viewer3.c

su 的源代码库

	    for (iy=1;iy<ny-1;iy+=2) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix]);
		  glVertex3fv(datatop[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix+1]);
		  glVertex3fv(datatop[iy+1][ix+1]);
	    }
      }

      /**********************************************************
      Plot vertical segments
      **********************************************************/
      for (ix=0;ix<nx;ix++) {
	    for (iy=0;iy<ny;iy++) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix]);
		  glVertex3fv(databot[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix]);
		  glVertex3fv(datatop[iy][ix]);
            }
      }

      /**********************************************************
      Plot slant segments
      **********************************************************/
      for (ix=0;ix<nx-1;ix++) {
	    for (iy=0;iy<ny-1;iy+=2) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix]);
		  glVertex3fv(databot[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix+1]);
		  glVertex3fv(datatop[iy][ix+1]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy+1][ix]);
		  glVertex3fv(databot[iy+1][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix]);
		  glVertex3fv(datatop[iy][ix]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy+1][ix]);
		  glVertex3fv(databot[iy+1][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix+1]);
		  glVertex3fv(datatop[iy][ix+1]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy+1][ix+1]);
		  glVertex3fv(databot[iy+1][ix+1]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix]);
		  glVertex3fv(datatop[iy+1][ix]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy+1][ix+1]);
		  glVertex3fv(databot[iy+1][ix+1]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy][ix+1]);
		  glVertex3fv(datatop[iy][ix+1]);
	    }

	    for (iy=1;iy<ny-1;iy+=2) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix]);
		  glVertex3fv(databot[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix]);
		  glVertex3fv(datatop[iy+1][ix]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix]);
		  glVertex3fv(databot[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix+1]);
		  glVertex3fv(datatop[iy+1][ix+1]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy+1][ix]);
		  glVertex3fv(databot[iy+1][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix+1]);
		  glVertex3fv(datatop[iy+1][ix+1]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix]);
		  glVertex3fv(databot[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix+1]);
		  glVertex3fv(datatop[iy+1][ix+1]);

		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emisbot[iy][ix+1]);
		  glVertex3fv(databot[iy][ix+1]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emistop[iy+1][ix+1]);
		  glVertex3fv(datatop[iy+1][ix+1]);
	    }
      }

      glEnd();
      glEndList();
}

void
showTri(int ihz,float ***data,
      int nx,int ny,float ***emis) 
{
      int ix,iy;

      glNewList(ihz+3+nhz*3,GL_COMPILE);
      glBegin(GL_LINES);

      /**********************************************************
	Plot 2 grids like this

         (ix,iy+2)_____(ix+1,iy+2)
                 |    /|
                 |   / |
	         |  /  |
                 | /   |
                 |/    |
 	(ix,iy+1)|-----|(ix+1,iy+1)
		 |\    |
		 | \   |
		 |  \  |
		 |   \ |
	  (ix,iy)|____\|(ix+1,iy)

      **********************************************************/
      for (ix=0;ix<nx-1;ix++) {   /*horizontal edges*/
	    for (iy=0;iy<ny;iy++) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix]);
		  glVertex3fv(data[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix+1]);
		  glVertex3fv(data[iy][ix+1]);
            }
      }

      for (ix=0;ix<nx;ix++) {   /*vertical edges*/
	    for (iy=0;iy<ny-1;iy++) {
	          glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix]);
		  glVertex3fv(data[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy+1][ix]);
		  glVertex3fv(data[iy+1][ix]);
            }
      }

      for (ix=0;ix<nx-1;ix++) {   /*slant edges*/
	    for (iy=0;iy<ny-1;iy+=2) {
	          glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix]);
		  glVertex3fv(data[iy+1][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix+1]);
		  glVertex3fv(data[iy][ix+1]);
	    }
        
	    for (iy=1;iy<ny-1;iy+=2) {
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy][ix]);
		  glVertex3fv(data[iy][ix]);
		  glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emis[iy+1][ix+1]);
		  glVertex3fv(data[iy+1][ix+1]);
	    }
      }

      glEnd();
      glEndList();
}

void
recalcModelView(void)
{
      GLfloat m[4][4];		/*the matrix*/

      glPopMatrix();
      glPushMatrix();

      build_rotmatrix(m, curquat);
      glMultMatrixf(&m[0][0]);
      glScalef(glb_scalefactor, glb_scalefactor, glb_scalefactor);
      glb_newmodel=0;
}

/***************************************************************
function to print a message in the window
***************************************************************/
void
showMessage(GLfloat x, GLfloat y, GLfloat z, char *message)
{
      glPushMatrix();
      glDisable(GL_LIGHTING);
      glTranslatef(x, y, z);
      glScalef(.01, .01, .01);
      /* To rotate 90 degrees counterclockwise aroubd (0,0,1)*/
      glRotatef(90.0, 0.0, 0.0, 1.0);
      while (*message) {
       	    glutStrokeCharacter(GLUT_STROKE_ROMAN, *message);
	    message++;
      }
      glEnable(GL_LIGHTING);
      glPopMatrix();
}

/***************************************************
Called whenever glutPostRedisplay() is called
***************************************************/
void
redraw(void)
{
      int ihz;
      if (glb_newmodel) recalcModelView();
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

      for (ihz=0;ihz<nhz;ihz++) {
	    if (hlt==LAYER && glb_on_or_off[ihz]==ON)
		  glCallList(ihz+3);
	    else if (hlt==HORZ && glb_on_or_off[ihz]==ON)
		  glCallList(nhz+ihz+3);
	    else if (hlt==TETRA && glb_on_or_off[ihz]==ON)
		  glCallList(ihz+2*nhz+3);
	    else if (hlt==TRI && glb_on_or_off[ihz]==ON)
		  glCallList(ihz+3*nhz+3);
      }

      if (glb_plot_rays==PLOT_RAYS) {
	    if (wc_rays==WHITE)
	          glCallList(nhz*4+3);
	    else
	          glCallList(nhz*4+4);
      }

      if (plot_st==PLOT_SURFACE_TRAVELTIMES)
            glCallList(nhz*4+5);

      if (glb_plot_wf==PLOT_WF) {
	    if (wfs==WIRED)
                  glCallList(nhz*4+6);
	    else
	          glCallList(nhz*4+7);
      }

      glFlush();
      /*showMessage(0, 0, 0, "x direction");*/
      glutSwapBuffers();
}

/****************************************
This call back is called when the window
is rescaled
****************************************/
void
myReshape(int w, int h)
{
      glViewport(0, 0, w, h);
      glb_W=w;
      glb_H=h;
}

/*****************************************
This call back is called when the mouse is
pressed
*****************************************/
void
mouse(int button, int state, int x, int y)
{
      if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN) {
	    glb_spinning=0;
	    glutIdleFunc(NULL);
	    glb_moving=1;
	    glb_beginx=x;
	    glb_beginy=y;
	    if(glutGetModifiers() & GLUT_ACTIVE_SHIFT) 
		  glb_scaling=1;
	    else 
		  glb_scaling=0;
      }	
      if (button==GLUT_LEFT_BUTTON && state==GLUT_UP) {
	    glb_moving=0;
	    glb_spinning=0;
      }
}

/********************************************
Animate the object to continue its motion
********************************************/
void
animate(void)
{
      add_quats(lastquat, curquat, curquat);
      glb_newmodel=1;
      glutPostRedisplay();
}

/*********************************************
Called when the mouse is pressed while moved
*********************************************/
void
motion(int x,int y)
{
      if (glb_scaling) {
	    glb_scalefactor=glb_scalefactor*
		  (1.0+(((float)(glb_beginy-y))/glb_H));
	    glb_beginx=x;
	    glb_beginy=y;
	    glb_newmodel=1;
	    glutPostRedisplay();
	    return;
      }

      if (glb_moving) {
	    trackball(lastquat,
		  (2.0*glb_beginx-glb_W)/glb_W,
		  (glb_H-2.0*glb_beginy)/glb_H,
		  (2.0*x-glb_W)/glb_W,
		  (glb_H-2.0*y)/glb_H,tbs);

	    #ifdef DEBUG
	    fprintf(stderr,"q=%f,%f,%f,%f\n",curquat[0],curquat[1],
		  curquat[2],curquat[3]);
            #endif

	    glb_beginx=x;
	    glb_beginy=y;
	    glb_spinning=1;
	    glutIdleFunc(animate);
      }
}

/******************************************
switches
******************************************/
void
controlLights(int value)
{
      switch (value) {
	    case -1:
		  exit(0);
		  break;
	    case 0:
		  glutFullScreen();
		  break;
            case 1:
                  if (wc_rays==WHITE)
                        wc_rays=COLORED;
                  else
                        wc_rays=WHITE;
                  break;
            case 2:
		  if (glb_plot_rays==DO_NOT_PLOT_RAYS)
		       	glb_plot_rays=PLOT_RAYS;
		  else
			glb_plot_rays=DO_NOT_PLOT_RAYS;
                  break;
            case 3:
                  if (plot_st==DO_NOT_PLOT_SURFACE_TRAVELTIMES)
		        plot_st=PLOT_SURFACE_TRAVELTIMES;
                  else 
		        plot_st=DO_NOT_PLOT_SURFACE_TRAVELTIMES;
		  break;
            case 4:
                  if (wfs==WIRED)
                        wfs=SOLID;
                  else
	      	        wfs=WIRED;                  
                  break;
            case 5:
                  if (glb_plot_wf==DO_NOT_PLOT_WF)
                        glb_plot_wf=PLOT_WF;
                  else
                        glb_plot_wf=DO_NOT_PLOT_WF;
                  break;
            case 6:
		  if (hlt==HORZ)
		        hlt=TRI;
		  else if (hlt==TRI)
			hlt=TETRA;
		  else if (hlt==TETRA)
			hlt=LAYER;
		  else 
			hlt=HORZ;	
		  break;
	    default:
		  if (glb_on_or_off[value-7]==ON)
			glb_on_or_off[value-7]=OFF;
		  else 
		        glb_on_or_off[value-7]=ON;
	          break;	
      }
      glutPostRedisplay();
}

/************************************************
When it is not visible, do not waste the computer
resources
************************************************/
void
vis(int visible)
{
      if (visible==GLUT_VISIBLE) {
	    if (glb_spinning)
		  glutIdleFunc(animate);
      } else {
	    if (glb_spinning)
	       	  glutIdleFunc(NULL);
      }
}

/*********************************************************************
Author: Zhaobo Meng, CWP 1996

Set up the traveltime mapping: traveltime->color
************************************************/
void
vEmission(float v,float vmin,float vmax,
      float *emission)
{
      float color;
      color=(v-vmin)/(vmax-vmin);
      color=MAX(0.0,MIN(1.0,color));
      if (glb_hue==1) {
	    emission[0]=1.0;
	    emission[1]=color;
	    emission[2]=1.0;
      } else {
	    emission[0]=color;
	    emission[1]=color;
	    emission[2]=color;
      }
      emission[3]=glb_alpha;
}

/*********************************************************************
Author: Zhaobo Meng, CWP 1996

Set up the traveltime mapping: traveltime->color
*********************************************************************/
void
tEmission(float t,float tmin,float tmax,
      float *emission)
{
      if (fabs(tmax-tmin)==0.0)
            emission[1]=0.0;
      else  
            emission[1]=MAX(0.0,MIN(1.0,(t-tmin)/(tmax-tmin)));
      emission[0]=1.0;
      emission[2]=emission[1];
      emission[3]=glb_alpha;
}

static void 
normalize_quat(float q[4])
{
      int i;
      float mag;

      mag = (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
      for (i = 0; i < 4; i++) q[i] /= mag;
}