glsurfeval.cc

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

}

}

/*-------------------------------------------------------------------------
 * map2f - pass a desription of a surface map
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::map2f(
    long _type,
    REAL _ulower,	/* u lower domain coord 	*/
    REAL _uupper,	/* u upper domain coord 	*/
    long _ustride,	/* interpoint distance		*/
    long _uorder,	/* parametric order		*/
    REAL _vlower,	/* v lower domain coord 	*/
    REAL _vupper,	/* v upper domain coord 	*/
    long _vstride,	/* interpoint distance		*/
    long _vorder,	/* parametric order		*/
    REAL *pts)	/* control points		*/
{
#ifdef USE_INTERNAL_EVAL
   inMap2f((int) _type, (REAL) _ulower, (REAL) _uupper,
	    (int) _ustride, (int) _uorder, (REAL) _vlower,
	    (REAL) _vupper, (int) _vstride, (int) _vorder,
	    (REAL *) pts);
#else



   if(output_triangles)
     {
       if(global_bpm == NULL)
	 global_bpm = bezierPatchMeshMake2(10,10);
       if(
	  (global_bpm->bpatch == NULL &&
	  (_type == GL_MAP2_VERTEX_3 || _type == GL_MAP2_VERTEX_4))
	  ||
	  (global_bpm->bpatch_normal == NULL &&
	   (_type == GL_MAP2_NORMAL))
	  ||
	  (global_bpm->bpatch_color == NULL &&
	   (_type == GL_MAP2_INDEX || _type == GL_MAP2_COLOR_4))
	  ||
	  (global_bpm->bpatch_texcoord == NULL &&
	   (_type == GL_MAP2_TEXTURE_COORD_1 ||
	    _type == GL_MAP2_TEXTURE_COORD_2 ||
	    _type == GL_MAP2_TEXTURE_COORD_3 ||
	    _type == GL_MAP2_TEXTURE_COORD_4 )
	   ))
	 {
	   bezierPatchMeshPutPatch(global_bpm, (int) _type, _ulower, _uupper,(int)  _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
	 }
       else /*new surface patch (with multiple maps) starts*/
	 {
	   bezierPatchMesh *temp = bezierPatchMeshMake2(10,10);
	   bezierPatchMeshPutPatch(temp, (int) _type, _ulower, _uupper,(int)  _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
	   global_bpm = bezierPatchMeshListInsert(global_bpm, temp);

	   /*
	   global_bpm = bezierPatchMeshListInsert(global_bpm,
						  bezierPatchMeshMake(
								      (int) _type, _ulower, _uupper,(int)  _ustride, (int) _uorder, _vlower, _vupper, (int) _vstride, (int) _vorder, pts, 10, 10));
	   */
	 }
     }
   else /*not output triangles*/
     {
       glMap2f((GLenum) _type, (GLfloat) _ulower, (GLfloat) _uupper,
	       (GLint) _ustride, (GLint) _uorder, (GLfloat) _vlower,
	       (GLfloat) _vupper, (GLint) _vstride, (GLint) _vorder,
	       (const GLfloat *) pts);
     }

#endif
}


/*-------------------------------------------------------------------------
 * mapmesh2f - evaluate a mesh of points on lattice
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::mapmesh2f(long style, long umin, long umax, long vmin, long vmax)
{
#ifdef NO_EVALUATION
return;
#endif

#ifdef USE_INTERNAL_EVAL
    inEvalMesh2((int)umin, (int)vmin, (int)umax, (int)vmax);
#else



if(output_triangles)
{
#ifdef USE_LOD
  bezierPatchMeshBeginStrip(global_bpm, GL_POLYGON);
  bezierPatchMeshInsertUV(global_bpm, global_grid_u0, global_grid_v0);
  bezierPatchMeshInsertUV(global_bpm, global_grid_u1, global_grid_v1);
  bezierPatchMeshInsertUV(global_bpm, (REAL)global_grid_nu, (REAL)global_grid_nv);
  bezierPatchMeshInsertUV(global_bpm, (REAL)umin, (REAL)vmin);
  bezierPatchMeshInsertUV(global_bpm, (REAL)umax, (REAL)vmax);
  bezierPatchMeshEndStrip(global_bpm);

#else

  REAL du, dv;
  long i,j;
  if(global_grid_nu == 0 || global_grid_nv == 0)
    return; /*no points need to be output*/
  du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
  dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;

  if(global_grid_nu >= global_grid_nv){

    for(i=umin; i<umax; i++){
      REAL u1 = (i==global_grid_nu)? global_grid_u1:(global_grid_u0 + i*du);
      REAL u2 = ((i+1) == global_grid_nu)? global_grid_u1: (global_grid_u0+(i+1)*du);

      bgnqstrip();
      for(j=vmax; j>=vmin; j--){
	REAL v1 = (j == global_grid_nv)? global_grid_v1: (global_grid_v0 +j*dv);
        
	coord2f(u1, v1);
	coord2f(u2, v1);
      }
      endqstrip();
    }
  }
  else{

    for(i=vmin; i<vmax; i++){
      REAL v1 = (i==global_grid_nv)? global_grid_v1:(global_grid_v0 + i*dv);
      REAL v2 = ((i+1) == global_grid_nv)? global_grid_v1: (global_grid_v0+(i+1)*dv);

      bgnqstrip();
      for(j=umax; j>=umin; j--){
	REAL u1 = (j == global_grid_nu)? global_grid_u1: (global_grid_u0 +j*du);        
	coord2f(u1, v2);
	coord2f(u1, v1);
      }
      endqstrip();
    }
  }
#endif
}
else
{
    switch(style) {
    default:
    case N_MESHFILL:
	glEvalMesh2((GLenum) GL_FILL, (GLint) umin, (GLint) umax,
		(GLint) vmin, (GLint) vmax);
	break;
    case N_MESHLINE:
	glEvalMesh2((GLenum) GL_LINE, (GLint) umin, (GLint) umax,
		(GLint) vmin, (GLint) vmax);
	break;
    case N_MESHPOINT:
	glEvalMesh2((GLenum) GL_POINT, (GLint) umin, (GLint) umax,
		(GLint) vmin, (GLint) vmax);
	break;
    }
  }

#endif

#ifdef STATISTICS
	STAT_num_of_quad_strips += (umax-umin)*(vmax-vmin);
#endif
}

