keyboard.c

来自「FreeFem++可以生成高质量的有限元网格。可以用于流体力学」· C语言 代码 · 共 862 行 · 第 1/2 页

#include "medit.h"
#include "extern.h"
#include "sproto.h"

extern int refmat,reftype,refitem;
int       *pilmat,ipilmat;
int        refpick = -1;

GLfloat  dazim = 1.0;
GLfloat  delev = 1.0;

extern void mouseCamera(int button,int state,int x,int y);
extern void motionCamera(int x,int y);


static void usage() {
  fprintf(stdout,"\n");
  fprintf(stdout,"-- Medit: OnLine Help --\n");

  fprintf(stdout,"** Rendering options (toggle):\n");
  fprintf(stdout,"f - facets        l - lines          g - const. entities\n");
  fprintf(stdout,"c - obj. color    e - material       b - back color\n");
  fprintf(stdout,"A - axis          B - box            G - grid\n");
  fprintf(stdout,"C - capping       r(R) - hide (show) refs.\n");
  fprintf(stdout,"n - smooth/flat shading\n");

  fprintf(stdout,"\n** Controls options:\n");
  fprintf(stdout,"i - reset view    a - animate        I - interactive\n");
  fprintf(stdout,"h - online help   q - quit           X - close window\n");

  fprintf(stdout,"\n** View controls (ALT + key):\n");
  fprintf(stdout,"c - copy   d - duplicate p - paste  l - link   u - unlink\n");
  fprintf(stdout,"J - toggle flight        y - change axis\n");
  
  fprintf(stdout,"\n** Misc. features\n");
  fprintf(stdout,"L - load prefs    W - save prefs\n");
  fprintf(stdout,"H - hardcopy PPM\n");
  fprintf(stdout,"F - face nums     P - point nums     # - select entity\n");
  fprintf(stdout,"N - normals       O - oppos. normals ! - select plane\n");
  fprintf(stdout,"m - data          o - iso-lines      w - tensor/vector\n");
  fprintf(stdout,"v - streamlines   k - toggle elev.   K - elev. coeff.\n");
  fprintf(stdout,"j - toggle deco   p - palette        S - play animation\n");
  
  fprintf(stdout,"+/- scale object  z/Z scale view\n");
  fprintf(stdout,"F1,F2,F3 - clipping: On/Off, Edit, Freeze\n");
}

/* 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();
}


/* change center of scene */
static void changeCenter(pScene sc,pMesh mesh) {
  pPoint     p0;
  pTriangle  pt;
  pQuad      pq;
  pTetra     ptt;
  pHexa      ph;
  float      cx,cy,cz;
  int        i;

  if ( !refitem )  return;
  cx = cy = cz = 0.0;
  switch(reftype) {
  case LPoint:
    p0 = &mesh->point[refitem];
    cx = p0->c[0];
    cy = p0->c[1];
    cz = p0->c[2];
    break;
  case LTria:
    pt = &mesh->tria[refitem];
    for (i=0; i<3; i++) {
      p0 = &mesh->point[pt->v[i]];
      cx += 0.33 * p0->c[0];
      cy += 0.33 * p0->c[1];
      cz += 0.33 * p0->c[2];
    }
    break;
  case LQuad:
    pq = &mesh->quad[refitem];
    for (i=0; i<4; i++) {
      p0 = &mesh->point[pq->v[i]];
      cx += 0.25 * p0->c[0];
      cy += 0.25 * p0->c[1];
      cz += 0.25 * p0->c[2];
    }
    break;
  case LTets:
    ptt = &mesh->tetra[refitem];
    for (i=0; i<4; i++) {
      p0 = &mesh->point[ptt->v[i]];
      cx += 0.25 * p0->c[0];
      cy += 0.25 * p0->c[1];
      cz += 0.25 * p0->c[2];
    }
    break;
  case LHexa:
    ph = &mesh->hexa[refitem];
    for (i=0; i<8; i++) {
      p0 = &mesh->point[ph->v[i]];
      cx += 0.125 * p0->c[0];
      cy += 0.125 * p0->c[1];
      cz += 0.125 * p0->c[2];
    }
    break;
  }

  /* reset translation and move to center */
  sc->view->panx = sc->view->pany = 0.0;
  sc->cx = -cx;
  sc->cy = -cy;
  sc->cz = -cz;
}


