scene.c

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

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


extern GLboolean  hasStereo;
extern int       *pilmat,ipilmat,refmat,reftype,refitem;
extern short      schw,schh;
extern ubyte      quiet,fullscreen,tiling,stereoMode;


/* return current active scene */
int currentScene() {
  int  k,idw;

  idw = glutGetWindow();
  for (k=0; k<MAX_SCENE; k++) {
    if ( cv.scene[k] && idw == cv.scene[k]->idwin )
      return(k);
  }
  return(0);
}

/* check for OpenGL error */
void checkErrors(void) {
  GLenum error;

  while ( (error = glGetError()) != GL_NO_ERROR ) {
    fprintf(stderr,"  ## ERROR: %d: %s\n",
            (int)error,(char*)gluErrorString(error));
    exit(1);
  }
}

void farclip(GLboolean b) {
  pScene  sc;
  pPersp  p;
  pCamera c;
  float   look[3],ratio,units;
  int     idw = currentScene();
  static  GLfloat up[3] = { 0.0, 1.0, 0.0};

  /* default */
  sc    = cv.scene[idw];
  p     = sc->persp;
  c     = sc->camera;
  ratio = (GLfloat)sc->par.xs / sc->par.ys;

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  switch (p->pmode) {
  case ORTHO:
    glOrtho(-1.,1.,-1.,0.1,0.01,0.01);
    break;

  case PERSPECTIVE:
    if ( b )
      gluPerspective(p->fovy,ratio,sc->dmax,4.0*sc->dmax);
    else
      gluPerspective(p->fovy,ratio,0.01,10000.0*sc->dmax);

    units = 1.e-02;
    glPolygonOffset(1.0, units);
    break;

  case CAMERA:
    gluPerspective(p->fovy,ratio,0.001*sc->dmax,4.0*sc->dmax);
    look[0] = c->eye[0] + 0.001*sc->dmax*c->speed[0];
    look[1] = c->eye[1] + 0.001*sc->dmax*c->speed[1];
    look[2] = c->eye[2] + 0.001*sc->dmax*c->speed[2];
    gluLookAt(c->eye[0],c->eye[1],c->eye[2], 
              look[0],look[1],look[2],
              up[0],up[1],up[2]);
    break;
  }

  /* zoom transformation */
  if ( p->rubber == 2 ) {
    glPushMatrix();
    glLoadIdentity();
    glRotatef(-p->gamma,1.,0.,0.);
    glRotatef(p->alpha,0.,1.,0.);
    glMultMatrixf(p->matrix);
    glGetFloatv(GL_PROJECTION_MATRIX,p->matrix);
    glPopMatrix();
    p->rubber = 0;
  }

  /* apply transformation */
  glMultMatrixf(p->matrix);

  glMatrixMode(GL_MODELVIEW);
}


void reshapeScene(int width,int height) {
  pScene   sc;

  if ( ddebug ) printf("reshape scene\n");
  sc = cv.scene[currentScene()];
  sc->par.xs = width;
  sc->par.ys = height;

  glViewport(0,0,width,height);
  farclip(GL_TRUE);
}


static void drawList(pScene sc,int clip,int map) {
  pMesh   mesh = cv.mesh[sc->idmesh];
  ubyte   elev = sc->mode & S_ALTITUDE;

  if ( ddebug ) printf("drawList %p %d %d\n",sc,clip,map);
  if ( mesh->dim == 2 && !elev ) glDisable(GL_DEPTH_TEST);

  glLineWidth(1.0);
  if ( clip ) {
    if ( map ) {
      if ( sc->cmlist[LTets] ) glCallList(sc->cmlist[LTets]);
      if ( sc->cmlist[LHexa] ) glCallList(sc->cmlist[LHexa]);
    }
    else {
      if ( sc->clist[LTets] ) glCallList(sc->clist[LTets]);
      if ( sc->clist[LHexa] ) glCallList(sc->clist[LHexa]);
    }
  }
  else if ( map ) {
    if ( mesh->nt+mesh->nq ) {
      if ( sc->mlist[LTria] ) glCallList(sc->mlist[LTria]);
      if ( sc->mlist[LQuad] ) glCallList(sc->mlist[LQuad]);
    }
    else {
      if ( sc->mlist[LTets] ) glCallList(sc->mlist[LTets]);
      if ( sc->mlist[LHexa] ) glCallList(sc->mlist[LHexa]);
    }
  }
  else {
    if ( mesh->nt+mesh->nq ) {
      if ( sc->dlist[LTria] ) glCallList(sc->dlist[LTria]);
      if ( sc->dlist[LQuad] ) glCallList(sc->dlist[LQuad]);
    }
    else {
      if ( sc->dlist[LTets] ) glCallList(sc->dlist[LTets]);
      if ( sc->dlist[LHexa] ) glCallList(sc->dlist[LHexa]);
    }
  }
  if ( mesh->dim == 2 && !elev ) glEnable(GL_DEPTH_TEST);
}

#ifdef ppc
void bogusQuad(pScene sc) {
  /* bogus polygon (nvidia) */
  glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    glLineWidth(1.0);
    glColor3fv(sc->par.back);
    glBegin(GL_QUADS);
      glVertex3f(0., 0.,-sc->persp->depth);
      glVertex3f(0., 0.,-sc->persp->depth);
      glVertex3f(0., 0.,-sc->persp->depth);
      glVertex3f(0., 0.,-sc->persp->depth);
    glEnd();
  glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
}
#endif

static void displayScene(pScene sc,int mode,int clip) {
  int     map;
  
  map = mode & S_MAP;

  switch(mode) {
  case FILL:  /* solid fill */
    if ( ddebug ) printf("solid fill\n");
    glEnable(GL_LIGHTING);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    glDisable(GL_POLYGON_OFFSET_FILL);
      drawList(sc,clip,0);
    glDisable(GL_LIGHTING);
    break;

  case WIRE:  /* basic wireframe */
  case WIRE+S_MATERIAL:
    if ( ddebug ) printf("wireframe\n");
#ifdef ppc
    bogusQuad(sc);
#endif
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    glColor4fv(sc->par.line);
    glDisable(GL_POLYGON_OFFSET_FILL);
      drawList(sc,clip,0);
    break;

  case DEPTH:  /* depth wireframe */
  case DEPTH + S_MATERIAL:
    if ( ddebug ) printf("depth wireframe\n");
    glEnable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_POLYGON_OFFSET_FILL);
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
      drawList(sc,clip,0);
    glDisable(GL_LIGHTING);
    break;

  case HIDDEN: /* hidden lines removal */
  case HIDDEN + S_MATERIAL:
    if ( ddebug ) printf("hidden lines\n");
    glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    glColor3fv(sc->par.back);
      drawList(sc,clip,0);
    glDisable(GL_POLYGON_OFFSET_FILL);
#ifdef ppc
    bogusQuad(sc);
#endif
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    glColor4fv(sc->par.line);
      drawList(sc,clip,0);
    break;

  case SHADED: /* shaded polygons */
  case SHADED+S_MATERIAL:
    if ( ddebug ) printf("shaded polygons\n");
    glEnable(GL_LIGHTING);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    glEnable(GL_POLYGON_OFFSET_FILL);
      drawList(sc,clip,0);
    glDisable(GL_LIGHTING);
    glDisable(GL_POLYGON_OFFSET_FILL);
#ifdef ppc
    bogusQuad(sc);
#endif
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    glColor4fv(sc->par.line);
      drawList(sc,clip,0);
    break;

  case SIZEMAP: /* display metric map */
  case SIZEMAP+S_MATERIAL:
    if ( ddebug ) printf("display sizemap\n");
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
      drawList(sc,clip,map);
    glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_POLYGON_OFFSET_FILL);
#ifdef ppc
    bogusQuad(sc);
#endif
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    glColor4fv(sc->par.line);
    glLineWidth(1.0);
      drawList(sc,clip,0);
    if ( sc->mode & S_ALTITUDE ) {
      glColor4fv(sc->par.line);
      if ( sc->mlist[LTets] ) glCallList(sc->mlist[LTets]);
      if ( sc->mlist[LHexa] ) glCallList(sc->mlist[LHexa]);
    }
    break;

  default: /* other modes */
    if ( ddebug ) printf("rendering mode %d\n",sc->mode);
    /* interior */
    if ( sc->mode & S_FILL ) {
      if ( sc->mode & S_COLOR )  glEnable(GL_LIGHTING);
      glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
      glEnable(GL_POLYGON_OFFSET_FILL);
      if ( sc->mode & S_MAP ) {
        glEnable(GL_COLOR_MATERIAL);
	drawList(sc,clip,map);
        glDisable(GL_COLOR_MATERIAL);
      }
      else {
 	glColor4fv(sc->par.back);
	drawList(sc,clip,0);
      }
    }

    /* boundary */
    glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_POLYGON_OFFSET_FILL);
#ifdef ppc
    bogusQuad(sc);
#endif
    glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    if ( !(sc->mode & S_BDRY) )  break;
    if ( sc->mode & S_COLOR && !(sc->mode & S_FILL) ) {
      glEnable(GL_COLOR_MATERIAL);
      glEnable(GL_LIGHTING);
    }
    if ( sc->mode & S_MAP) {
      if ( sc->mode & S_FILL ) {
        glColor4fv(sc->par.line);
        drawList(sc,clip,0);
      }
      else
        drawList(sc,clip,map);
    }
    else if ( sc->mode & S_ALTITUDE ) {
      glColor4fv(sc->par.line);
      drawList(sc,clip,map);
      if ( sc->mlist[LTets] ) glCallList(sc->mlist[LTets]);
      if ( sc->mlist[LHexa] ) glCallList(sc->mlist[LHexa]);
    }
    else {
      glColor4fv(sc->par.line);
      drawList(sc,clip,0);
    }
  }
}

static void displayData(pScene sc,pMesh mesh) {
  int  kk;
  
  glDisable(GL_LIGHTING);
  glDisable(GL_COLOR_MATERIAL);

  /* iso-lines */
  if ( sc->isotyp & S_ISOLINE ) {
    glLineWidth(1.0);
    if ( sc->ilist[LTria] )  glCallList(sc->ilist[LTria]);
    if ( sc->ilist[LQuad] )  glCallList(sc->ilist[LQuad]);
    glDisable(GL_CLIP_PLANE0);
    if ( sc->ilist[LTets] && sc->clip->active & C_ON )
      glCallList(sc->ilist[LTets]);
  }

  /* vector field */
  if ( sc->isotyp & S_VECTOR ) {
    if ( mesh->dim == 2 ) {
      if ( sc->vlist[LTria] )  glCallList(sc->vlist[LTria]);
      if ( sc->vlist[LQuad] )  glCallList(sc->vlist[LQuad]);
    }
    else {
      if ( sc->clip->active & C_ON ) {
        glDisable(GL_CLIP_PLANE0);
        if ( sc->vlist[LTets] )  glCallList(sc->vlist[LTets]);
        if ( sc->vlist[LHexa] )  glCallList(sc->vlist[LHexa]);
      }
      else if (mesh->ntet+mesh->nhex == 0 )
        if ( sc->vlist[LTria] )  glCallList(sc->vlist[LTria]);
    }
  }

  /* streamlines */
  if ( sc->isotyp & S_CRITP && sc->cplist )
    glCallList(sc->cplist);
  if ( sc->isotyp & S_STREAML ) {
    for (kk=0; kk<sc->stream->nbstl; kk++)
      glCallList(sc->slist[kk]);
  }
  else if ( sc->isotyp & S_PARTICLE ) {
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    displayParticle(sc,mesh);
    glDisable(GL_COLOR_MATERIAL);
  }

  /* iso-surfaces */
  if ( sc->isotyp & S_ISOSURF ) {
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    if ( sc->ilist[LTets] )  glCallList(sc->ilist[LTets]);
    if ( sc->ilist[LHexa] )  glCallList(sc->ilist[LHexa]);
    glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
  }
  
}


void setupView(pScene sc) {
  pScene       slave;
  pMesh        mesh;
  pTransform   view;
  pPersp       p;
  pCamera      c;
  int          clvol;

  /* 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 ) {
    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 drawModel(pScene sc) {
  pMesh        mesh;
  pTransform   view;
  pClip        clip;
  ubyte        sstatic;

  /* default */
  mesh = cv.mesh[sc->idmesh];
  view = sc->view;
  clip = sc->clip;
  if ( ddebug ) printf("\n-- redraw scene %d, mesh %d\n",sc->idwin,sc->idmesh);