/*-------------------------------------------------------------------------
 * evalcoord2f - evaluate a point on a surface
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::evalcoord2f(long, REAL u, REAL v)
{


#ifdef NO_EVALUATION
return;
#endif


    newtmeshvert(u, v);
}

/*-------------------------------------------------------------------------
 * evalpoint2i - evaluate a grid point
 *-------------------------------------------------------------------------
 */
void
OpenGLSurfaceEvaluator::evalpoint2i(long u, long v)
{
#ifdef NO_EVALUATION
return;
#endif

    newtmeshvert(u, v);
}

void
OpenGLSurfaceEvaluator::point2i( long u, long v )
{
#ifdef NO_EVALUATION
return;
#else

#ifdef USE_INTERNAL_EVAL
    inEvalPoint2( (int)u,  (int)v);
#else


if(output_triangles)
{

  REAL du, dv;
  REAL fu,fv;
  du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
  dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
  fu = (u==global_grid_nu)? global_grid_u1:(global_grid_u0 + u*du);
  fv = (v == global_grid_nv)? global_grid_v1: (global_grid_v0 +v*dv);
  coord2f(fu,fv);
}
else
    glEvalPoint2((GLint) u, (GLint) v);


#endif

#ifdef STATISTICS
  STAT_num_of_eval_vertices++;
#endif

#endif

}

void
OpenGLSurfaceEvaluator::coord2f( REAL u, REAL v )
{
#ifdef NO_EVALUATION
return;
#else

#ifdef USE_INTERNAL_EVAL
    inEvalCoord2f( u, v);
#else


if(output_triangles)
    bezierPatchMeshInsertUV(global_bpm, u,v);
else
    glEvalCoord2f((GLfloat) u, (GLfloat) v);


#endif


#ifdef STATISTICS
  STAT_num_of_eval_vertices++;
#endif

#endif
}

void
OpenGLSurfaceEvaluator::newtmeshvert( long u, long v )
{
#ifdef NO_EVALUATION
return;
#else

    if (tmeshing) {

	if (vcount == 2) {
	    vertexCache[0]->invoke(this);
	    vertexCache[1]->invoke(this);
	    point2i( u,  v);

	} else {
	    vcount++;
	}

	vertexCache[which]->saveEvalPoint(u, v);
	which = 1 - which;
    } else {
	point2i( u,  v);
    }
#endif
}

void
OpenGLSurfaceEvaluator::newtmeshvert( REAL u, REAL v )
{
#ifdef NO_EVALUATION
return;
#else
    if (tmeshing) {


	if (vcount == 2) {
	    vertexCache[0]->invoke(this);
	    vertexCache[1]->invoke(this);
	    coord2f(u,v);

	} else {
	    vcount++;
	}

	vertexCache[which]->saveEvalCoord(u, v);
	which = 1 - which;
    } else {

	coord2f( u,  v);
    }
#endif

}

void
OpenGLSurfaceEvaluator::putCallBack(GLenum which, _GLUfuncptr fn )
{
  switch(which)
    {
    case GLU_NURBS_BEGIN:
      beginCallBackN = (void (GLAPIENTRY *) (GLenum)) fn;
      break;
    case GLU_NURBS_END:
      endCallBackN = (void (GLAPIENTRY *) (void)) fn;
      break;
    case GLU_NURBS_VERTEX:
      vertexCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
      break;
    case GLU_NURBS_NORMAL:
      normalCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
      break;
    case GLU_NURBS_COLOR:
      colorCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
      break;
    case GLU_NURBS_TEXTURE_COORD:
      texcoordCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
      break;
    case GLU_NURBS_BEGIN_DATA:
      beginCallBackData = (void (GLAPIENTRY *) (GLenum, void*)) fn;
      break;
    case GLU_NURBS_END_DATA:
      endCallBackData = (void (GLAPIENTRY *) (void*)) fn;
      break;
    case GLU_NURBS_VERTEX_DATA:
      vertexCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
      break;
    case GLU_NURBS_NORMAL_DATA:
      normalCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
      break;
    case GLU_NURBS_COLOR_DATA:
      colorCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
      break;
    case GLU_NURBS_TEXTURE_COORD_DATA:
      texcoordCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
      break;

    }
}


void
OpenGLSurfaceEvaluator::beginCallBack(GLenum which, void *data)
{
  if(beginCallBackData)
    beginCallBackData(which, data);
  else if(beginCallBackN)
    beginCallBackN(which);
}

void
OpenGLSurfaceEvaluator::endCallBack(void *data)
{
  if(endCallBackData)
    endCallBackData(data);
  else if(endCallBackN)
    endCallBackN();
}

void
OpenGLSurfaceEvaluator::vertexCallBack(const GLfloat *vert, void* data)
{
  if(vertexCallBackData)
    vertexCallBackData(vert, data);
  else if(vertexCallBackN)
    vertexCallBackN(vert);
}


void
OpenGLSurfaceEvaluator::normalCallBack(const GLfloat *normal, void* data)
{
  if(normalCallBackData)
    normalCallBackData(normal, data);
  else if(normalCallBackN)
    normalCallBackN(normal);
}

void
OpenGLSurfaceEvaluator::colorCallBack(const GLfloat *color, void* data)
{
  if(colorCallBackData)
    colorCallBackData(color, data);
  else if(colorCallBackN)
    colorCallBackN(color);
}

void
OpenGLSurfaceEvaluator::texcoordCallBack(const GLfloat *texcoord, void* data)
{
  if(texcoordCallBackData)
    texcoordCallBackData(texcoord, data);
  else if(texcoordCallBackN)
    texcoordCallBackN(texcoord);
}