/* special keys PERSPECTIVE mode */
void special(int key,int x,int y) {
  pTransform  view;
  pScene      sc;
  pMesh       mesh;
  pClip       clip;
  pCube       cube;
  float       pancoeff = 0.1f;
  int         keyact,idw = currentScene();
  ubyte       post = TRUE;
 
  /* default */
  if ( ddebug ) printf("special key  %d\n",key);
  sc   = cv.scene[idw];

  /* special mode camera */
  if ( sc->persp->pmode == CAMERA ) {
    specCamera(sc,key);
    return;
  }
  
  view = sc->view;
  mesh = cv.mesh[sc->idmesh];
  clip = sc->clip;
  cube = sc->cube;
  keyact = glutGetModifiers();
  if ( keyact & GLUT_ACTIVE_SHIFT )
    pancoeff = 0.01;

  switch(key) {
  case GLUT_KEY_F1:  /* toggle clipping plane */
    if ( mesh->dim == 3 ) {
      if ( cube->active & C_ON)
    keyCube('C',0,0);
      else
    keyClip('C',0,0);
    }
    post = FALSE;
    break;
  case GLUT_KEY_F2:  /* edit clipping plane */
    if ( mesh->dim == 3 ) {
      if ( cube->active & C_ON)
        keyCube('E',0,0);     
      else if ( clip->active & C_ON ) 
    keyClip('E',0,0);
    }
    post = FALSE;
    break;
  case GLUT_KEY_F3:  /* freeze clipping plane */
    if ( cube->active & C_ON )
      keyCube('F',0,0);
    else if ( clip->active & C_ON ) 
      keyClip('F',0,0);
    post = FALSE;
    break;
  case GLUT_KEY_F4:  /* toggle Vclip */
    if ( mesh->dim == 3 )  keyClip('Z',0,0);
    post = FALSE;
    break;
  case GLUT_KEY_F5:  /* Toggle Shrink */
    if ( mesh->ntet+mesh->nhex > 0 )
      keyFeature('V',0,0);
    else
      keyFeature('S',0,0);
    break;
  case GLUT_KEY_F6:  /* Increase Shrink */
    keyFeature('I',0,0);
    break;
  case GLUT_KEY_F7:  /* Decrease Shrink */
    keyFeature('i',0,0);
    break;

  case GLUT_KEY_LEFT:  /* translate eyes or object */
    if ( clip->active & C_EDIT ) {
      clip->cliptr->panx -= 0.02 * sc->dmax;
      clip->cliptr->angle = 0.0;
      clip->active |= C_UPDATE + C_REDO;
    }
    else if ( keyact & GLUT_ACTIVE_CTRL ) {
      sc->par.eyesep *= 0.9;
      printf("eyesep %f\n",sc->par.eyesep);
    }
    else
      view->panx -= pancoeff * sc->dmax;
    break;
  case GLUT_KEY_RIGHT:
    if ( clip->active & C_EDIT ) {
      clip->cliptr->panx += 0.02 * sc->dmax;
      clip->cliptr->angle = 0.0;
      clip->active |= C_UPDATE + C_REDO;
    }
    else if ( keyact & GLUT_ACTIVE_CTRL ) {
      sc->par.eyesep *= 1.1;
      printf("eyesep %f\n",sc->par.eyesep);
    }
    else
      view->panx += pancoeff * sc->dmax;
    break;
  case GLUT_KEY_UP:
    if ( clip->active & C_EDIT ) {
      clip->cliptr->pany += 0.02 * sc->dmax;
      clip->cliptr->angle = 0.0;
      clip->active |= C_UPDATE + C_REDO;
    }
    else
      view->pany += pancoeff * sc->dmax;
    break;
  case GLUT_KEY_DOWN:
    if ( clip->active & C_EDIT ) {
      clip->cliptr->pany -= 0.02 * sc->dmax;
      clip->cliptr->angle = 0.0;
      clip->active |= C_UPDATE + C_REDO;
    }
    else
      view->pany -= pancoeff * sc->dmax;
    break;
  default:
    return;
  }
  if ( post )  glutPostRedisplay();
}


