glsurfeval.cc

winNT技术操作系统,国外开放的原代码和LIUX一样

	  break; /*exit the main loop*/
	}
      else /* case3: neither is empty, plus the leftMostV, there is at least one triangle to output*/
	{
	  if(upper_val[i] <= lower_val[j])
	    {
	      bgntfan();
	      coord2f(lower_val[j], v_lower);
//	      glNormal3fv(lowerNormal[j]);
//	      glVertex3fv(lowerXYZ[j]);

	      /*find the last k>=i such that
	       *upperverts[k][0] <= lowerverts[j][0]
	       */
	      k=i;

	      while(k<n_upper)
		{
		  if(upper_val[k] > lower_val[j])
		    break;
		  k++;

		}
	      k--;


	      for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
		{
		  coord2f(upper_val[l], v_upper);
//		  glNormal3fv(upperNormal[l]);
//		  glVertex3fv(upperXYZ[l]);

		}
	      coord2f(leftMostV[0], leftMostV[1]);
//	      glNormal3fv(leftMostNormal);
//	      glVertex3fv(leftMostXYZ);

	      endtfan();

	      /*update i and leftMostV for next loop
	       */
	      i = k+1;

	      leftMostV[0] = upper_val[k];
	      leftMostV[1] = v_upper;
//	      leftMostNormal = upperNormal[k];
//	      leftMostXYZ = upperXYZ[k];
	    }
	  else /*upperVerts[i][0] > lowerVerts[j][0]*/
	    {
	      bgntfan();
	      coord2f(upper_val[i], v_upper);
//	      glNormal3fv(upperNormal[i]);
//	      glVertex3fv(upperXYZ[i]);
        
	      coord2f(leftMostV[0], leftMostV[1]);
//		glNormal3fv(leftMostNormal);
//	      glVertex3fv(leftMostXYZ);
        

	      /*find the last k>=j such that
	       *lowerverts[k][0] < upperverts[i][0]
	       */
	      k=j;
	      while(k< n_lower)
		{
		  if(lower_val[k] >= upper_val[i])
		    break;
		  coord2f(lower_val[k], v_lower);
//		  glNormal3fv(lowerNormal[k]);
//		  glVertex3fv(lowerXYZ[k]);

		  k++;
		}
	      endtfan();

	      /*update j and leftMostV for next loop
	       */
	      j=k;
	      leftMostV[0] = lower_val[j-1];
	      leftMostV[1] = v_lower;

//	      leftMostNormal = lowerNormal[j-1];
//	      leftMostXYZ = lowerXYZ[j-1];
	    }
	}
    }
  //clean up
//  free(upperXYZ);
//  free(lowerXYZ);
//  free(upperNormal);
//  free(lowerNormal);
#endif

}


void
OpenGLSurfaceEvaluator::evalVStrip(int n_left, REAL u_left, REAL* left_val, int n_right, REAL u_right, REAL* right_val)
{
#ifdef USE_INTERNAL_EVAL
	inEvalVStrip(n_left, u_left, left_val,
	n_right, u_right, right_val);
#else

#ifdef FOR_CHRIS
	evalVStripExt(n_left, u_left, left_val,
		      n_right, u_right, right_val);
	return;

#endif

  int i,j,k,l;
  REAL botMostV[2];
  /*
   *the algorithm works by scanning from bot to top.
   *botMostV: the bot most of the remaining verteces (on both left and right).
   *	       it could an element of leftVerts or rightVerts.
   *i: leftVerts[i] is the first vertex to the top of botMostV on left line
   *j: rightVerts[j] is the first vertex to the top of botMostV on rightline
   */

  /*initialize i,j,and botMostV
   */
  if(left_val[0] <= right_val[0])
    {
      i=1;
      j=0;

      botMostV[0] = u_left;
      botMostV[1] = left_val[0];
    }
  else
    {
      i=0;
      j=1;

      botMostV[0] = u_right;
      botMostV[1] = right_val[0];
    }

  /*the main loop.
   *the invariance is that:
   *at the beginning of each loop, the meaning of i,j,and botMostV are
   *maintained
   */
  while(1)
    {
      if(i >= n_left) /*case1: no more in left*/
	{
	  if(j<n_right-1) /*at least two vertices in right*/
	    {
	      bgntfan();
	      coord2f(botMostV[0], botMostV[1]);
	      while(j<n_right){
		coord2f(u_right, right_val[j]);
//		glNormal3fv(rightNormal[j]);
//		glVertex3fv(rightXYZ[j]);
		j++;

	      }
	      endtfan();
	    }
	  break; /*exit the main loop*/
	}
      else if(j>= n_right) /*case2: no more in right*/
	{
	  if(i<n_left-1) /*at least two vertices in left*/
	    {
	      bgntfan();
	      coord2f(botMostV[0], botMostV[1]);
//	      glNormal3fv(botMostNormal);
//	      glVertex3fv(botMostXYZ);
        
	      for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
		{
		  coord2f(u_left, left_val[k]);
//		  glNormal3fv(leftNormal[k]);
//		  glVertex3fv(leftXYZ[k]);
		}

	      endtfan();
	    }
	  break; /*exit the main loop*/
	}
      else /* case3: neither is empty, plus the botMostV, there is at least one triangle to output*/
	{
	  if(left_val[i] <= right_val[j])
	    {
	      bgntfan();
	      coord2f(u_right, right_val[j]);
//	      glNormal3fv(rightNormal[j]);
//	      glVertex3fv(rightXYZ[j]);

	      /*find the last k>=i such that
	       *leftverts[k][0] <= rightverts[j][0]
	       */
	      k=i;

	      while(k<n_left)
		{
		  if(left_val[k] > right_val[j])
		    break;
		  k++;

		}
	      k--;


	      for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
		{
		  coord2f(u_left, left_val[l]);
//		  glNormal3fv(leftNormal[l]);
//		  glVertex3fv(leftXYZ[l]);

		}
	      coord2f(botMostV[0], botMostV[1]);
//	      glNormal3fv(botMostNormal);
//	      glVertex3fv(botMostXYZ);

	      endtfan();

	      /*update i and botMostV for next loop
	       */
	      i = k+1;

	      botMostV[0] = u_left;
	      botMostV[1] = left_val[k];
//	      botMostNormal = leftNormal[k];
//	      botMostXYZ = leftXYZ[k];
	    }
	  else /*left_val[i] > right_val[j])*/
	    {
	      bgntfan();
	      coord2f(u_left, left_val[i]);
//	      glNormal3fv(leftNormal[i]);
//	      glVertex3fv(leftXYZ[i]);
        
	      coord2f(botMostV[0], botMostV[1]);
//	      glNormal3fv(botMostNormal);
//	      glVertex3fv(botMostXYZ);
        

	      /*find the last k>=j such that
	       *rightverts[k][0] < leftverts[i][0]
	       */
	      k=j;
	      while(k< n_right)
		{
		  if(right_val[k] >= left_val[i])
		    break;
		  coord2f(u_right, right_val[k]);
//		  glNormal3fv(rightNormal[k]);
//		  glVertex3fv(rightXYZ[k]);

		  k++;
		}
	      endtfan();

	      /*update j and botMostV for next loop
	       */
	      j=k;
	      botMostV[0] = u_right;
	      botMostV[1] = right_val[j-1];

//	      botMostNormal = rightNormal[j-1];
//	      botMostXYZ = rightXYZ[j-1];
	    }
	}
    }
  //clean up
//  free(leftXYZ);
//  free(leftNormal);
//  free(rightXYZ);
//  free(rightNormal);
#endif
}


void
OpenGLSurfaceEvaluator::bgnqstrip(void)
{
  if(output_triangles)
    bezierPatchMeshBeginStrip(global_bpm, GL_QUAD_STRIP);
  else
    glBegin((GLenum) GL_QUAD_STRIP);

#ifdef STATISTICS
	STAT_num_of_quad_strips++;
#endif
}

void
OpenGLSurfaceEvaluator::endqstrip(void)
{
  if(output_triangles)
    bezierPatchMeshEndStrip(global_bpm);
  else
    glEnd();

}

/*-------------------------------------------------------------------------
 * bgnmap2f - preamble to surface definition and evaluations
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::bgnmap2f(long)
{
  if(output_triangles)
    {
      /*deallocate the space which may has been
       *allocated by global_bpm previously
       */
      if(global_bpm != NULL) {
	bezierPatchMeshListDelete(global_bpm);
	global_bpm = NULL;
      }


      /*
	auto_normal_flag = 1; //always output normal in callback mode.
			      //we could have used the following code,
			      //but Inspector doesn't have gl context
			      //before it calls tessellator.
			      //this way is temporary.
	*/
      //NEWCALLBACK
      //if one of the two normal callback functions are set,
      //then set
      if(normalCallBackN != NULL ||
	 normalCallBackData != NULL)
	auto_normal_flag = 1;
      else
	auto_normal_flag = 0;

      //initialize so that no maps initially
      vertex_flag = 0;
      normal_flag = 0;
      color_flag = 0;
      texcoord_flag = 0;

      /*
      if(glIsEnabled(GL_AUTO_NORMAL) == GL_TRUE)
	auto_normal_flag = 1;
      else if (callback_auto_normal == 1)
	auto_normal_flag = 1;
      else
	auto_normal_flag = 0;
	*/

      //NEWCALLBACK: no need to worry about gl states when gling clalback
    }
  else
    {
      glPushAttrib((GLbitfield) GL_EVAL_BIT);

      /*to avoid side effect, we restor the opengl state for GL_POLYGON_MODE
       */       
      glGetIntegerv(GL_POLYGON_MODE, gl_polygon_mode);
    }

}

/*-------------------------------------------------------------------------
 * endmap2f - postamble to a map
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::endmap2f(void)
{

  if(output_triangles)
    {
      //bezierPatchMeshListDelDeg(global_bpm);

      //    bezierPatchMeshListEval(global_bpm);

      //surfcount++;
      //printf("surfcount=%i\n", surfcount);
      //if(surfcount == 8) exit(0);

      inBPMListEvalEM(global_bpm);



/*
    global_bpm = bezierPatchMeshListReverse(global_bpm);
    {
      float *vertex_array;
      float *normal_array;
      int *length_array;
      int *type_array;
      int num_strips;
      bezierPatchMeshListCollect(global_bpm, &vertex_array, &normal_array, &length_array, &type_array, &num_strips);
      drawStrips(vertex_array, normal_array, length_array, type_array, num_strips);
      free(vertex_array);
      free(normal_array);
      free(length_array);
      free(type_array);
    }
*/

    //bezierPatchMeshListPrint(global_bpm);
    //bezierPatchMeshListDraw(global_bpm);

//	  printf("num triangles=%i\n", bezierPatchMeshListNumTriangles(global_bpm));

#ifdef USE_LOD
#else
    bezierPatchMeshListDelete(global_bpm);
    global_bpm = NULL;
#endif

  }
else
  {
#ifndef USE_LOD
glPopAttrib();
#endif

#ifdef STATISTICS
    fprintf(stderr, "num_vertices=%i,num_triangles=%i,num_quads_strips=%i\n", STAT_num_of_eval_vertices,STAT_num_of_triangles,STAT_num_of_quad_strips);
#endif

    /*to restore the gl_polygon_mode
     */
#ifndef USE_LOD
    glPolygonMode( GL_FRONT, (GLenum) gl_polygon_mode[0]);
    glPolygonMode( GL_BACK,  (GLenum) gl_polygon_mode[1]);
#endif