wzwindow.c

Delaunay三角形的网格剖分程序

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

  static float lt_position[] = {1.0, 0.0, 1.0,  1.0};
  if (win->dump||win->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};

    win->list_valid=win->data_valid;



    glLightfv(GL_LIGHT0,GL_AMBIENT,lgt_ambient);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,lgt_diffuse);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT,  AmbientLight);
    glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, TwoSideLighting);
    glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_ambient_and_diffuse);


    glEnable(GL_LIGHTING);
    glEnable(GL_NORMALIZE);


    if (win->gouraud_shading)
      glShadeModel(GL_SMOOTH);
    else
      glShadeModel(GL_FLAT);

    glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,1);


    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_DEPTH_TEST);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    win->firstcall=0;
  }

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
    gluPerspective(400.0, win->asp, win->cameraSC , win->cameraSC+2.0);
  /*
    if (win->state.ortho)
    glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
    else
    glFrustum(-1.0,1.0,-1.0,1.0,4.0,6.0);
    */
  
  if (win->bg_black)
    glClearColor(0.0, 0.0, 0.0, 0.0);
  else
    glClearColor(1.0, 1.0, 1.0, 1.0);

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  if (win->bg_black)
    glColor3f(1.0,1.0,1.0);
  else
    glColor3f(0.0,0.0,0.0);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();


  lt_position[0]=win->lightTX;
  lt_position[1]=win->lightTY;
  lt_position[2]=win->lightTZ;
  lt_position[3]=1.0;


  glTranslatef(0.0,0.0,-(win->cameraSC+1.0));

  if(!win->wireframe)
      {
	glLightfv(GL_LIGHT0, GL_POSITION, lt_position);
	glEnable(GL_LIGHT0);
      }
  if(win->frame)
    {
      double d=0.02;
      glBegin(GL_LINES);
      glVertex3f(win->lightTX-d,win->lightTY,win->lightTZ);
      glVertex3f(win->lightTX+d,win->lightTY,win->lightTZ);
      glVertex3f(win->lightTX,win->lightTY-d,win->lightTZ);
      glVertex3f(win->lightTX,win->lightTY+d,win->lightTZ);
      glVertex3f(win->lightTX,win->lightTY,win->lightTZ-d);
      glVertex3f(win->lightTX,win->lightTY,win->lightTZ+d);
      glVertex3f(-win->lightTX-d,-win->lightTY,-win->lightTZ);
      glVertex3f(-win->lightTX+d,-win->lightTY,-win->lightTZ);
      glVertex3f(-win->lightTX,-win->lightTY-d,-win->lightTZ);
      glVertex3f(-win->lightTX,-win->lightTY+d,-win->lightTZ);
      glVertex3f(-win->lightTX,-win->lightTY,-win->lightTZ-d);
      glVertex3f(-win->lightTX,-win->lightTY,-win->lightTZ+d);
      glEnd();
    }

  glTranslatef(win->cameraTX,win->cameraTY,0.0);


  glRotatef(win->cameraRX,1.0,0.0,0.0);
  glRotatef(win->cameraRY,0.0,0.0,1.0);

  xsize=win->boxMax[0]-win->boxMin[0];
  ysize=win->boxMax[1]-win->boxMin[1];
  zsize=win->boxMax[2]-win->boxMin[2];
  scalefac=xsize;
  if (ysize>scalefac) scalefac=ysize;
  if (zsize>scalefac) scalefac=zsize;

  glScalef(1.0/scalefac,1.0/scalefac,1.0/scalefac);

  glTranslatef(
	       -0.5*(win->boxMax[0]+win->boxMin[0]),
	       -0.5*(win->boxMax[1]+win->boxMin[1]),
	       -0.5*(win->boxMax[2]+win->boxMin[2])
	       );


  if (win->frame)
    {
      glBegin(GL_LINES);

/* Marker an Schnittpunkten mit section slice einsetzen ist das einfachste! */

      glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMin[2]);
      glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMin[2]);

      glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMin[2]);
      glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMin[2]);

      glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMin[2]);
      glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMin[2]);

      glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMin[2]);
      glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMin[2]);
      
      if(win->dim>2){
	glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMax[2]);
	glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMax[2]);
	
	glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMax[2]);
	glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMax[2]);
	
	glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMax[2]);
	glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMax[2]);

	glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMax[2]);
	glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMax[2]);


	glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMin[2]);
	glVertex3f(win->boxMin[0],win->boxMin[1],win->boxMax[2]);

	glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMin[2]);
	glVertex3f(win->boxMax[0],win->boxMin[1],win->boxMax[2]);
	
	glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMin[2]);
	glVertex3f(win->boxMax[0],win->boxMax[1],win->boxMax[2]);

	glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMin[2]);
	glVertex3f(win->boxMin[0],win->boxMax[1],win->boxMax[2]);
      }
      glEnd();

      glRasterPos3f(win->boxMin[0],win->boxMin[1],win->boxMin[2]); 
      wzwPrint(win,"O");
      glRasterPos3f(win->boxMax[0],win->boxMin[1],win->boxMin[2]);
      wzwPrint(win,"x");
      glRasterPos3f(win->boxMin[0],win->boxMax[1],win->boxMin[2]);
      wzwPrint(win,"y");
      if(win->dim>2){
	glRasterPos3f(win->boxMin[0],win->boxMin[1],win->boxMax[2]);
	wzwPrint(win,"z");
      }
    }
  if (!win->wireframe || (win->wireframe&&win->move_wireframe))
      {
	if (!win->list_valid)
	  {
	    glNewList(win->list,GL_COMPILE_AND_EXECUTE);
	    win->list_valid=1;
	    wzwViewLoop(win);
	    glEndList();
	  }
	else
  	  glCallList(win->list);

      }
  glFlush();
  if (!win->dump)
    {
      glwSwapBuffers(w);
      if (!win->dialog) glwQuit(w);
      glDisable(GL_LIGHT0);
      glDisable(GL_LIGHT1);
      glDisable(GL_LIGHT2);
    }
}


static void wzwView0(wzWindow win)
{
  int was_dialog;


  if (win->dump)
    {

      char fname[64];
      FILE *f;
      win->list_valid = 0;
      sprintf(fname,"%s_%d.ppm",win->dump_name_stub,win->dump_i);
      glwSwapBuffers(win->glwin);
      glwDump(win->glwin, win,fname,win->dump_w,win->dump_h);
      glwSwapBuffers(win->glwin);
      /*
      sprintf(fname,"%s_%d.eps",win->dump_name_stub,win->dump_i);
      f = fopen(fname,"w");
      glepsDumpSorted(win->glwin,f);
      fclose(f);
      */
      win->dump_i++;

    }
  else
    {

      win->list_valid=win->data_valid;
      glwAttach(win->glwin);


      glwSetKeyDownFunc(win->glwin,wzwKeyCallback);
      glwSetMouseDownFunc(win->glwin,wzwMouseDown);
      glwSetMouseUpFunc(win->glwin,wzwMouseUp);
      glwSetReshapeFunc(win->glwin,wzwReshape);
      glwSetExposeFunc(win->glwin,wzwReshape);
      glwSetRedrawFunc(win->glwin,wzwDraw);

      if (win->next_dialog)
	{
	  win->dialog=1;
	  win->next_dialog=0;

	}

      if (win->dialog)
	{
	  wzwShowState(win);
	  glwSetControlMode(win->glwin,GLW_EVENT_DRIVEN);
	  was_dialog=1;
	}
      else
	{
	  glwSetControlMode(win->glwin,GLW_APPLICATION_DRIVEN);
	  was_dialog=0;
	}
      glwProcess(win->glwin,win);
      if ((!was_dialog)&&win->dialog)
	{
	  glwSetControlMode(win->glwin,GLW_EVENT_DRIVEN);
	  glwProcess(win->glwin,win);
	}
      wzwShowState(win);
    }
}

void wzwView1(wzWindow win, wzwCallback f, void *info)
{
    win->draw=f;
    win->draw2=NULL;
    win->info=info;
    wzwView0(win);
    win->dump=0;
}

void wzwView2(wzWindow win, wzwCallback2 f, void * structure,void *info)
{
  win->draw2=f;
  win->draw=NULL;
  win->info=structure;
  win->info2=info;
  wzwView0(win);
  win->dump=0;
}

/*#############################@define@############################*/
void wzwInit(wzWindow win)
{
    int i; char tmp[100];
    wzwInitStatus(&(win->c));
    wzwInitStatus(&(win->old));
    win->saveFilePattern = WZW_PATTERN_SAVE;
    win->printLevel = WZW_PRINT_ALL;
    win->drawLevel  = WZW_DRAW_NORMAL;
    win->drawType   = WZW_TYPE_RECTANGLE;
    win->drawBound[WZW_DRAW_NONE]      = 0;
    win->drawBound[WZW_DRAW_FRAME]     = 1;
    win->drawBound[WZW_DRAW_WIREFRAME] = 200;
    win->drawBound[WZW_DRAW_COARSE]    = 1000;
    win->drawBound[WZW_DRAW_NORMAL]    = 10000;
    win->drawBound[WZW_DRAW_BEST]      = 100000;
    win->moveFactor[WZW_MOVE_RX] = 10.0;
    win->moveFactor[WZW_MOVE_RY] = 10.0;
    win->moveFactor[WZW_MOVE_TX] =  0.1;
    win->moveFactor[WZW_MOVE_TY] =  0.1;
    win->moveFactor[WZW_MOVE_TZ] =  0.1;
    win->moveFactor[WZW_MOVE_SC] = -0.2;
    win->moveMouseFactor[WZW_MOVE_RX] =  0.1;
    win->moveMouseFactor[WZW_MOVE_RY] =  0.1;
    win->moveMouseFactor[WZW_MOVE_TX] =  0.1;
    win->moveMouseFactor[WZW_MOVE_TY] = -0.1;
    win->moveMouseFactor[WZW_MOVE_TZ] =  0.1;
    win->moveMouseFactor[WZW_MOVE_SC] =  0.1;
    for(i=0;i<3;i++){
        win->boxFullMin[i]   = win->boxMin[i]    = 0;
        win->boxFullDelta[i] = win->boxDelta[i]  = 1;
        win->boxMax[i]       = win->boxMin[i] + win->boxDelta[i];
        win->prel[i]         = win->point[i] = win->puntrans[i]=0.5;
        win->slice[i]        = 0;
    }
    win->slice[2] = 1;
    win->slice[3] = -0.5;
    sprintf(tmp,win->saveFilePattern,win->name);
    wzwReadStatus(&(win->c),tmp);
    wzwDefinePosition(win);
}

void wzwGetDrawType(      wzWindow win, int *type)
{*type = win->drawType;}
void wzwGetPrintLevel(    wzWindow win, int *level)
{*level = win->printLevel;}
void wzwGetDrawLevel(     wzWindow win, int *level, int *bound)
{*level = win->drawLevel; *bound = win->drawBound[*level];}

void wzwDefineObject(     wzWindow win, int obj,
	        	  char key, char *name, char *help, char *url,
	        	  wzwCallback d, void *data)
{
    if(obj<1 || obj > win->c.maxObjects[WZW_MODE_O]) return;
    win->c.defined[WZW_MODE_O][obj] = win->objectDefined[obj] = 1;
    win->objectName[obj]     = name;
    win->objectHelp[obj]     = help;
    win->objectURL[obj]      = url;
    win->objectKey[obj]      = key;
    win->objectCallback[obj] = d;
    win->object[obj]         = data;
}

/*#############################@parameter@############################*/

static int wzwDefineParameter(wzWindow win, int obj, int par,
	        	       char key, char *name, char *help, char *url)
{
  if(obj<0 || obj >= WZW_OBJECTS)    return 0;
  if(par<0 || par >= WZW_PARAMETERS) return 0;
  win->parDefined[obj][par]  = 1;
  win->parName[obj][par]     = name;
  win->parHelp[obj][par]     = help;
  win->parURL[obj][par]      = url;
  win->parKey[obj][par]      = key;
  return 1;
}

void wzwDefineAction(    wzWindow win, int obj, int par,
			  char key, char *name, char *help, char *url,
	        	  wzwCallback d)
{
  if(wzwDefineParameter(win,obj,par,key,name,help,url)){
    win->parType[obj][par]  = WZW_TYPE_Action;
    win->par[obj][par].Action.call = d;
  }
}

void wzwDefineInteger(    wzWindow win, int obj, int par,
			  char key, char *name, char *help, char *url,
			  int min, int max)
{
  if(wzwDefineParameter(win,obj,par,key,name,help,url)){
    win->parType[obj][par]  = WZW_TYPE_Integer;
    win->par[obj][par].Int.min = min;
    win->par[obj][par].Int.max = max;
  }
}
void wzwDefineDouble(     wzWindow win, int obj, int par,
			  char key, char *name, char *help, char *url,
			  double min, double max)
{
  if(wzwDefineParameter(win,obj,par,key,name,help,url)){
    win->parType[obj][par]  = WZW_TYPE_Double;
    win->par[obj][par].Double.min = min;
    win->par[obj][par].Double.max = max;
  }
}

void wzwDefineSwitch(     wzWindow win, int obj, int par,
			  char key, char *name, char *help, char *url)
{
    if(wzwDefineParameter(win,obj,par,key,name,help,url)){
      win->parType[obj][par]  = WZW_TYPE_Switch;
    }
}
void wzwDefineEnum(       wzWindow win, int obj, int par,
			  char key, char *name, char *help, char *url,
			  int values, char** value)
{
  if(wzwDefineParameter(win,obj,par,key,name,help,url)){
    win->parType[obj][par]  = WZW_TYPE_Enum;
    win->par[obj][par].Enum.values = values;
    win->par[obj][par].Enum.value  = value;
  }
}

void wzwSetInteger(       wzWindow win, int obj, int par, int value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    return;
    if(par<0 || par >= WZW_PARAMETERS) return;
    win->c.value[obj][par].i = value;
}
void wzwSetSwitch(       wzWindow win, int obj, int par, int value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    return;
    if(par<0 || par >= WZW_PARAMETERS) return;
    win->c.value[obj][par].i = value;
}
void wzwSetEnum(       wzWindow win, int obj, int par, int value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    return;
    if(par<0 || par >= WZW_PARAMETERS) return;
    win->c.value[obj][par].i = value;
}
void wzwSetDouble(       wzWindow win, int obj, int par, double value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    return;
    if(par<0 || par >= WZW_PARAMETERS) return;
    win->c.value[obj][par].d = value;
}
int wzwGetObject(       wzWindow win)
{
  return win->c.current[WZW_MODE_O];
}
void wzwGetDouble(       wzWindow win, int obj, int par, double *value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    {*value = 0; return;}
    if(par<0 || par >= WZW_PARAMETERS) {*value = 0; return;}
    *value = win->c.value[obj][par].d;
}
void wzwGetInteger(       wzWindow win, int obj, int par, int *value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    {*value = 0; return;}
    if(par<0 || par >= WZW_PARAMETERS) {*value = 0; return;}
    *value = win->c.value[obj][par].i;
}
void wzwGetSwitch(       wzWindow win, int obj, int par, int *value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    {*value = 0; return;}
    if(par<0 || par >= WZW_PARAMETERS) {*value = 0; return;}