Skip to content
Snippets Groups Projects
Commit bb6e768a authored by Maxime Graulich's avatar Maxime Graulich
Browse files

Use Trackball for rotation, scale around the start point and translate on the current 2D plane

parent 04940e24
No related branches found
No related tags found
No related merge requests found
/*
* (c) Copyright 1993, 1994, Silicon Graphics, Inc.
* ALL RIGHTS RESERVED
* Permission to use, copy, modify, and distribute this software for
* any purpose and without fee is hereby granted, provided that the above
* copyright notice appear in all copies and that both the copyright notice
* and this permission notice appear in supporting documentation, and that
* the name of Silicon Graphics, Inc. not be used in advertising
* or publicity pertaining to distribution of the software without specific,
* written prior permission.
*
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
*
* US Government Users Restricted Rights
* Use, duplication, or disclosure by the Government is subject to
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
* clause at DFARS 252.227-7013 and/or in similar or successor
* clauses in the FAR or the DOD or NASA FAR Supplement.
* Unpublished-- rights reserved under the copyright laws of the
* United States. Contractor/manufacturer is Silicon Graphics,
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
*
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
/*
* Trackball code:
*
* Implementation of a virtual trackball.
* Implemented by Gavin Bell, lots of ideas from Thant Tessman and
* the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.
*
* Vector manip code:
*
* Original code from:
* David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli
*
* Much mucking with by:
* Gavin Bell
*/
/*
* Modified for inclusion in Gmsh (rotmatrix as a vector +
* float->double + optional use of hyperbolic sheet for z-rotation)
*/
#include <math.h>
#include "Trackball.h"
#include <iostream>
/*
* This size should really be based on the distance from the center of
* rotation to the point on the object underneath the mouse. That
* point would then track the mouse as closely as possible. This is a
* simple example, though, so that is left as an Exercise for the
* Programmer.
*/
#define TRACKBALLSIZE (.8)
/*
* Local function prototypes (not defined in trackball.h)
*/
static double tb_project_to_sphere(double, double, double);
static void normalize_quat(double [4]);
using namespace std ;
void
vzero(double *v)
{
v[0] = 0.0;
v[1] = 0.0;
v[2] = 0.0;
}
void
vset(double *v, double x, double y, double z)
{
v[0] = x;
v[1] = y;
v[2] = z;
}
void
vsub(const double *src1, const double *src2, double *dst)
{
dst[0] = src1[0] - src2[0];
dst[1] = src1[1] - src2[1];
dst[2] = src1[2] - src2[2];
}
void
vcopy(const double *v1, double *v2)
{
register int i;
for (i = 0 ; i < 3 ; i++)
v2[i] = v1[i];
}
void
vcross(const double *v1, const double *v2, double *cross)
{
double temp[3];
temp[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]);
temp[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]);
temp[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]);
vcopy(temp, cross);
}
double
vlength(const double *v)
{
return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
}
void
vscale(double *v, double div)
{
v[0] *= div;
v[1] *= div;
v[2] *= div;
}
void
vnormal(double *v)
{
vscale(v,1.0/vlength(v));
}
double
vdot(const double *v1, const double *v2)
{
return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}
void
vadd(const double *src1, const double *src2, double *dst)
{
dst[0] = src1[0] + src2[0];
dst[1] = src1[1] + src2[1];
dst[2] = src1[2] + src2[2];
}
/*
* Ok, simulate a track-ball. Project the points onto the virtual
* trackball, then figure out the axis of rotation, which is the cross
* product of P1 P2 and O P1 (O is the center of the ball, 0,0,0)
* Note: This is a deformed trackball-- is a trackball in the center,
* but is deformed into a hyperbolic sheet of rotation away from the
* center. This particular function was chosen after trying out
* several variations.
*
* It is assumed that the arguments to this routine are in the range
* (-1.0 ... 1.0)
*/
void
trackball(double q[4], double p1x, double p1y, double p2x, double p2y)
{
double a[3]; /* Axis of rotation */
double phi; /* how much to rotate about axis */
double p1[3], p2[3], d[3];
double t;
if (p1x == p2x && p1y == p2y) {
/* Zero rotation */
vzero(q);
q[3] = 1.0;
return;
}
/*
* First, figure out z-coordinates for projection of P1 and P2 to
* deformed sphere
*/
vset(p1,p1x,p1y,tb_project_to_sphere(TRACKBALLSIZE,p1x,p1y));
vset(p2,p2x,p2y,tb_project_to_sphere(TRACKBALLSIZE,p2x,p2y));
/*
* Now, we want the cross product of P1 and P2
*/
vcross(p2,p1,a);
/*
* Figure out how much to rotate around that axis.
*/
vsub(p1,p2,d);
t = vlength(d);
/*
* Avoid problems with out-of-control values...
*/
if (t > 1.0) t = 1.0;
if (t < -1.0) t = -1.0;
phi = 2.0 * asin(t);
axis_to_quat(a,phi,q);
}
/*
* Given an axis and angle, compute quaternion.
*/
void axis_to_quat(double a[3], double phi, double q[4])
{
vnormal(a);
vcopy(a,q);
vscale(q,sin(phi/2.0));
q[3] = cos(phi/2.0);
}
/*
* Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
* if we are away from the center of the sphere.
*/
static double
tb_project_to_sphere(double r, double x, double y)
{
double d, t, z;
d = sqrt(x*x + y*y);
if (d < r ) {
z = sqrt(r*r - d*d);
} else {
z = 0.;
}
return z;
}
/*
* Given two rotations, e1 and e2, expressed as quaternion rotations,
* figure out the equivalent single rotation and stuff it into dest.
*
* This routine also normalizes the result every RENORMCOUNT times it is
* called, to keep error from creeping in.
*
* NOTE: This routine is written so that q1 or q2 may be the same
* as dest (or each other).
*/
#define RENORMCOUNT 97
void
add_quats(double q1[4], double q2[4], double dest[4])
{
static int count=0;
double t1[4], t2[4], t3[4];
double tf[4];
vcopy(q1,t1);
vscale(t1,q2[3]);
vcopy(q2,t2);
vscale(t2,q1[3]);
vcross(q2,q1,t3);
vadd(t1,t2,tf);
vadd(t3,tf,tf);
tf[3] = q1[3] * q2[3] - vdot(q1,q2);
dest[0] = tf[0];
dest[1] = tf[1];
dest[2] = tf[2];
dest[3] = tf[3];
if (++count > RENORMCOUNT) {
count = 0;
normalize_quat(dest);
}
}
/*
* Quaternions always obey: a^2 + b^2 + c^2 + d^2 = 1.0
* If they don't add up to 1.0, dividing by their magnitued will
* renormalize them.
*
* Note: See the following for more information on quaternions:
*
* - Shoemake, K., Animating rotation with quaternion curves, Computer
* Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985.
* - Pletinckx, D., Quaternion calculus as a basic tool in computer
* graphics, The Visual Computer 5, 2-13, 1989.
*/
static void
normalize_quat(double q[4])
{
int i;
double mag;
mag = (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
for (i = 0; i < 4; i++) q[i] /= mag;
}
/*
* Build a rotation matrix, given a quaternion rotation.
*
*/
void
build_rotmatrix(double m[16], double q[4])
{
m[0] = 1.0 - 2.0 * (q[1] * q[1] + q[2] * q[2]);
m[1] = 2.0 * (q[0] * q[1] - q[2] * q[3]);
m[2] = 2.0 * (q[2] * q[0] + q[1] * q[3]);
m[3] = 0.0;
m[4] = 2.0 * (q[0] * q[1] + q[2] * q[3]);
m[5]= 1.0 - 2.0 * (q[2] * q[2] + q[0] * q[0]);
m[6] = 2.0 * (q[1] * q[2] - q[0] * q[3]);
m[7] = 0.0;
m[8] = 2.0 * (q[2] * q[0] - q[1] * q[3]);
m[9] = 2.0 * (q[1] * q[2] + q[0] * q[3]);
m[10] = 1.0 - 2.0 * (q[1] * q[1] + q[0] * q[0]);
m[11] = 0.0;
m[12] = 0.0;
m[13] = 0.0;
m[14] = 0.0;
m[15] = 1.0;
}
/*
* (c) Copyright 1993, 1994, Silicon Graphics, Inc.
* ALL RIGHTS RESERVED
* Permission to use, copy, modify, and distribute this software for
* any purpose and without fee is hereby granted, provided that the above
* copyright notice appear in all copies and that both the copyright notice
* and this permission notice appear in supporting documentation, and that
* the name of Silicon Graphics, Inc. not be used in advertising
* or publicity pertaining to distribution of the software without specific,
* written prior permission.
*
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
*
* US Government Users Restricted Rights
* Use, duplication, or disclosure by the Government is subject to
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
* clause at DFARS 252.227-7013 and/or in similar or successor
* clauses in the FAR or the DOD or NASA FAR Supplement.
* Unpublished-- rights reserved under the copyright laws of the
* United States. Contractor/manufacturer is Silicon Graphics,
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
*
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
/*
* trackball.h
* A virtual trackball implementation
* Written by Gavin Bell for Silicon Graphics, November 1988.
*/
/*
* Pass the x and y coordinates of the last and current positions of
* the mouse, scaled so they are from (-1.0 ... 1.0).
*
* The resulting rotation is returned as a quaternion rotation in the
* first paramater.
*/
void
trackball(double q[4], double p1x, double p1y, double p2x, double p2y);
/*
* Given two quaternions, add them together to get a third quaternion.
* Adding quaternions to get a compound rotation is analagous to adding
* translations to get a compound translation. When incrementally
* adding rotations, the first argument here should be the new
* rotation, the second and third the total rotation (which will be
* over-written with the resulting new total rotation).
*/
void
add_quats(double *q1, double *q2, double *dest);
/*
* A useful function, builds a rotation matrix in Matrix based on
* given quaternion.
*/
void
build_rotmatrix(double m[16], double q[4]);
/*
* This function computes a quaternion based on an axis (defined by
* the given vector) and an angle about which to rotate. The angle is
* expressed in radians. The result is put into the third argument.
*/
void
axis_to_quat(double a[3], double phi, double q[4]);
double trackballsize() ;
...@@ -14,7 +14,7 @@ ...@@ -14,7 +14,7 @@
#include <gmsh/PViewOptions.h> #include <gmsh/PViewOptions.h>
#include "androidGModel.h" #include "androidGModel.h"
#include "drawGModel.h" #include "drawContext.h"
onelab::server *getOnelab() {return onelab::server::instance();} onelab::server *getOnelab() {return onelab::server::instance();}
...@@ -32,6 +32,7 @@ class MobileMessage : public GmshMessage ...@@ -32,6 +32,7 @@ class MobileMessage : public GmshMessage
{ {
if(level == "Error") if(level == "Error")
{ {
LOGE("%s", message.c_str());
if(message.size() <= 26 || message.substr(message.size()-25,25) != "check the log for details") if(message.size() <= 26 || message.substr(message.size()-25,25) != "check the log for details")
return; return;
if(!gCallbackObject) if(!gCallbackObject)
...@@ -48,15 +49,12 @@ class MobileMessage : public GmshMessage ...@@ -48,15 +49,12 @@ class MobileMessage : public GmshMessage
env->CallVoidMethod(gCallbackObject, mid, jstr); env->CallVoidMethod(gCallbackObject, mid, jstr);
env->DeleteLocalRef(jstr); env->DeleteLocalRef(jstr);
env->DeleteLocalRef(jClass); env->DeleteLocalRef(jClass);
LOGE("%s", message.c_str());
return; return;
} }
else if(level == "Progress") else if(level == "Progress")
{ {
if(!gCallbackObject) if(!gCallbackObject)
return; return;
//if ((gJavaVM->GetEnv((void**)&env, JNI_VERSION_1_6)) < 0)
// return;
if ((gJavaVM->AttachCurrentThread(&env, NULL)) < 0) if ((gJavaVM->AttachCurrentThread(&env, NULL)) < 0)
return; return;
jstring jstr = env->NewStringUTF(message.c_str()); jstring jstr = env->NewStringUTF(message.c_str());
...@@ -76,7 +74,7 @@ class MobileMessage : public GmshMessage ...@@ -76,7 +74,7 @@ class MobileMessage : public GmshMessage
requestRender(); requestRender();
return; return;
} }
LOGI("%s", message.c_str()); LOGI("%s:\t%s", level.c_str(), message.c_str());
} }
}; };
...@@ -109,47 +107,37 @@ JNIEXPORT jlong JNICALL Java_org_geuz_onelab_Gmsh_init ...@@ -109,47 +107,37 @@ JNIEXPORT jlong JNICALL Java_org_geuz_onelab_Gmsh_init
Msg::SetCallback(new MobileMessage()); Msg::SetCallback(new MobileMessage());
const char* name = env->GetStringUTFChars(jname, NULL); const char* name = env->GetStringUTFChars(jname, NULL);
return reinterpret_cast<jlong>(new drawGModel()); return reinterpret_cast<jlong>(new drawContext());
} }
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_loadFile JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_loadFile
(JNIEnv *env, jobject obj, jlong jptr, jstring jname) (JNIEnv *env, jobject obj, jlong jptr, jstring jname)
{ {
const char* filename = env->GetStringUTFChars(jname, NULL); const char* filename = env->GetStringUTFChars(jname, NULL);
((drawGModel *)jptr)->load(filename); ((drawContext *)jptr)->load(filename);
} }
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_initView JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_initView
(JNIEnv *env, jobject obj, jlong jptr, jint w, jint h) (JNIEnv *env, jobject obj, jlong jptr, jint w, jint h)
{ {
((drawGModel *)jptr)->initView(w,h); ((drawContext *)jptr)->initView(w,h);
} }
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_drawView JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_drawView
(JNIEnv *env, jobject obj, jlong jptr) (JNIEnv *env, jobject obj, jlong jptr)
{ {
((drawGModel *)jptr)->drawView(); ((drawContext *)jptr)->drawView();
}
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setTranslation
(JNIEnv *env, jobject obj, jlong jptr, jfloat tx, jfloat ty, jfloat tz)
{
((drawGModel *)jptr)->setTranslation(tx, ty, tz);
}
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setScale
(JNIEnv *env, jobject obj, jlong jptr, jfloat sx, jfloat sy, jfloat sz)
{
((drawGModel *)jptr)->setScale(sx, sy, sz);
} }
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setRotate JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_eventHandler
(JNIEnv *env, jobject obj, jlong jptr, jfloat rx, jfloat ry, jfloat rz) (JNIEnv *env, jobject obj, jlong jptr, jint jevent, jfloat jx, jfloat jy)
{ {
((drawGModel *)jptr)->setRotation(rx, ry, rz); ((drawContext *)jptr)->eventHandler(jevent, jx, jy);
} }
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setShow JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setShow
(JNIEnv *env, jobject obj, jlong jptr, jstring jwhat, jboolean value) (JNIEnv *env, jobject obj, jlong jptr, jstring jwhat, jboolean value)
{ {
const char* what = env->GetStringUTFChars(jwhat, NULL); const char* what = env->GetStringUTFChars(jwhat, NULL);
if(strcmp(what, "mesh") == 0) if(strcmp(what, "mesh") == 0)
((drawGModel *)jptr)->showMesh(value); ((drawContext *)jptr)->showMesh(value);
else if(strcmp(what, "geom") == 0) else if(strcmp(what, "geom") == 0)
((drawGModel *)jptr)->showGeom(value); ((drawContext *)jptr)->showGeom(value);
} }
JNIEXPORT jlong JNICALL Java_org_geuz_onelab_Gmsh_getOnelabInstance JNIEXPORT jlong JNICALL Java_org_geuz_onelab_Gmsh_getOnelabInstance
(JNIEnv *env , jobject obj) (JNIEnv *env , jobject obj)
......
...@@ -5,6 +5,7 @@ ...@@ -5,6 +5,7 @@
#ifndef _Included_org_geuz_onelab_Gmsh #ifndef _Included_org_geuz_onelab_Gmsh
#define _Included_org_geuz_onelab_Gmsh #define _Included_org_geuz_onelab_Gmsh
void requestRender(); void requestRender();
unsigned char *getBitmapFromString(const char *text);
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
...@@ -42,27 +43,11 @@ JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_drawView ...@@ -42,27 +43,11 @@ JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_drawView
/* /*
* Class: org_geuz_onelab_Gmsh * Class: org_geuz_onelab_Gmsh
* Method: setTranslation * Method: eventHandler
* Signature: (JFFF)V * Signature: (JIFF)V
*/ */
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setTranslation JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_eventHandler
(JNIEnv *, jobject, jlong, jfloat, jfloat, jfloat); (JNIEnv *, jobject, jlong, jint, jfloat, jfloat);
/*
* Class: org_geuz_onelab_Gmsh
* Method: setScale
* Signature: (JFFF)V
*/
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setScale
(JNIEnv *, jobject, jlong, jfloat, jfloat, jfloat);
/*
* Class: org_geuz_onelab_Gmsh
* Method: setRotate
* Signature: (JFFF)V
*/
JNIEXPORT void JNICALL Java_org_geuz_onelab_Gmsh_setRotate
(JNIEnv *, jobject, jlong, jfloat, jfloat, jfloat);
/* /*
* Class: org_geuz_onelab_Gmsh * Class: org_geuz_onelab_Gmsh
......
#if !defined(BUILD_ANDROID)
#define BUILD_IOS 1
#endif
#include <map>
#if defined(BUILD_IOS)
#include <OpenGLES/ES1/gl.h>
#include <OpenGLES/ES1/glext.h>
#include <Gmsh/Gmsh.h>
#include <Gmsh/GModel.h>
#include <Gmsh/MElement.h>
#include <Gmsh/VertexArray.h>
#include <Gmsh/onelab.h>
#include <Gmsh/onelabUtils.h>
#include <Gmsh/PView.h>
#include <Gmsh/PViewOptions.h>
#include <Gmsh/Context.h>
#include <Gmsh/StringUtils.h>
#include <GetDP/GetDP.h>
#endif
#if defined(BUILD_ANDROID)
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <gmsh/Gmsh.h>
#include <gmsh/GModel.h>
#include <gmsh/MElement.h>
#include <gmsh/VertexArray.h>
#include <gmsh/onelab.h>
#include <gmsh/onelabUtils.h>
#include <gmsh/PView.h>
#include <gmsh/PViewOptions.h>
#include <gmsh/Context.h>
#include <gmsh/StringUtils.h>
#include <getdp/GetDP.h>
#include "androidGModel.h"
#endif
#include "drawContext.h"
#include "Trackball.h"
static bool locked = false;
drawContext::drawContext()
{
new GModel();
GmshInitialize();
GmshSetOption("Mesh", "SurfaceFaces", 1.);
GmshSetOption("General", "Terminal", 1.);
#ifdef DEBUG
GmshSetOption("General", "Verbosity", 99.);
#else
GmshSetOption("General", "Verbosity", 10.);
#endif
onelabUtils::setFirstComputationFlag(false);
for(int i = 0; i < 3; i++){
_translate[i] = 0.;
_scale[i] = 1.;
}
setQuaternion(0., 0., 0., 1.);
_fillMesh = false;
_showMesh = false;
_showGeom = true;
_gradiant = true;
}
static void checkGlError(const char* op) {
for (GLint error = glGetError(); error; error = glGetError())
Msg::Error("%s: glError (0x%x)",op,error);
}
void drawContext::load(std::string filename)
{
if(locked) return;
// clear previous GModel, onelab datas and PView
GModel::list.clear();
PView::list.clear();
onelab::server::instance()->clear();
// open the file with Gmsh
GmshOpenProject(filename);
// run getdp witout parameter
onelab_cb("check");
// to allow the firs run
onelab::server::instance()->setChanged(true, "Gmsh");
onelab::server::instance()->setChanged(true, "GetDP");
}
void drawContext::eventHandler(int event, float x, float y)
{
this->_current.set(this->_scale, this->_translate, this->_right, this->_left, this->_bottom, this->_top, this->_width, this->_height, x, y);
switch(event)
{
case 0: // finger(s) press the screen
// in this case x and y represent the start point
this->_start.set(this->_scale, this->_translate, this->_right, this->_left, this->_bottom, this->_top, this->_width, this->_height, x, y);
this->_previous.set(this->_scale, this->_translate, this->_right, this->_left, this->_bottom, this->_top, this->_width, this->_height, x, y);
break;
case 1: // finger move (translate)
// in this case x and y represent the current point
_translate[0] += (this->_current.wnr[0] - this->_previous.wnr[0]);
_translate[1] += (this->_current.wnr[1] - this->_previous.wnr[1]);
_translate[2] = 0.;
break;
case 2: // fingers move (scale)
// in this case we don't care about previous and current position, x represent the scale
this->_scale[0] = this->_scale[1] = this->_scale[2] = x;
this->_start.recenter(this->_scale, this->_translate); // FIXME somethink change the value of win
break;
case 3: // fingers move (rotate)
this->addQuaternion((2. * this->_previous.win[0] - this->_width) / this->_width,
(this->_height - 2. * this->_previous.win[1]) / this->_height,
(2. * this->_current.win[0] - this->_width) / this->_width,
(this->_height - 2. * this->_current.win[1]) / this->_height);
break;
case 4: // release the finger(s)
// Do nothink ?
break;
default: // all other reset the position
setQuaternion(0., 0., 0., 1.);
for(int i = 0; i < 3; i++){
_translate[i] = 0.;
_scale[i] = 1.;
}
break;
}
this->_previous.set(this->_scale, this->_translate, this->_right, this->_left, this->_bottom, this->_top, this->_width, this->_height, x, y);
}
void drawContext::setQuaternion(double q0, double q1, double q2, double q3)
{
this->_quaternion[0] = q0;
this->_quaternion[1] = q1;
this->_quaternion[2] = q2;
this->_quaternion[3] = q3;
}
void drawContext::addQuaternion(double p1x, double p1y, double p2x, double p2y)
{
double quat[4];
trackball(quat, p1x, p1y, p2x, p2y);
add_quats(quat, this->_quaternion, this->_quaternion);
}
void drawContext::buildRotationMatrix()
{
build_rotmatrix(_rotate, _quaternion);
for(int i=0; i<16;i++)
_rotatef[i] = (float)_rotate[i];
}
void drawContext::OrthofFromGModel()
{
SBoundingBox3d bb = GModel::current()->bounds();
double ratio = (double)(this->_width ? this->_width : 1.) / (double)(this->_height ? this->_height : 1.);
double modelh = bb.max().y() - bb.min().y(), modelw = bb.max().x() - bb.min().x();
double modelratio = (modelw ? modelw : 1.) / (modelh ? modelh : 1.);
double xmin = -ratio, xmax = ratio, ymin = -1., ymax = 1.;
xmin = bb.min().x();
xmax = bb.max().x();
ymin = bb.min().x() / ratio;
ymax = bb.max().x() / ratio;
xmax += (xmax - xmin) / 5.;
xmin -= (xmax - xmin) / 5.;
ymax += (ymax - ymin) / 5.;
ymin -= (ymax - ymin) / 5.;
// clipping
double zmax = std::max(fabs(bb.min().z()), fabs(bb.max().z()));
double clip = zmax * 5.;
clip = 1.;
GLint matrixMode;
glGetIntegerv(GL_MATRIX_MODE, &matrixMode);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
this->_left = (xmin != 0 || xmax != 0)? xmin : -ratio;
this->_right = (xmin != 0 || xmax != 0)? xmax : ratio;
this->_top = (xmin != 0 || xmax != 0)? ymax : 1.0;
this->_bottom = (xmin != 0 || xmax != 0)? ymin : -1.0;
glOrthof(this->_left, this->_right, this->_bottom, this->_top, -clip, clip);
glMatrixMode(matrixMode);
}
void drawContext::initView(int w, int h)
{
this->_height = h;
this->_width = w;
glViewport(0, 0, w, h);
this->OrthofFromGModel();
glClearColor(.83,.85,.98,1.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void drawArray(VertexArray *va, GLint type, bool colorArray=false)
{
if(!va) return;
glEnable(GL_BLEND);
glEnable(GL_RESCALE_NORMAL);
glShadeModel(GL_SMOOTH);
glVertexPointer(3, GL_FLOAT, 0, va->getVertexArray());
glEnableClientState(GL_VERTEX_ARRAY);
glNormalPointer(GL_BYTE, 0, va->getNormalArray());
glEnableClientState(GL_NORMAL_ARRAY);
if(colorArray)
{
glColorPointer(4, GL_UNSIGNED_BYTE, 0, va->getColorArray());
glEnableClientState(GL_COLOR_ARRAY);
}
glDrawArrays(type, 0, va->getNumVertices());
glDisable(GL_POLYGON_OFFSET_FILL);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_RESCALE_NORMAL);
glDisable(GL_BLEND);
}
void drawVector(double x, double y, double z, double dx, double dy, double dz)
{
double l = sqrt(dx * dx + dy * dy + dz * dz), lt;
double n[3], t[3], u[3];
if(l == 0.0) return;
GLfloat line[] = {
(GLfloat)x, (GLfloat)y, (GLfloat)z,
(GLfloat)(x+dx), (GLfloat)(y+dy), (GLfloat)(z+dz),
};
glVertexPointer(3, GL_FLOAT, 0, line);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_LINES, 0, 2);
glDisableClientState(GL_VERTEX_ARRAY);
n[0] = dx / l;
n[1] = dy / l;
n[2] = dz / l;
if((fabs(n[0]) >= fabs(n[1]) && fabs(n[0]) >= fabs(n[2])) ||
(fabs(n[1]) >= fabs(n[0]) && fabs(n[1]) >= fabs(n[2]))) {
t[0] = n[1];
t[1] = -n[0];
t[2] = 0.;
}
else {
t[0] = 0.;
t[1] = n[2];
t[2] = -n[1];
}
lt = sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
t[0] /= lt;
t[1] /= lt;
t[2] /= lt;
u[0] = n[1] * t[2] - n[2] * t[1];
u[1] = n[2] * t[0] - n[0] * t[2];
u[2] = n[0] * t[1] - n[1] * t[0];
lt = sqrt(u[0] * u[0] + u[1] * u[1] + u[2] * u[2]);
u[0] /= lt;
u[1] /= lt;
u[2] /= lt;
double f1 = 0.75; // Stem lenght
double b = 0.1 * l;
GLfloat arrow[] = {
(GLfloat)(x + dx), (GLfloat)(y + dy), (GLfloat)(z + dz),
(GLfloat)(x + f1 * dx + b * (t[0])), (GLfloat)(y + f1 * dy + b * (t[1])), (GLfloat)(z + f1 * dz + b * (t[2])),
(GLfloat)(x + f1 * dx + b * (-t[0])), (GLfloat)(y + f1 * dy + b * (-t[1])), (GLfloat)(z + f1 * dz + b * (-t[2])),
(GLfloat)(x + dx), (GLfloat)(y + dy), (GLfloat)(z + dz),
(GLfloat)(x + f1 * dx + b * (-u[0])), (GLfloat)(y + f1 * dy + b * (-u[1])), (GLfloat)(z + f1 * dz + b * (-u[2])),
(GLfloat)(x + f1 * dx + b * (u[0])), (GLfloat)(y + f1 * dy + b * (u[1])), (GLfloat)(z + f1 * dz + b * (u[2])),
};
glVertexPointer(3, GL_FLOAT, 0, arrow);
glEnableClientState(GL_VERTEX_ARRAY);
glEnable(GL_LINE_SMOOTH);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_LINE_SMOOTH);
}
void drawContext::drawVectorArray(PViewOptions *opt, VertexArray *va)
{
if(!va || va->getNumVerticesPerElement() != 2) return;
for(int i = 0; i < va->getNumVertices(); i += 2){
float *s = va->getVertexArray(3 * i);
float *v = va->getVertexArray(3 * (i + 1));
double l = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
double lmax = opt->tmpMax;
if((l && opt->vectorType) && lmax)
{
double scale = (opt->arrowSizeMax - opt->arrowSizeMin) / lmax;
if(opt->arrowSizeMin && l) scale += opt->arrowSizeMin / l;
double dx = scale * v[0];
double dy = scale * v[1];
double dz = scale * v[2];
GLubyte *color = (GLubyte *)va->getColorArray(4 * i);
glColor4ub(*(color), *(color+1), *(color+2), *(color+3));
if(fabs(dx) > 1. || fabs(dy) > 1. || fabs(dz) > 1.)
{
double d = (this->_right - this->_left) / this->_width / _scale[0];
dx *= d; dy *= d; dz *= d;
double x = s[0], y = s[1], z = s[2];
drawVector(x,y,z,dx,dy,dz);
}
}
}
}
void drawContext::drawPView(PView *p)
{
PViewOptions *opt = p->getOptions();
PViewData *data = p->getData(true);
if(!opt->visible) return;
glPointSize((GLfloat)opt->pointSize);
glLineWidth((GLfloat)opt->lineWidth);
drawArray(p->va_points, GL_POINTS,true);
drawArray(p->va_lines, GL_LINES,true);
drawArray(p->va_triangles, GL_TRIANGLES,true);
glLineWidth(1);
glPointSize(1);
drawVectorArray(p->getOptions(), p->va_vectors);
}
void drawContext::drawScale()
{
glPushMatrix();
glLoadIdentity();
// Draw the scale bar
if(PView::list.size() < 1) return;
PView *p = PView::list[PView::list.size()-1];
PViewOptions *opt = p->getOptions();
double width = 6*(this->_right -this->_left) / 10.;
double height = (this->_top - this->_bottom) / 20.;
double box = width / (opt->nbIso ? opt->nbIso : 1);
double xmin = this->_left + (this->_right - this->_left -width)/2.;
double ymin = this->_bottom + height;
GLfloat *vertex = (GLfloat *)malloc(opt->nbIso*3*4*sizeof(GLfloat));
GLubyte *color = (GLubyte *)malloc(opt->nbIso*4*4*sizeof(GLubyte));
for(int i = 0; i < opt->nbIso; i++){
if(opt->intervalsType == PViewOptions::Discrete || opt->intervalsType == PViewOptions::Numeric)
{
unsigned int col = opt->getColor(i, opt->nbIso);
color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col);
color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col);
color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col);
color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + height;
vertex[i*3*4+5] = 0.;
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + height;
vertex[i*3*4+11] = 0.;
}
else if(opt->intervalsType == PViewOptions::Continuous)
{
double dv = (opt->tmpMax - opt->tmpMin) / (opt->nbIso ? opt->nbIso : 1);
double v1 = opt->tmpMin + i * dv;
unsigned int col1 = opt->getColor(v1, opt->tmpMin, opt->tmpMax, true);
color[i*4*4+0] = color[i*4*4+4] = (GLubyte)CTX::instance()->unpackRed(col1);
color[i*4*4+1] = color[i*4*4+5] = (GLubyte)CTX::instance()->unpackGreen(col1);
color[i*4*4+2] = color[i*4*4+6] = (GLubyte)CTX::instance()->unpackBlue(col1);
color[i*4*4+3] = color[i*4*4+7] = (GLubyte)CTX::instance()->unpackAlpha(col1);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + height;
vertex[i*3*4+5] = 0.;
double v2 = opt->tmpMin + (i + 1) * dv;
unsigned int col2 = opt->getColor(v2, opt->tmpMin, opt->tmpMax, true);
color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col2);
color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col2);
color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col2);
color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col2);
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + height;
vertex[i*3*4+11] = 0.;
}
else
{
unsigned int col = opt->getColor(i, opt->nbIso);
color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col);
color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col);
color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col);
color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + height;
vertex[i*3*4+5] = 0.;
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + height;
vertex[i*3*4+11] = 0.;
}
}
glVertexPointer(3, GL_FLOAT, 0, vertex);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
glEnableClientState(GL_COLOR_ARRAY);
if(opt->intervalsType == PViewOptions::Discrete || opt->intervalsType == PViewOptions::Numeric || opt->intervalsType == PViewOptions::Continuous)
glDrawArrays(GL_TRIANGLE_STRIP, 0, opt->nbIso*4);
else
glDrawArrays(GL_LINES, 0, opt->nbIso*4);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
free(vertex);
free(color);
glPopMatrix();
}
void drawContext::drawMesh()
{
GModel::current()->fillVertexArrays();
glColor4f(0,0,0,1.);
for(GModel::fiter it = GModel::current()->firstFace(); it != GModel::current()->lastFace(); it++){
if(_fillMesh) drawArray((*it)->va_triangles, GL_TRIANGLES);
else drawArray((*it)->va_lines, GL_LINES);
}
}
void drawContext::drawPost()
{
if(PView::list.empty()) return ;
for(unsigned int i = 0; i < PView::list.size(); i++){
PView::list[i]->fillVertexArrays();
drawPView(PView::list[i]);
}
}
void drawContext::drawGeom()
{
glColor4f(0,0,1.,1.);
glLineWidth(3);
for(GModel::eiter it = GModel::current()->firstEdge(); it != GModel::current()->lastEdge(); it++){
GEdge *e = *it;
int N = e->minimumDrawSegments() + 1;
Range<double> t_bounds = e->parBounds(0);
double t_min = t_bounds.low();
double t_max = t_bounds.high();
// Create a VA for this edge
GLfloat edge[N*3];
for(unsigned int i=0; i < N; i++) {
double t = t_min + (double)i / (double)(N-1) * (t_max - t_min);
GPoint p = e->point(t);
edge[i*3] = p.x(); edge[i*3+1] = p.y(); edge[i*3+2] = p.z();
}
// Then print the VA
glVertexPointer(3, GL_FLOAT, 0, edge);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_LINE_STRIP, 0, N);
glDisableClientState(GL_VERTEX_ARRAY);
}
glLineWidth(1);
}
void drawContext::drawAxes(double x0, double y0, double z0, double h)
{
glLineWidth(5);
glPushMatrix();
glLoadIdentity();
glTranslatef(x0, y0, z0);
glMultMatrixf(_rotatef);
glTranslatef(-x0, -y0, -z0);
const GLfloat axes[] = {
(GLfloat)x0, (GLfloat)y0, (GLfloat)z0,
(GLfloat)(x0+h), (GLfloat)y0, (GLfloat)z0,
(GLfloat)x0, (GLfloat)y0, (GLfloat)z0,
(GLfloat)x0, (GLfloat)(y0+h), (GLfloat)z0,
(GLfloat)x0, (GLfloat)y0, (GLfloat)z0,
(GLfloat)x0, (GLfloat)y0, (GLfloat)(z0+h),
};
const GLubyte colors[] = {
255, 0, 0, 255,
255, 0, 0, 255,
0, 0, 255, 255,
0, 0, 255, 255,
0, 255, 0, 255,
0, 255, 0, 255,
};
glVertexPointer(3, GL_FLOAT, 0, axes);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_LINES, 0, 6);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glPopMatrix();
glLineWidth(1);
}
void drawContext::drawView()
{
this->OrthofFromGModel();
glMatrixMode(GL_MODELVIEW);
// fill the background
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(_gradiant)
{
glPushMatrix();
glLoadIdentity();
const GLfloat squareVertices[] = {
(GLfloat)this->_top, (GLfloat)this->_left, -5.,
(GLfloat)this->_top, (GLfloat)this->_right, -5.,
(GLfloat)this->_bottom, (GLfloat)this->_left, -5.,
(GLfloat)this->_bottom, (GLfloat)this->_right, -5.,
};
const GLubyte squareColors[] = {
255, 255, 255, 255,
255, 255, 255, 255,
190, 200, 255, 255,
190, 200, 255, 255,
};
glVertexPointer(3, GL_FLOAT, 0, squareVertices);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, squareColors);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glPopMatrix();
}
checkGlError("Draw background");
//
glLoadIdentity();
glScalef(_scale[0], _scale[1], _scale[2]);
glTranslatef(_translate[0], _translate[1], _translate[2]);
this->buildRotationMatrix();
glMultMatrixf(_rotatef);
//glTranslatef(this->_translate[0]/this->_height,this->_translate[1]/this->_width,0);
//glScalef(this->_scale[0], this->_scale[1], this->_scale[2]);
checkGlError("Initialize position");
//
this->drawAxes(this->_right - (this->_top - this->_bottom)/9.0, this->_bottom + (this->_top - this->_bottom)/9.0, 0, (this->_top - this->_bottom)/10.);
this->drawPost();
if(_showGeom) this->drawGeom();
if(_showMesh) this->drawMesh();
//this->drawScale();
checkGlError("Draw model,post-pro,...");
}
std::vector<std::string> commandToVector(const std::string cmd)
{
std::vector<std::string> ret;
int pos=0, last=0;
while((pos = cmd.find("-", last+1)) != std::string::npos)
{
ret.push_back(cmd.substr(last,pos-1-last));
last = pos;
}
ret.push_back(cmd.substr(last,cmd.size()-1));
return ret;
}
int onelab_cb(std::string action)
{
Msg::Debug("Ask onlab to %s", action.c_str());
if(action == "stop")
{
onelab::string o("GetDP/Action", "stop");
o.setVisible(false);
o.setNeverChanged(true);
onelab::server::instance()->set(o);
return 0;
}
if(locked) return -1;
locked = true;
int redraw = 0;
if(action == "reset")
{
onelab::server::instance()->clear();
onelabUtils::runGmshClient(action, true);
action = "check";
}
Msg::ResetErrorCounter();
if(action == "compute")
{
onelabUtils::initializeLoop("1");
onelabUtils::initializeLoop("2");
onelabUtils::initializeLoop("3");
}
do
{
if(onelabUtils::runGmshClient(action, true))
redraw = 1;
if(redraw == 0 && !onelab::server::instance()->getChanged("GetDP"))continue;
std::vector<onelab::string> ps;
onelab::server::instance()->get(ps, "GetDP/1ModelName");
if(ps.empty()){
std::vector<std::string> split = SplitFileName(GModel::current()->getFileName());
std::string name(split[0] + split[1]);
onelab::string o("GetDP/1ModelName", name, "Model name");
o.setKind("file");
onelab::server::instance()->set(o);
}
onelab::string o("GetDP/Action", action);
o.setVisible(false);
o.setNeverChanged(true);
onelab::server::instance()->set(o);
if(action == "compute" && (onelab::server::instance()->getChanged("Gmsh") || onelab::server::instance()->getChanged("GetDP")))
{
std::string filename = GModel::current()->getFileName();
std::vector<std::string> args;
args.push_back("getdp");
std::vector<onelab::string> onelabArgs;
onelab::server::instance()->get(onelabArgs, "GetDP/1ModelName");
args.push_back((onelabArgs.empty())? SplitFileName(filename)[0] + SplitFileName(filename)[1] : onelabArgs[0].getValue());
onelab::server::instance()->get(onelabArgs, "GetDP/9ComputeCommand");
std::vector<std::string> compute = commandToVector((onelabArgs.empty())? "" : onelabArgs[0].getValue().c_str());
args.insert( args.end(), compute.begin(), compute.end() );
args.push_back("-onelab");
args.push_back("GetDP");
GetDP(args, onelab::server::instance());
}
if(action == "check" && (onelab::server::instance()->getChanged("Gmsh") || onelab::server::instance()->getChanged("GetDP")))
{
std::string filename = GModel::current()->getFileName();
std::vector<std::string> args;
args.push_back("getdp");
std::vector<onelab::string> onelabArgs;
args.push_back(SplitFileName(filename)[0] + SplitFileName(filename)[1]);
onelab::server::instance()->get(onelabArgs, "GetDP/9CheckCommand");
args.push_back((onelabArgs.empty())? "" : onelabArgs[0].getValue());
args.push_back("-onelab");
args.push_back("GetDP");
GetDP(args, onelab::server::instance());
}
} while(action == "compute" && (onelabUtils::incrementLoop("3") || onelabUtils::incrementLoop("2") || onelabUtils::incrementLoop("1")));
locked = false;
return redraw;
}
// vim:set ts=2:
#ifndef _DRAW_GMODEL_H_
#define _DRAW_GMODEL_H_
#if !defined(BUILD_ANDROID)
#define BUILD_IOS 1
#endif
#include <string>
#if defined(BUILD_IOS)
#include <Gmsh/PView.h>
#include <Gmsh/PViewOptions.h>
#include <Gmsh/Context.h>
#endif
#include "movePosition.h"
int onelab_cb(const std::string);
class drawContext{
private:
float _translate[3], _scale[3]; // current translation and scale
double _rotate[16]; // current rotation matrix (double for Trackball)
float _rotatef[16]; // current rotation matrix (float for OpenGL ES)
double _quaternion[4]; // current quaternion used for rotation
movePosition _start, _previous, _current; // store informations about user interactions
int _width, _height; // size of OpenGL context in pixel
float _left, _right, _top, _bottom; // value of "border"
bool _gradiant, // show the background gradiant
_showGeom, // show the Geometry
_showMesh, // show the Mesh
_fillMesh; // fill the Mesh
void OrthofFromGModel(void);
void drawPView(PView *p);
void drawVectorArray(PViewOptions *opt, VertexArray *va);
public:
drawContext();
~drawContext(){}
void load(std::string filename);
void eventHandler(int event, float x=0, float y=0);
void setQuaternion(double q0, double q1, double q2, double q3);
void addQuaternion(double p1x, double p1y, double p2x, double p2y);
void buildRotationMatrix();
void setTranslate(int i, float t) {if(i>=0 && i<3) this->_translate[i] = t;}
float getTranslate(int i) {if(i>=0 && i<3) return this->_translate[i]; return 0;}
void setScale(int i, float s) {if(i>=0 && i<3) this->_scale[i] = s;}
float getScale(int i) {if(i>=0 && i<3) return this->_scale[i]; return 0;}
void initView(int w, int h);
void drawView();
void drawAxes(double x0=0., double y0=0., double z0=0., double h=0.5);
void drawGeom();
void drawMesh();
void drawPost();
void drawScale();
void useGradiant(bool gradiant=true) {_gradiant = gradiant;}
void showGeom(bool show=true) {_showGeom = show;}
void showMesh(bool show=true) {_showMesh = show;}
void fillMesh(bool show=true) {_fillMesh = show;}
bool isShowedMesh(){return _showMesh;}
bool isShowedGeom(){return _showGeom;}
};
#endif
class movePosition {
public:
float win[3]; // window coordinates
float wnr[3]; // world coordinates BEFORE rotation
float s[3]; // scaling state when the event was recorded
float t[3]; // translation state when the event was recorded
movePosition()
{
for(int i = 0; i < 3; i++)
win[i] = wnr[i] = s[i] = t[i] = 0.;
}
movePosition(const movePosition &instance)
{
for(int i = 0; i < 3; i++){
win[i] = instance.win[i];
wnr[i] = instance.wnr[i];
s[i] = instance.s[i];
t[i] = instance.t[i];
}
}
void set(float scale[3], float translate[3], float vxmax, float vxmin, float vymin, float vymax, int width, int height, int x, int y)
{
for(int i = 0; i < 3; i++){
s[i] = scale[i];
t[i] = translate[i];
}
win[0] = (float)x;
win[1] = (float)y;
win[2] = 0.;
wnr[0] =
(vxmin + win[0] / (float)width * (vxmax - vxmin)) / scale[0] - translate[0];
wnr[1] =
(vymax - win[1] / (float)height * (vymax - vymin)) / scale[1] - translate[1];
wnr[2] = 0.;
}
void recenter(float scale[3], float translate[3]) const
{
// compute the equivalent translation to apply *after* the scaling so that
// the scaling is done around the point which was clicked:
translate[0] = t[0] * (s[0] / scale[0]) - wnr[0] * (1. - (s[0] / scale[0]));
translate[1] = t[1] * (s[1] / scale[1]) - wnr[1] * (1. - (s[1] / scale[1]));
}
};
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment