glrender.c

有限元学习研究用源代码(老外的),供科研人员参考

    rnd->lightTX=0.0;
    rnd->lightTY=0.5;
    rnd->lightTZ= -1.0;
    rnd->sliceDir='z';
    rnd->slice[0]=0.0;
    rnd->slice[1]=0.0;
    rnd->slice[2]=1.0;
    rnd->slice[4]=-0.5*(rnd->boxMax[2]-rnd->boxMin[2]);
    rnd->p_min=rnd->boxMin[2]+p_eps*(rnd->boxMax[2]-rnd->boxMin[2]);
    rnd->p_boxMax=rnd->boxMax[2]-p_eps*(rnd->boxMax[2]-rnd->boxMin[2]);

    rnd->list_valid=0;
    rnd->level_surf=0;
    rnd->level=0.0;
    rnd->dialog=1;
  }



iglRenderer iglrCreate(     char *name, char *help, char *url,
			  int xpos,
			  int ypos,
			  int wdt,
			  int hgt)
{
    glWindow w;
    iglRenderer rnd;

    glwInitPosition(xpos,ypos,wdt,hgt);
    glwInitTitle(name);
    w=glwCreate();
    if (w==NULL)
	{
	    fprintf(stderr,"iglrnd: unable to open window\n");
	    return NULL;
	}


    rnd=(struct iglRendererStruct*) calloc(1,sizeof(struct iglRendererStruct));
    rnd->win=w;
    rnd->volume_init = 1;
    iglrReset(rnd);
    /* cool picture !*/
    glClearColor(0.2, 0.2, 0.2, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glwSwapBuffers(rnd->win);
    glFlush();
    iglrRegisterKeyAction(rnd,GLW_space,iglrKeyAction_state_control,"SPACE: State control");
    iglrRegisterKeyAction(rnd,GLW_o,iglrKeyAction_object_move,
			 "o: Toogle object/frame movement");
    iglrRegisterKeyAction(rnd,GLW_q,iglrKeyAction_state_control,"q: State control (Quit)");
    iglrRegisterKeyAction(rnd,GLW_g,iglrKeyAction_g,"g: Toggle Gouraud/flat shading.");
    iglrRegisterKeyAction(rnd,GLW_m,iglrKeyAction_m,"m: Move showing full model (slow).");
    iglrRegisterKeyAction(rnd,GLW_w,iglrKeyAction_w,"w: Move showing wireframe only (fast).");
    iglrRegisterKeyAction(rnd,GLW_f,iglrKeyAction_f,"f: Move showing frame (bounding box) only (very fast).");
    iglrRegisterKeyAction(rnd,GLW_B,iglrKeyAction_B,"B: Toggle background color (black/white). ");
    iglrRegisterKeyAction(rnd,GLW_D,iglrKeyAction_D,"D: Dump actual picture to file (look for *-*.tiff)");
    iglrRegisterKeyAction(rnd,GLW_F,iglrKeyAction_F,"F: Toggle rendering volume frame (bounding box) drawing.");
    iglrRegisterKeyAction(rnd,GLW_plus,iglrKeyAction_inc_mouse, "+: Increase mouse sensitivity.");
    iglrRegisterKeyAction(rnd,GLW_minus,iglrKeyAction_dec_mouse,"-: Decrease mouse sensitivity.");
    iglrRegisterKeyAction(rnd,GLW_greater,iglrKeyAction_SC_in,">: SC in.");
    iglrRegisterKeyAction(rnd,GLW_less,  iglrKeyAction_SC_out,"<: SC out.");
    iglrRegisterKeyAction(rnd,GLW_l,iglrKeyAction_l,"l: Level surface.");
    iglrRegisterKeyAction(rnd,GLW_x,iglrKeyAction_x,
			 "x: Show x orthogonal slice section.");
    iglrRegisterKeyAction(rnd,GLW_y,iglrKeyAction_y,
			 "y: Show y orthogonal slice section.");
    iglrRegisterKeyAction(rnd,GLW_z,iglrKeyAction_z,
			 "z: Show z orthogonal slice section.");
    iglrRegisterKeyAction(rnd,GLW_r,iglrKeyAction_r,"r: Reset.");
    iglrRegisterKeyAction(rnd,GLW_question,iglrKeyAction_help,"?: Key help.");
    iglrRegisterKeyAction(rnd,GLW_Left ,iglrKeyAction_left ,
 "<=  :rotate/ SHIFT+<=:shift/ SHIFT+CTRL+<=:level/ ALT+CTRL+<=:move light/");
    iglrRegisterKeyAction(rnd,GLW_Right,iglrKeyAction_right,
 "=>  :rotate/ SHIFT+=>:shift/ SHIFT+CTRL+=>:level/ ALT+CTRL+=>:move light/");
    iglrRegisterKeyAction(rnd,GLW_Up   ,iglrKeyAction_up   ,
 "Up  :rotate/ SHIFT+Up:shift/ SHIFT+CTRL+Up:scale/ ALT+CTRL+Up:move light/");
    iglrRegisterKeyAction(rnd,GLW_Down ,iglrKeyAction_down ,
 "Down:rotate/ SHIFT+Dn:shift/ SHIFT+CTRL+Dn:scale/ ALT+CTRL+Dn:move light/");
    iglrRegisterKeyAction(rnd,GLW_W,iglrKeyAction_wireframe,
			 "W: toggle wireframe mode");
    iglrRegisterKeyAction(rnd,GLW_I,iglrKeyAction_info,
			 "I: full state information");
    iglrRegisterKeyAction(rnd,GLW_S,iglrKeyAction_S,"S: increase scale factor.");
    iglrRegisterKeyAction(rnd,GLW_s,iglrKeyAction_s,"s: decrease scale factor.");

    rnd->list=1;
    rnd->list_valid=0;
    rnd->data_valid=0;

    rnd->firstcall=1;
    rnd->next_dialog=0;
    iglrShowState(rnd);


    rnd->dump_w=600;
    rnd->dump_h=600;
    rnd->dump_i=0;
    strcpy(rnd->dump_name_stub,name);
    iglrInit(rnd);
    return rnd;
}


void iglrDumpNext(iglRenderer rnd)
{
  rnd->dump=1;
}

void iglrSetDumpFileNameStub(iglRenderer rnd, char *name)
{
  strcpy(rnd->dump_name_stub,name);
}

void iglrSetDumpPixmapSize(iglRenderer rnd, int w, int h)
{
  rnd->dump_w=600;
  rnd->dump_h=600;
}

void iglrSetTitle(iglRenderer rnd, char *title)
{
  glwSetTitle(rnd->win,title);
}


void iglrDestroy(iglRenderer rnd)
{
    glwDestroy(rnd->win);
    free(rnd);

}

void iglrGetLevelSurface(iglRenderer rnd, int* mode)
{
  *mode=rnd->level_surf;
}

void iglrSetLevelSurface(iglRenderer rnd, int mode)
{
  rnd->level_surf=mode;
}

void iglrGetLevel(iglRenderer rnd, double* lev)
{
  *lev=rnd->level;
}

void iglrSetLevel(iglRenderer rnd, double lev)
{
  rnd->level=lev;
}

void iglrSetDataValid(iglRenderer rnd, int valid)
{
  rnd->data_valid=valid;
}

void iglrMoveFrame(iglRenderer rnd)
{
    rnd->move_frame=1;
    rnd->move_wireframe=0;
    rnd->drawLevel = IGLR_DRAW_BEST;
    rnd->move_model=0;
}



void iglrMoveWireframe(iglRenderer rnd)
{
    rnd->move_wireframe=1;
    rnd->drawLevel = IGLR_DRAW_COARSE;
    rnd->move_frame=0;
    rnd->move_model=0;
}

void iglrMoveModel(iglRenderer rnd)
{
    rnd->move_wireframe=0;
    rnd->drawLevel = IGLR_DRAW_BEST;
    rnd->move_frame=0;
    rnd->move_model=1;
}

void iglrSetPerspective(iglRenderer rnd, double rotx, double rotz)
{

  rnd->cameraRX=rotx;
  rnd->cameraRY=rotz;

}

void iglrGetPerspective(iglRenderer rnd, double *rotx, double *rotz)
{

  *rotx=rnd->cameraRX;
  *rotz=rnd->cameraRY;

}

void iglrGetWireframe(iglRenderer rnd, int *wf)
{
  *wf=rnd->wireframe;
}

void iglrSetFlatshading(iglRenderer rnd, int flat)
{
  rnd->gouraud_shading=!flat;
}
void iglrGetFlatshading(iglRenderer rnd, int *flat)
{
  *flat=!rnd->gouraud_shading;
}

void iglrSetDialog(iglRenderer rnd, int dialog)
{
  rnd->dialog=dialog;
}
void iglrGetDialog(iglRenderer rnd, int *dialog)
{
  *dialog=rnd->dialog;
}


void iglrSetPlane(iglRenderer rnd, double a,double b,double c, double d)
{
  rnd->slice[0]=a;
  rnd->slice[1]=b;
  rnd->slice[2]=c;
  rnd->slice[4]=d;

}

void iglrGetSliceState(iglRenderer rnd, int *hold)
{
    *hold = rnd->showSlice;
}

void iglrGetMouseState(iglRenderer rnd, int *hold)
{
    *hold = rnd->button_hold;
}


void iglrSetVScale(iglRenderer rnd, double vscale)
{
  rnd->vscale= vscale;
}

void iglrGetVScale(iglRenderer rnd, double *vscale)
{
 *vscale= rnd->vscale;
}

static void iglrReshape(glWindow w, void *info,int width, int height)
{
    iglRenderer rnd=(iglRenderer)info;
    rnd->asp=(double)width/(double)height;
    glViewport(0, 0, (GLint)width, (GLint)height);

}



static GLenum iglrMouse1(glWindow w, void * info,int x,int y, GLenum mask)
{
  iglRenderer rnd=(iglRenderer)info;
  if (mask & GLW_SHIFT){  /* translate */
      if (rnd->object_move){
	  double xs,ys;
	  xs=0.008*rnd->sensitivity*(x-rnd->lastxpos);
	  ys=0.008*rnd->sensitivity*(y-rnd->lastypos);
	  rnd->lastxpos=x;
	  rnd->lastypos=y;
	  switch(rnd->sliceDir){
	  case 'x':
	      xs *= rnd->boxMax[1]-rnd->boxMin[1];
	      ys *= rnd->boxMax[2]-rnd->boxMin[2];
	      iglrSetVolume(rnd,
			   rnd->boxMin[0],rnd->boxMax[0],
			   rnd->boxMin[1]-xs,rnd->boxMax[1]-xs,
			   rnd->boxMin[2]+ys,rnd->boxMax[2]+ys);
	      break;
	  case 'y':
	      xs *= rnd->boxMax[0]-rnd->boxMin[0];
	      ys *= rnd->boxMax[2]-rnd->boxMin[2];
	      iglrSetVolume(rnd,
			   rnd->boxMin[0]-xs,rnd->boxMax[0]-xs,
			   rnd->boxMin[1],rnd->boxMax[1],
			   rnd->boxMin[2]+ys,rnd->boxMax[2]+ys);
	      break;
	  case 'z':
	      xs *= rnd->boxMax[0]-rnd->boxMin[0];
	      ys *= rnd->boxMax[1]-rnd->boxMin[1];
	      iglrSetVolume(rnd,
			   rnd->boxMin[0]-xs,rnd->boxMax[0]-xs,
			   rnd->boxMin[1]+ys,rnd->boxMax[1]+ys,
			   rnd->boxMin[2],rnd->boxMax[2]);
	      break;
	  }
	  rnd->list_valid=0;
	  iglrShowState(rnd);
	  return GL_TRUE;
      }
      rnd->cameraTX+=0.008*rnd->sensitivity*(x-rnd->lastxpos);
      rnd->cameraTY-=0.008*rnd->sensitivity*(y-rnd->lastypos);
      rnd->lastxpos=x;
      rnd->lastypos=y;
      return GL_TRUE;
    }
  else  /* rotate */
    {
      rnd->cameraRY+=0.7*rnd->sensitivity*(x-rnd->lastxpos);
      rnd->cameraRX+=0.7*rnd->sensitivity*(y-rnd->lastypos);
      rnd->lastxpos=x;
      rnd->lastypos=y;
      return GL_TRUE;
    }
}



static GLenum iglrMouse2(glWindow w, void * info,int x,int y, GLenum mask)
{
  iglRenderer rnd=(iglRenderer)info;
  if (mask & GLW_SHIFT)  /* rotate light */
    {
      rnd->lightTX+=0.05*rnd->sensitivity*(x-rnd->lastxpos);
      rnd->lightTY-=0.05*rnd->sensitivity*(y-rnd->lastypos);
      rnd->lastxpos=x;
      rnd->lastypos=y;
      return GL_TRUE;
    }
  else
    {
      /* scale values */
      rnd->vscale-=0.1*rnd->sensitivity*(y-rnd->lastypos);
      rnd->lastypos=y;
      rnd->list_valid=0;
      return GL_TRUE;

    }
}



static GLenum iglrMouse3(glWindow w, void * info,int x,int y, GLenum mask)
{
  iglRenderer rnd=(iglRenderer)info;
  if (rnd->level_surf)
    {
      rnd->level-= 0.01*rnd->sensitivity*(y-rnd->lastypos);
      rnd->lastypos=y;
      rnd->list_valid=0;
      iglrShowState(rnd);
      return GL_TRUE;
    }
  else
    {
      rnd->slice[4]+= 0.01*rnd->sensitivity*(rnd->p_boxMax-rnd->p_min)*(y-rnd->lastypos);
      if ( -rnd->slice[4] < rnd->p_min) rnd->slice[4]= -rnd->p_min;
      if ( -rnd->slice[4] > rnd->p_boxMax) rnd->slice[4]= -rnd->p_boxMax;

      rnd->lastypos=y;
      rnd->list_valid=0;
      iglrShowState(rnd);
      return GL_TRUE;
    }
}


static GLenum iglrMouseDown(glWindow w, void * info,int x,int y, GLenum mask)
{
  iglRenderer rnd=(iglRenderer)info;
  rnd->button_hold = 1;
  rnd->drawLevel = IGLR_DRAW_WIREFRAME;
/*
  if (mask&GLW_LEFTBUTTON)        glwSetMouseMoveFunc(w,iglrMouse1);
  else if (mask&GLW_MIDDLEBUTTON) glwSetMouseMoveFunc(w,iglrMouse2);
  else if (mask&GLW_RIGHTBUTTON)  glwSetMouseMoveFunc(w,iglrMouse3);
*/
  glwSetMouseMoveFunc(w,iglrMouse);
  if (rnd->move_wireframe||rnd->move_frame)
    {
      if (rnd->move_wireframe)
	rnd->list_valid=0;
      rnd->wireframe=1;
      glDisable(GL_LIGHTING);
      glDisable(GL_COLOR_MATERIAL);
      glDisable(GL_DEPTH_TEST);
      glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    }
  rnd->lastxpos=x;
  rnd->lastypos=y;
  iglrShowState(rnd);
  return GL_TRUE;
}

static GLenum iglrMouseUp(glWindow w, void * info,int x,int y, GLenum mask)
{
    iglRenderer rnd=(iglRenderer)info;
    rnd->button_hold = 0;
    rnd->drawLevel = IGLR_DRAW_NORMAL;

    if (rnd->move_wireframe)
      rnd->list_valid=0;
    glwSetMouseMoveFunc(w,NULL);
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_DEPTH_TEST);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    rnd->wireframe=0;
    iglrShowState(rnd);
    return GL_TRUE;
}

void iglrDrawIntern(glWindow w, void *info);

void iglrDraw(glWindow w, void *info)
     /*
{
  iglRenderer rnd=(iglRenderer)info;
  while(!rnd->list_valid) iglrDrawIntern(w,info);
}
void iglrDrawIntern(glWindow w, void *info)
*/
{
  iglRenderer rnd=(iglRenderer)info;


  double xsize,ysize,zsize;
  double scalefac,ltn;

  static float lt_position[] = {1.0, 0.0, 1.0,  1.0};
  if (rnd->dump||rnd->firstcall)
  {
    static float mat_shininess[] = {80.0};
    static float mat_specular[] = {0.8, 0.8, 0.8, 1.0};
    static float mat_emission[] = {0.1,0.1,0.1, 1.0};
    static float mat_ambient_and_diffuse[]={1.0,1.0,1.0,1.0};
    static float lgt_ambient[]={1.0,1.0,1.0,1.0};
    static float lgt_diffuse[]={1.0,1.0,1.0,1.0};
    static float AmbientLight[] = {0.8,0.8,0,8, 1.0};
    static float TwoSideLighting[] = {GL_TRUE};