void keyScene(unsigned char key,int x,int y) {
  pMaterial   pm;
  pTetra      ptt;
  pHexa       ph;
  pTriangle   pt;
  pQuad       pq;
  pScene      sc,sc1;
  pMesh       mesh;
  pClip       clip;
  pCube       cube;
  pPersp      p;
  pCamera     cam;
  double      dd;
  float       a,b,c,d;
  int         k,keyact,numit,idw = currentScene();
  ubyte       post = FALSE,dolist = FALSE;

  if ( idw < 0 ) exit(0);

  /* ESC = end medit */
  if ( key == 'q' || key == 27 ) 
    exit(0);
  else if ( key == 'h' || key == '?' )
    usage();

  /* default */
  sc   = cv.scene[idw];
  mesh = cv.mesh[sc->idmesh];
  clip = sc->clip;
  cube = sc->cube;
  p    = sc->persp;

  keyact = glutGetModifiers();
  if ( key == ' ' ) {
    if ( option == MORPHING )
      morphMesh(sc,mesh);
    else if ( sc->isotyp & S_PARTICLE ) {
      glutIdleFunc(0);
    } 
    else {      
      cam = sc->camera;
      cam->eye[0] += cam->spmod*cam->speed[0];
      cam->eye[1] += cam->spmod*cam->speed[1];
      cam->eye[2] += cam->spmod*cam->speed[2];
      reshapeScene(sc->par.xs,sc->par.ys);
    }
    post = TRUE;
  }

  else if ( islower(key) ) {
    switch(key) {
    case 'a':  /* toggle animate */
      keyAnim('A',0,0);
      break;
    case 'b':  /* backcolor */
      keyColor('b',0,0);
      break;
    case 'c':
      if ( keyact & GLUT_ACTIVE_ALT )
    keyView('C',0,0);
      else {
    sc->mode ^= S_COLOR;
    post = TRUE;
      }
      break;
    case 'd':
      if ( keyact & GLUT_ACTIVE_ALT ) keyView('D',0,0);
      break;
    case 'e': 
      keyColor('e',0,0);
      break;
    case 'f':
      sc->mode ^= S_FILL;
      post=TRUE;
      break;
    case 'g': 
      keyItem('g',0,0);
      break;
    case 'h':
      usage();
      break;
    case 'i':
      keyView('R',0,0);
      if ( clip->active & C_ON )  resetClip(sc,clip,mesh);
      if ( cube->active & C_ON )  resetCube(sc,cube,mesh);
      sc1 = sc;
      while ( sc1->slave > -1 ) {
        sc1 = cv.scene[sc1->slave];
        glutSetWindow(sc1->idwin);
        keyScene('i',0,0);
      }
      glutSetWindow(sc->idwin);
      break;
    case 'j':
      sc->type ^= S_DECO;
      post = TRUE;
      break;
    case 'k':
      keyMetric('k',0,0);
      break;
    case 'l':
      if ( keyact & GLUT_ACTIVE_ALT ) 
        keyView('L',0,0);
      else
        sc->mode ^= S_BDRY;  
      post = TRUE;  
      break;
    case 'm':  /* toggle metric */
      if ( mesh->nbb )  keyMetric('m',0,0);
      keyMode('n',0,0);