void animateCamera() {
pScene sc;
pCamera c;
double dazim,delev,azim,elev;
float cfelev,cfazim;
if ( !animate || !ctracking ) return;
sc = cv.scene[currentScene()];
c = sc->camera;
azim = Azimuth(c);
elev = Elevation(c);
switch (cbutton) {
case GLUT_LEFT_BUTTON:
cfelev = 3.0;
cfazim = 3.0;
delev = 2.0*(cury-starty)/(float)sc->par.ys;
dazim = 2.0*(curx-startx)/(float)sc->par.xs;
if ( delev >= 0.0 ) delev *= delev;
else delev = -delev*delev;
if ( dazim >= 0.0 ) dazim *= dazim;
else dazim = -dazim*dazim;
elev += cfelev * delev;
azim -= cfazim * dazim;
break;
case GLUT_MIDDLE_BUTTON:
break;
case GLUT_BUTTON_3:
puts("button3");
break;
case GLUT_BUTTON_4:
puts("button4");
break;
}
updateCamera(sc,c,azim,elev);
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
void motionCamera(int x,int y) {
pScene sc;
pCamera c;
double dazim,delev,azim,elev;
float cfelev,cfazim;
/* keep current pos */
curx = x;
cury = y;
if ( animate ) return;
sc = cv.scene[currentScene()];
c = sc->camera;
azim = Azimuth(c);
elev = Elevation(c);
switch (cbutton) {
case GLUT_LEFT_BUTTON:
cfelev = 50.0;
cfazim = 50.0;
delev = cfelev * (y-starty)/(float)sc->par.ys;
dazim = cfazim * (x-startx)/(float)sc->par.xs;
startx = x;
starty = y;
elev += delev;
azim -= dazim;
break;
case GLUT_MIDDLE_BUTTON:
break;
case GLUT_BUTTON_3:
puts("button3");
break;
case GLUT_BUTTON_4:
puts("button4");
break;
}
updateCamera(sc,c,azim,elev);
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
void setupView (pScene sc) {
pScene slave;
pMesh mesh;
pTransform view;
pPersp p;
pCamera c;
/* default */
if (ddebug) fprintf(stdout, "setupView\n");
mesh = cv.mesh[sc->idmesh];
view = sc->view;
p = sc->persp;
c = sc->camera;
/* init transformation matrix */
if (sc->type & S_RESET) {
glPushMatrix();
glLoadIdentity();
if (p->pmode != CAMERA) {
if (mesh->dim == 3 || sc->mode & S_ALTITUDE) {
glRotatef(-60., 1., 0., 0.);
glRotatef(-120., 0., 0., 1.);
}
} else {
if (c->vecup == X_AXIS)
glRotatef(90.0, 0.0, 0.0, 1.0);
else if (c->vecup == Z_AXIS)
glRotatef(-90.0, 1.0, 0.0, 0.0);
}
glGetFloatv(GL_MODELVIEW_MATRIX, view->matrix);
glPopMatrix();
sc->type ^= S_RESET;
}
/* keep old transformation */
memcpy(view->oldmat, view->matrix, 16 * sizeof(float));
/* compute new transformation */
glPushMatrix();
glLoadIdentity();
if (p->pmode != CAMERA) {
glTranslatef(view->panx, view->pany, 0.0);
if (mesh->dim == 3 || sc->mode & S_ALTITUDE)
glRotatef(view->angle, view->axis[0], view->axis[1], view->axis[2]);
glTranslatef(-view->opanx, -view->opany, 0.);
glMultMatrixf(view->matrix);
glGetFloatv(GL_MODELVIEW_MATRIX, view->matrix);
} else if (animate) {
c->eye[0] += c->spmod * c->speed[0];
c->eye[1] += c->spmod * c->speed[1];
c->eye[2] += c->spmod * c->speed[2];
animateCamera();
reshapeScene(sc->par.xs, sc->par.ys);
}
glPopMatrix();
/* keep old translation */
view->opanx = view->panx;
view->opany = view->pany;
/* copy views */
if (!animate && sc->slave > -1) {
int clvol;
slave = cv.scene[sc->slave];
memcpy(slave->view, sc->view, sizeof(struct transform));
memcpy(slave->camera, sc->camera, sizeof(struct camera));
slave->view->angle = 0.0f;
clvol = slave->clip->active & C_VOL;
memcpy(slave->clip, sc->clip, sizeof(struct clip));
if (clvol) slave->clip->active |= C_VOL;
}
}
void mouse(int button,int state,int x,int y) {
button = alt_ctrl_left_to_middle(button);
pScene sc;
pTransform tr;
pPersp p;
int keyact,idw = currentScene();
static int olds = -1;
#ifdef IGL
// Tweakbar has precedence over everything else
if(TwEventMouseButtonGLUT(button,state,x,y) && state == GLUT_DOWN)
{
return;
}
#endif
/* default */
if ( ddebug ) printf("control mouse %d\n",state);
sc = cv.scene[idw];
p = sc->persp;
if ( sc->cube->active & C_EDIT )
tr = sc->cube->cubetr;
else if ( sc->clip->active & C_EDIT )
tr = sc->clip->cliptr;
else
tr = sc->view;
tr->mstate = state;
tr->mbutton = button;
/* check if ctrl-shift-alt pressed */
keyact = glutGetModifiers();
if ( state == GLUT_DOWN ) {
picking=GL_FALSE;
tracking = GL_TRUE;
lasttime = glutGet(GLUT_ELAPSED_TIME);
if ( button == GLUT_LEFT_BUTTON ) {
if ( keyact & GLUT_ACTIVE_SHIFT ) {
/* entity designation */
picking = GL_TRUE;
if ( sc->picklist ) glDeleteLists(sc->picklist,1);
sc->picklist = pickingScene(sc,x,y,0);
return;
}
else if ( keyact & GLUT_ACTIVE_ALT ) {
/* zoom */
starty = y;
glutMotionFunc(zoomMotion);
return;
}
else if ( keyact & GLUT_ACTIVE_CTRL ) {
/* rubberband selection */
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
p->rubix = p->rubfx = x;
p->rubiy = p->rubfy = sc->par.ys-y;
rxi = rx1 = x;
ryi = ry1 = sc->par.ys-y;
p->rubber = 1;
glDrawBuffer(GL_BACK_LEFT);
ortho2D(sc,ON);
glutMotionFunc(rubberMotion);
return;
}
}
else if ( button == GLUT_MIDDLE_BUTTON && keyact & GLUT_ACTIVE_SHIFT ) {
picking = GL_TRUE;
if ( sc->picklist ) glDeleteLists(sc->picklist,1);
sc->picklist = pickingScene(sc,x,y,LPoint);
return;
}
/* transformation */
startx = x;
starty = y;
point2Vect(x,y,sc->par.xs,sc->par.ys,tr->pos);
glutSetCursor(GLUT_CURSOR_INFO);
}
else if ( state == GLUT_UP ) {
if ( button == GLUT_LEFT_BUTTON ) {
if ( keyact & GLUT_ACTIVE_CTRL ) {
/* rubberband selection */
p->rubfx = x;
p->rubfy = sc->par.ys-y;
p->rubber = 2;
glDrawBuffer(GL_BACK_LEFT);
ortho2D(sc,OFF);
glutMotionFunc(motion);
return;
}
else if ( keyact & GLUT_ACTIVE_ALT ) {
glutMotionFunc(motion);
return;
}
else if ( picking == GL_TRUE ) {
picking = GL_FALSE;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
}
glutMotionFunc(motion);
if ( sc->clip->active & C_EDIT )
sc->clip->active |= C_REDO;
/* transformation */
glutSetCursor(GLUT_CURSOR_INHERIT);
tracking = GL_FALSE;
if ( glutGet(GLUT_ELAPSED_TIME) >= lasttime ) {
if ( tr->manim == GL_TRUE ) glutIdleFunc(glutIdle);
else tr->angle = 0.0;
/*if ( abs(startx-x) + abs(starty-y) > 0 )*/
glutPostRedisplay();
}
else if ( tr->manim == GL_TRUE && olds == idw )
glutIdleFunc(NULL);
}
olds = idw;
}
/* special keys CAMERA mode */
void specCamera(pScene sc,int key) {
pCamera c;
double dd,azim,elev;
GLfloat axe[3];
int keyact;
c = sc->camera;
keyact = glutGetModifiers();
axe[0] = c->speed[2];
axe[1] = 0.0;
axe[2] = -c->speed[0];
dd = sqrt(axe[0]*axe[0] + axe[2]*axe[2]);
if ( dd != 0.0f ) {
axe[0] /= dd;
axe[2] /= dd;
}
switch (key) {
case GLUT_KEY_LEFT:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[0] += axe[0]*c->altinc;
c->eye[2] += axe[2]*c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
azim += dazim;
}
break;
case GLUT_KEY_RIGHT:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[0] -= axe[0]*c->altinc;
c->eye[2] -= axe[2]*c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
azim -= dazim;
}
break;
case GLUT_KEY_UP:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[1] += c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
elev -= delev;
}
break;
case GLUT_KEY_DOWN:
if ( keyact & GLUT_ACTIVE_SHIFT ) {
c->eye[1] -= c->altinc;
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
return;
}
else {
azim = Azimuth(c);
elev = Elevation(c);
elev += delev;
}
break;
default:
return;
}
updateCamera(sc,c,azim,elev);
/* refresh scene */
reshapeScene(sc->par.xs,sc->par.ys);
glutPostRedisplay();
}
