OpenGLSurfaceEvaluator Class Reference

#include <glsurfeval.h>

Inheritance diagram for OpenGLSurfaceEvaluator:

Collaboration diagram for OpenGLSurfaceEvaluator:

Public Member Functions
	OpenGLSurfaceEvaluator ()
virtual	~OpenGLSurfaceEvaluator (void)
void	polymode (long style)
void	range2f (long, REAL *, REAL *)
void	domain2f (REAL, REAL, REAL, REAL)
void	addMap (SurfaceMap *)
void	enable (long)
void	disable (long)
void	bgnmap2f (long)
void	map2f (long, REAL, REAL, long, long, REAL, REAL, long, long, REAL *)
void	mapgrid2f (long, REAL, REAL, long, REAL, REAL)
void	mapmesh2f (long, long, long, long, long)
void	evalcoord2f (long, REAL, REAL)
void	evalpoint2i (long, long)
void	endmap2f (void)
void	bgnline (void)
void	endline (void)
void	bgnclosedline (void)
void	endclosedline (void)
void	bgntmesh (void)
void	swaptmesh (void)
void	endtmesh (void)
void	bgnqstrip (void)
void	endqstrip (void)
void	bgntfan (void)
void	endtfan (void)
void	evalUStrip (int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)
void	evalVStrip (int n_left, REAL u_left, REAL *left_val, int n_right, REAL u_right, REAL *right_val)
void	coord2f (REAL, REAL)
void	point2i (long, long)
void	newtmeshvert (REAL, REAL)
void	newtmeshvert (long, long)
void	putCallBack (GLenum which, _GLUfuncptr fn)
int	get_vertices_call_back ()
void	put_vertices_call_back (int flag)
void	put_callback_auto_normal (int flag)
int	get_callback_auto_normal ()
void	set_callback_userData (void *data)
void	LOD_eval_list (int level)
Public Member Functions inherited from BasicSurfaceEvaluator
virtual	~BasicSurfaceEvaluator ()
Public Member Functions inherited from CachingEvaluator
virtual	~CachingEvaluator ()
virtual int	canRecord (void)
virtual int	canPlayAndRecord (void)
virtual int	createHandle (int handle)
virtual void	beginOutput (ServiceMode, int handle)
virtual void	endOutput (void)
virtual void	discardRecording (int handle)
virtual void	playRecording (int handle)

Private Member Functions
	void (GLAPIENTRY *beginCallBackN)(GLenum type)
	void (GLAPIENTRY *endCallBackN)(void)
	void (GLAPIENTRY *vertexCallBackN)(const GLfloat *vert)
	void (GLAPIENTRY *normalCallBackN)(const GLfloat *normal)
	void (GLAPIENTRY *colorCallBackN)(const GLfloat *color)
	void (GLAPIENTRY *texcoordCallBackN)(const GLfloat *texcoord)
	void (GLAPIENTRY *beginCallBackData)(GLenum type
	void (GLAPIENTRY *endCallBackData)(void *data)
	void (GLAPIENTRY *vertexCallBackData)(const GLfloat *vert
	void (GLAPIENTRY *normalCallBackData)(const GLfloat *normal
	void (GLAPIENTRY *colorCallBackData)(const GLfloat *color
	void (GLAPIENTRY *texcoordCallBackData)(const GLfloat *texcoord
void	beginCallBack (GLenum type, void *data)
void	endCallBack (void *data)
void	vertexCallBack (const GLfloat *vert, void *data)
void	normalCallBack (const GLfloat *normal, void *data)
void	colorCallBack (const GLfloat *color, void *data)
void	texcoordCallBack (const GLfloat *texcoord, void *data)
void	LOD_triangle (REAL A[2], REAL B[2], REAL C[2], int level)
void	LOD_eval (int num_vert, REAL *verts, int type, int level)
void	inDoDomain2WithDerivs (int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
void	inPreEvaluate (int order, REAL vprime, REAL *coeff)
void	inPreEvaluateWithDeriv (int order, REAL vprime, REAL *coeff, REAL *coeffDeriv)
void	inComputeFirstPartials (REAL *p, REAL *pu, REAL *pv)
void	inComputeNormal2 (REAL *pu, REAL *pv, REAL *n)
void	inDoEvalCoord2 (REAL u, REAL v, REAL *retPoint, REAL *retNormal)
void	inDoEvalCoord2NOGE (REAL u, REAL v, REAL *retPoint, REAL *retNormal)
void	inMap2f (int k, REAL ulower, REAL uupper, int ustride, int uorder, REAL vlower, REAL vupper, int vstride, int vorder, REAL *ctlPoints)
void	inMapGrid2f (int nu, REAL u0, REAL u1, int nv, REAL v0, REAL v1)
void	inEvalMesh2 (int lowU, int lowV, int highU, int highV)
void	inEvalPoint2 (int i, int j)
void	inEvalCoord2f (REAL u, REAL v)
void	inEvalULine (int n_points, REAL v, REAL *u_vals, int stride, REAL ret_points[][3], REAL ret_normals[][3])
void	inEvalVLine (int n_points, REAL u, REAL *v_vals, int stride, REAL ret_points[][3], REAL ret_normals[][3])
void	inEvalUStrip (int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)
void	inEvalVStrip (int n_left, REAL u_left, REAL *left_val, int n_right, REAL u_right, REAL *right_val)
void	inPreEvaluateBV (int k, int uorder, int vorder, REAL vprime, REAL *baseData)
void	inPreEvaluateBU (int k, int uorder, int vorder, REAL uprime, REAL *baseData)
void	inPreEvaluateBV_intfac (REAL v)
void	inPreEvaluateBU_intfac (REAL u)
void	inDoDomain2WithDerivsBV (int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
void	inDoDomain2WithDerivsBU (int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
void	inDoEvalCoord2NOGE_BV (REAL u, REAL v, REAL *retPoint, REAL *retNormal)
void	inDoEvalCoord2NOGE_BU (REAL u, REAL v, REAL *retPoint, REAL *retNormal)
void	inBPMEval (bezierPatchMesh *bpm)
void	inBPMListEval (bezierPatchMesh *list)
void	inMap2fEM (int which, int dimension, REAL ulower, REAL uupper, int ustride, int uorder, REAL vlower, REAL vupper, int vstride, int vorder, REAL *ctlPoints)
void	inDoDomain2WithDerivsEM (surfEvalMachine *em, REAL u, REAL v, REAL *retPoint, REAL *retdu, REAL *retdv)
void	inDoDomain2EM (surfEvalMachine *em, REAL u, REAL v, REAL *retPoint)
void	inDoEvalCoord2EM (REAL u, REAL v)
void	inBPMEvalEM (bezierPatchMesh *bpm)
void	inBPMListEvalEM (bezierPatchMesh *list)

Private Attributes
StoredVertex *	vertexCache [VERTEX_CACHE_SIZE]
int	tmeshing
int	which
int	vcount
GLint	gl_polygon_mode [2]
bezierPatchMesh *	global_bpm
int	output_triangles
void *	data
void *	userData
int	LOD_eval_level
int	global_uorder
int	global_vorder
REAL	global_uprime
REAL	global_vprime
REAL	global_vprime_BV
REAL	global_uprime_BU
int	global_uorder_BV
int	global_vorder_BV
int	global_uorder_BU
int	global_vorder_BU
REAL	global_ucoeff [IN_MAX_BEZIER_ORDER]
REAL	global_vcoeff [IN_MAX_BEZIER_ORDER]
REAL	global_ucoeffDeriv [IN_MAX_BEZIER_ORDER]
REAL	global_vcoeffDeriv [IN_MAX_BEZIER_ORDER]
REAL	global_BV [IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
REAL	global_PBV [IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
REAL	global_BU [IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
REAL	global_PBU [IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
REAL *	global_baseData
int	global_ev_k
REAL	global_ev_u1
REAL	global_ev_u2
int	global_ev_ustride
int	global_ev_uorder
REAL	global_ev_v1
REAL	global_ev_v2
int	global_ev_vstride
int	global_ev_vorder
REAL	global_ev_ctlPoints [IN_MAX_BEZIER_ORDER *IN_MAX_BEZIER_ORDER *IN_MAX_DIMENSION]
REAL	global_grid_u0
REAL	global_grid_u1
int	global_grid_nu
REAL	global_grid_v0
REAL	global_grid_v1
int	global_grid_nv
surfEvalMachine	em_vertex
surfEvalMachine	em_normal
surfEvalMachine	em_color
surfEvalMachine	em_texcoord
int	auto_normal_flag
int	callback_auto_normal
int	vertex_flag
int	normal_flag
int	color_flag
int	texcoord_flag

Additional Inherited Members
Public Types inherited from CachingEvaluator
enum	ServiceMode { play, record, playAndRecord }

Detailed Description

Definition at line 100 of file glsurfeval.h.

Constructor & Destructor Documentation

OpenGLSurfaceEvaluator()

OpenGLSurfaceEvaluator::OpenGLSurfaceEvaluator

(

)

Definition at line 99 of file glsurfeval.cc.

{
    int i;

    for (i=0; i<VERTEX_CACHE_SIZE; i++) {
    vertexCache[i] = new StoredVertex;
    }
    tmeshing = 0;
    which = 0;
    vcount = 0;

    global_uorder = 0;
    global_vorder = 0;
    global_uprime = -1.0;
    global_vprime = -1.0;
    global_vprime_BV = -1.0;
    global_uprime_BU = -1.0;
    global_uorder_BU = 0;
    global_vorder_BU = 0;
    global_uorder_BV = 0;
    global_vorder_BV = 0;
    global_baseData = NULL;
        
    global_bpm = NULL;
    output_triangles = 0; //don't output triangles by default

    //no default callback functions
    beginCallBackN = NULL;
    endCallBackN = NULL;
    vertexCallBackN = NULL;
    normalCallBackN = NULL;
    colorCallBackN = NULL;
    texcoordCallBackN = NULL;
    beginCallBackData = NULL;
    endCallBackData = NULL;
    vertexCallBackData = NULL;
    normalCallBackData = NULL;
    colorCallBackData = NULL;
    texcoordCallBackData = NULL;

    userData = NULL;

    auto_normal_flag = 0;
    callback_auto_normal = 0; //default of GLU_CALLBACK_AUTO_NORMAL is 0
    vertex_flag = 0;
    normal_flag = 0;
    color_flag = 0;
    texcoord_flag = 0;

    em_vertex.uprime = -1.0;
    em_vertex.vprime = -1.0;
    em_normal.uprime = -1.0;
    em_normal.vprime = -1.0;
    em_color.uprime = -1.0;
    em_color.vprime = -1.0;
    em_texcoord.uprime = -1.0;
    em_texcoord.vprime = -1.0;

#ifdef USE_LOD
    LOD_eval_level = 1;
#endif
}

~OpenGLSurfaceEvaluator()

OpenGLSurfaceEvaluator::~OpenGLSurfaceEvaluator ( void  )

virtual

Definition at line 162 of file glsurfeval.cc.

{
   for (int ii= 0; ii< VERTEX_CACHE_SIZE; ii++) {
      delete vertexCache[ii];
      vertexCache[ii]= 0;
   }
}

Member Function Documentation

addMap()

void OpenGLSurfaceEvaluator::addMap ( SurfaceMap *  )

inline

Definition at line 107 of file glsurfeval.h.

{ }

beginCallBack()

void OpenGLSurfaceEvaluator::beginCallBack ( GLenum  type, void *  data  )

private

Definition at line 1237 of file glsurfeval.cc.

{
  if(beginCallBackData)
    beginCallBackData(which, data);
  else if(beginCallBackN)
    beginCallBackN(which);
}

Referenced by inBPMEval(), and inBPMEvalEM().

bgnclosedline()

void OpenGLSurfaceEvaluator::bgnclosedline ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 268 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshBeginStrip(global_bpm, GL_LINE_LOOP);
  else
    glBegin((GLenum) GL_LINE_LOOP);
}

bgnline()

void OpenGLSurfaceEvaluator::bgnline ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 240 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshBeginStrip(global_bpm, GL_LINE_STRIP);
  else
    glBegin((GLenum) GL_LINE_STRIP);
}

bgnmap2f()

void OpenGLSurfaceEvaluator::bgnmap2f ( long  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 739 of file glsurfeval.cc.

{
  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;
    */
      glPushAttrib((GLbitfield) GL_EVAL_BIT);

    }
  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);
    }

}

bgnqstrip()

void OpenGLSurfaceEvaluator::bgnqstrip ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 712 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshBeginStrip(global_bpm, GL_QUAD_STRIP);
  else
    glBegin((GLenum) GL_QUAD_STRIP);

#ifdef STATISTICS
    STAT_num_of_quad_strips++;
#endif
}

Referenced by inEvalMesh2(), and mapmesh2f().

bgntfan()

void OpenGLSurfaceEvaluator::bgntfan ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 324 of file glsurfeval.cc.

{

  if(output_triangles)
    bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLE_FAN);
  else
    glBegin((GLenum) GL_TRIANGLE_FAN);

}

Referenced by evalUStrip(), evalVStrip(), inEvalUStrip(), and inEvalVStrip().

bgntmesh()

void OpenGLSurfaceEvaluator::bgntmesh ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 290 of file glsurfeval.cc.

{

    tmeshing = 1;
    which = 0;
    vcount = 0;

    if(output_triangles)
      bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLES);
    else
      glBegin((GLenum) GL_TRIANGLES);

}

colorCallBack()

void OpenGLSurfaceEvaluator::colorCallBack ( const GLfloat *  color, void *  data  )

private

Definition at line 1274 of file glsurfeval.cc.

{
  if(colorCallBackData)
    colorCallBackData(color, data);
  else if(colorCallBackN)
    colorCallBackN(color);
}

Referenced by inDoEvalCoord2EM().

coord2f()

void OpenGLSurfaceEvaluator::coord2f	(	REAL	u,
		REAL	v
	)

Definition at line 1106 of file glsurfeval.cc.

{
#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
}

Referenced by evalUStrip(), evalVStrip(), StoredVertex::invoke(), mapmesh2f(), newtmeshvert(), and point2i().

disable()

void OpenGLSurfaceEvaluator::disable ( long  type )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 175 of file glsurfeval.cc.

{
    glDisable((GLenum) type);
}

domain2f()

void OpenGLSurfaceEvaluator::domain2f ( REAL  ulo, REAL  uhi, REAL  vlo, REAL  vhi  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 263 of file glsurfeval.cc.

{
}

enable()

void OpenGLSurfaceEvaluator::enable ( long  type )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 185 of file glsurfeval.cc.

{
    glEnable((GLenum) type);
}

endCallBack()

void OpenGLSurfaceEvaluator::endCallBack ( void *  data )

private

Definition at line 1246 of file glsurfeval.cc.

{
  if(endCallBackData)
    endCallBackData(data);
  else if(endCallBackN)
    endCallBackN();
}

Referenced by inBPMEval(), and inBPMEvalEM().

endclosedline()

void OpenGLSurfaceEvaluator::endclosedline ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 277 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshEndStrip(global_bpm);
  else
    glEnd();
}

endline()

void OpenGLSurfaceEvaluator::endline ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 249 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshEndStrip(global_bpm);
  else
    glEnd();
}

endmap2f()

void OpenGLSurfaceEvaluator::endmap2f ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 801 of file glsurfeval.cc.

{

  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
    glPopAttrib();
  }
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
}

}

endqstrip()

void OpenGLSurfaceEvaluator::endqstrip ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 725 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshEndStrip(global_bpm);
  else
    glEnd();

}

Referenced by inEvalMesh2(), and mapmesh2f().

endtfan()

void OpenGLSurfaceEvaluator::endtfan ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 334 of file glsurfeval.cc.

{
  if(output_triangles)
    bezierPatchMeshEndStrip(global_bpm);
  else
    glEnd();
}

Referenced by evalUStrip(), evalVStrip(), inEvalUStrip(), and inEvalVStrip().

endtmesh()

void OpenGLSurfaceEvaluator::endtmesh ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 312 of file glsurfeval.cc.

{
    tmeshing = 0;


    if(output_triangles)
      bezierPatchMeshEndStrip(global_bpm);
    else
      glEnd();
}

evalcoord2f()

void OpenGLSurfaceEvaluator::evalcoord2f ( long  , REAL  u, REAL  v  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 1042 of file glsurfeval.cc.

{


#ifdef NO_EVALUATION
return;
#endif


    newtmeshvert(u, v);
}

evalpoint2i()

void OpenGLSurfaceEvaluator::evalpoint2i ( long  u, long  v  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 1059 of file glsurfeval.cc.

{
#ifdef NO_EVALUATION
return;
#endif

    newtmeshvert(u, v);
}

evalUStrip()

void OpenGLSurfaceEvaluator::evalUStrip ( int  n_upper, REAL  v_upper, REAL *  upper_val, int  n_lower, REAL  v_lower, REAL *  lower_val  )

virtual

Implements BasicSurfaceEvaluator.

Definition at line 343 of file glsurfeval.cc.

{
#ifdef USE_INTERNAL_EVAL
  inEvalUStrip(n_upper, v_upper, upper_val,
    n_lower, v_lower, lower_val);
#else

#ifdef FOR_CHRIS
  evalUStripExt(n_upper, v_upper, upper_val,
         n_lower, v_lower, lower_val);
  return;

#endif
  int i,j,k,l;
  REAL leftMostV[2];

  /*
   *the algorithm works by scanning from left to right.
   *leftMostV: the left most of the remaining verteces (on both upper and lower).
   *           it could an element of upperVerts or lowerVerts.
   *i: upperVerts[i] is the first vertex to the right of leftMostV on upper line
   *j: lowerVerts[j] is the first vertex to the right of leftMostV on lower line
   */

  /*initialize i,j,and leftMostV
   */
  if(upper_val[0] <= lower_val[0])
    {
      i=1;
      j=0;

      leftMostV[0] = upper_val[0];
      leftMostV[1] = v_upper;
    }
  else
    {
      i=0;
      j=1;

      leftMostV[0] = lower_val[0];
      leftMostV[1] = v_lower;

    }

  /*the main loop.
   *the invariance is that:
   *at the beginning of each loop, the meaning of i,j,and leftMostV are
   *maintained
   */
  while(1)
    {
      if(i >= n_upper) /*case1: no more in upper*/
    {
      if(j<n_lower-1) /*at least two vertices in lower*/
        {
          bgntfan();
          coord2f(leftMostV[0], leftMostV[1]);
//        glNormal3fv(leftMostNormal);
//      glVertex3fv(leftMostXYZ);

          while(j<n_lower){
        coord2f(lower_val[j], v_lower);
//      glNormal3fv(lowerNormal[j]);
//      glVertex3fv(lowerXYZ[j]);
        j++;

          }
          endtfan();
        }
      break; /*exit the main loop*/
    }
      else if(j>= n_lower) /*case2: no more in lower*/
    {
      if(i<n_upper-1) /*at least two vertices in upper*/
        {
          bgntfan();
          coord2f(leftMostV[0], leftMostV[1]);
//        glNormal3fv(leftMostNormal);
//        glVertex3fv(leftMostXYZ);
        
          for(k=n_upper-1; k>=i; k--) /*reverse order for two-side lighting*/
        {
          coord2f(upper_val[k], v_upper);
//        glNormal3fv(upperNormal[k]);
//        glVertex3fv(upperXYZ[k]);
        }

          endtfan();
        }
      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

}

evalVStrip()

void OpenGLSurfaceEvaluator::evalVStrip ( int  n_left, REAL  u_left, REAL *  left_val, int  n_right, REAL  u_right, REAL *  right_val  )

virtual

Implements BasicSurfaceEvaluator.

Definition at line 530 of file glsurfeval.cc.

{
#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
}

get_callback_auto_normal()

int OpenGLSurfaceEvaluator::get_callback_auto_normal ( )

inline

Definition at line 163 of file glsurfeval.h.

     {
        return callback_auto_normal;
      }

Referenced by GLUnurbs::get_callback_auto_normal().

get_vertices_call_back()

int OpenGLSurfaceEvaluator::get_vertices_call_back ( )

inline

Definition at line 149 of file glsurfeval.h.

      {
    return output_triangles;
      }

Referenced by GLUnurbs::get_vertices_call_back().

inBPMEval()

void OpenGLSurfaceEvaluator::inBPMEval ( bezierPatchMesh *  bpm )

private

Definition at line 247 of file insurfeval.cc.

{
  int i,j,k,l;
  float u,v;

  int ustride = bpm->bpatch->dimension * bpm->bpatch->vorder;
  int vstride = bpm->bpatch->dimension;
  inMap2f( 
      (bpm->bpatch->dimension == 3)? GL_MAP2_VERTEX_3 : GL_MAP2_VERTEX_4,
      bpm->bpatch->umin,
      bpm->bpatch->umax,
      ustride,
      bpm->bpatch->uorder,
      bpm->bpatch->vmin,
      bpm->bpatch->vmax,
      vstride,
      bpm->bpatch->vorder,
      bpm->bpatch->ctlpoints);
  
  bpm->vertex_array = (float*) malloc(sizeof(float)* (bpm->index_UVarray/2) * 3+1); /*in case the origional dimenion is 4, then we need 4 space to pass to evaluator.*/
  assert(bpm->vertex_array);
  bpm->normal_array = (float*) malloc(sizeof(float)* (bpm->index_UVarray/2) * 3);
  assert(bpm->normal_array);
#ifdef CRACK_TEST
if(  global_ev_u1 ==2 &&   global_ev_u2 == 3
  && global_ev_v1 ==2 &&   global_ev_v2 == 3)
{
REAL vertex[4];
REAL normal[4];
#ifdef DEBUG
printf("***number 1\n");
#endif

beginCallBack(GL_QUAD_STRIP, NULL);
inEvalCoord2f(3.0, 3.0);
inEvalCoord2f(2.0, 3.0);
inEvalCoord2f(3.0, 2.7);
inEvalCoord2f(2.0, 2.7);
inEvalCoord2f(3.0, 2.0);
inEvalCoord2f(2.0, 2.0);
endCallBack(NULL);


beginCallBack(GL_TRIANGLE_STRIP, NULL);
inEvalCoord2f(2.0, 3.0);
inEvalCoord2f(2.0, 2.0);
inEvalCoord2f(2.0, 2.7);
endCallBack(NULL);

}

/*
if(  global_ev_u1 ==2 &&   global_ev_u2 == 3
  && global_ev_v1 ==1 &&   global_ev_v2 == 2)
{
#ifdef DEBUG
printf("***number 2\n");
#endif
beginCallBack(GL_QUAD_STRIP);
inEvalCoord2f(2.0, 2.0);
inEvalCoord2f(2.0, 1.0);
inEvalCoord2f(3.0, 2.0);
inEvalCoord2f(3.0, 1.0);
endCallBack();
}
*/
if(  global_ev_u1 ==1 &&   global_ev_u2 == 2
  && global_ev_v1 ==2 &&   global_ev_v2 == 3)
{
#ifdef DEBUG
printf("***number 3\n");
#endif
beginCallBack(GL_QUAD_STRIP, NULL);
inEvalCoord2f(2.0, 3.0);
inEvalCoord2f(1.0, 3.0);
inEvalCoord2f(2.0, 2.3);
inEvalCoord2f(1.0, 2.3);
inEvalCoord2f(2.0, 2.0);
inEvalCoord2f(1.0, 2.0);
endCallBack(NULL);

beginCallBack(GL_TRIANGLE_STRIP, NULL);
inEvalCoord2f(2.0, 2.3);
inEvalCoord2f(2.0, 2.0);
inEvalCoord2f(2.0, 3.0);
endCallBack(NULL);

}
return;
#endif

  k=0;
  l=0;

  for(i=0; i<bpm->index_length_array; i++)
    {
      beginCallBack(bpm->type_array[i], userData);
      for(j=0; j<bpm->length_array[i]; j++)
    {
      u = bpm->UVarray[k];
      v = bpm->UVarray[k+1];
      inDoEvalCoord2NOGE(u,v,
                 bpm->vertex_array+l,
                 bpm->normal_array+l);

      normalCallBack(bpm->normal_array+l, userData);
      vertexCallBack(bpm->vertex_array+l, userData);

      k += 2;
      l += 3;
    }
      endCallBack(userData);
    }
}

Referenced by inBPMListEval().

inBPMEvalEM()

void OpenGLSurfaceEvaluator::inBPMEvalEM ( bezierPatchMesh *  bpm )

private

Definition at line 1826 of file insurfeval.cc.

{
  int i,j,k;
  float u,v;

  int ustride;
  int vstride;

#ifdef USE_LOD
  if(bpm->bpatch != NULL)
    {
      bezierPatch* p=bpm->bpatch;
      ustride = p->dimension * p->vorder;
      vstride = p->dimension;

      glMap2f( (p->dimension == 3)? GL_MAP2_VERTEX_3 : GL_MAP2_VERTEX_4,
          p->umin,
          p->umax,
          ustride,
          p->uorder,
          p->vmin,
          p->vmax,
          vstride,
          p->vorder,
          p->ctlpoints);


/*
    inMap2fEM(0, p->dimension,
      p->umin,
      p->umax,
      ustride,
      p->uorder,
      p->vmin,
      p->vmax,
      vstride,
      p->vorder,
      p->ctlpoints);
*/
    }
#else

  if(bpm->bpatch != NULL){
    bezierPatch* p = bpm->bpatch;
    ustride = p->dimension * p->vorder;
    vstride = p->dimension;
    inMap2fEM(0, p->dimension,
      p->umin,
      p->umax,
      ustride,
      p->uorder,
      p->vmin,
      p->vmax,
      vstride,
      p->vorder,
      p->ctlpoints);
  }
  if(bpm->bpatch_normal != NULL){
    bezierPatch* p = bpm->bpatch_normal;
    ustride = p->dimension * p->vorder;
    vstride = p->dimension;
    inMap2fEM(1, p->dimension,
      p->umin,
      p->umax,
      ustride,
      p->uorder,
      p->vmin,
      p->vmax,
      vstride,
      p->vorder,
      p->ctlpoints);
  }
  if(bpm->bpatch_color != NULL){
    bezierPatch* p = bpm->bpatch_color;
    ustride = p->dimension * p->vorder;
    vstride = p->dimension;
    inMap2fEM(2, p->dimension,
      p->umin,
      p->umax,
      ustride,
      p->uorder,
      p->vmin,
      p->vmax,
      vstride,
      p->vorder,
      p->ctlpoints);
  }
  if(bpm->bpatch_texcoord != NULL){
    bezierPatch* p = bpm->bpatch_texcoord;
    ustride = p->dimension * p->vorder;
    vstride = p->dimension;
    inMap2fEM(3, p->dimension,
      p->umin,
      p->umax,
      ustride,
      p->uorder,
      p->vmin,
      p->vmax,
      vstride,
      p->vorder,
      p->ctlpoints);
  }
#endif


  k=0;
  for(i=0; i<bpm->index_length_array; i++)
    {
#ifdef USE_LOD
      if(bpm->type_array[i] == GL_POLYGON) //a mesh
    {
      GLfloat *temp = bpm->UVarray+k;
      GLfloat u0 = temp[0];
      GLfloat v0 = temp[1];
      GLfloat u1 = temp[2];
      GLfloat v1 = temp[3];
      GLint nu = (GLint) ( temp[4]);
      GLint nv = (GLint) ( temp[5]);
      GLint umin = (GLint) ( temp[6]);
      GLint vmin = (GLint) ( temp[7]);
      GLint umax = (GLint) ( temp[8]);
      GLint vmax = (GLint) ( temp[9]);

      glMapGrid2f(LOD_eval_level*nu, u0, u1, LOD_eval_level*nv, v0, v1);
      glEvalMesh2(GL_FILL, LOD_eval_level*umin, LOD_eval_level*umax, LOD_eval_level*vmin, LOD_eval_level*vmax);
    }
      else
    {
      LOD_eval(bpm->length_array[i], bpm->UVarray+k, bpm->type_array[i],
           0
           );
    }
      k+= 2*bpm->length_array[i];       
    
#else //undef  USE_LOD

#ifdef CRACK_TEST
if(  bpm->bpatch->umin == 2 &&   bpm->bpatch->umax == 3
  && bpm->bpatch->vmin ==2 &&    bpm->bpatch->vmax == 3)
{
REAL vertex[4];
REAL normal[4];
#ifdef DEBUG
printf("***number ****1\n");
#endif

beginCallBack(GL_QUAD_STRIP, NULL);
inDoEvalCoord2EM(3.0, 3.0);
inDoEvalCoord2EM(2.0, 3.0);
inDoEvalCoord2EM(3.0, 2.7);
inDoEvalCoord2EM(2.0, 2.7);
inDoEvalCoord2EM(3.0, 2.0);
inDoEvalCoord2EM(2.0, 2.0);
endCallBack(NULL);

beginCallBack(GL_TRIANGLE_STRIP, NULL);
inDoEvalCoord2EM(2.0, 3.0);
inDoEvalCoord2EM(2.0, 2.0);
inDoEvalCoord2EM(2.0, 2.7);
endCallBack(NULL);

}
if(  bpm->bpatch->umin == 1 &&   bpm->bpatch->umax == 2
  && bpm->bpatch->vmin ==2 &&    bpm->bpatch->vmax == 3)
{
#ifdef DEBUG
printf("***number 3\n");
#endif
beginCallBack(GL_QUAD_STRIP, NULL);
inDoEvalCoord2EM(2.0, 3.0);
inDoEvalCoord2EM(1.0, 3.0);
inDoEvalCoord2EM(2.0, 2.3);
inDoEvalCoord2EM(1.0, 2.3);
inDoEvalCoord2EM(2.0, 2.0);
inDoEvalCoord2EM(1.0, 2.0);
endCallBack(NULL);

beginCallBack(GL_TRIANGLE_STRIP, NULL);
inDoEvalCoord2EM(2.0, 2.3);
inDoEvalCoord2EM(2.0, 2.0);
inDoEvalCoord2EM(2.0, 3.0);
endCallBack(NULL);

}
return;
#endif //CRACK_TEST

      beginCallBack(bpm->type_array[i], userData);

      for(j=0; j<bpm->length_array[i]; j++)
    {
      u = bpm->UVarray[k];
      v = bpm->UVarray[k+1];
#ifdef USE_LOD
          LOD_EVAL_COORD(u,v);
//    glEvalCoord2f(u,v);
#else

#ifdef  GENERIC_TEST
          float temp_normal[3];
          float temp_vertex[3];
          if(temp_signal == 0)
        {
          gTessVertexSphere(u,v, temp_normal, temp_vertex);
//printf("normal=(%f,%f,%f)\n", temp_normal[0], temp_normal[1], temp_normal[2])//printf("veretx=(%f,%f,%f)\n", temp_vertex[0], temp_vertex[1], temp_vertex[2]);
              normalCallBack(temp_normal, userData);
          vertexCallBack(temp_vertex, userData);
        }
          else if(temp_signal == 1)
        {
          gTessVertexCyl(u,v, temp_normal, temp_vertex);
//printf("normal=(%f,%f,%f)\n", temp_normal[0], temp_normal[1], temp_normal[2])//printf("veretx=(%f,%f,%f)\n", temp_vertex[0], temp_vertex[1], temp_vertex[2]);
              normalCallBack(temp_normal, userData);
          vertexCallBack(temp_vertex, userData);
        }
      else
#endif //GENERIC_TEST

        inDoEvalCoord2EM(u,v);
     
#endif //USE_LOD

      k += 2;
    }
      endCallBack(userData);

#endif //USE_LOD
    }
}

Referenced by inBPMListEvalEM().

inBPMListEval()

void OpenGLSurfaceEvaluator::inBPMListEval ( bezierPatchMesh *  list )

private

Definition at line 238 of file insurfeval.cc.

{
  bezierPatchMesh* temp;
  for(temp = list; temp != NULL; temp = temp->next)
    {
      inBPMEval(temp);
    }
}

inBPMListEvalEM()

void OpenGLSurfaceEvaluator::inBPMListEvalEM ( bezierPatchMesh *  list )

private

Definition at line 2056 of file insurfeval.cc.

{
  bezierPatchMesh* temp;
  for(temp = list; temp != NULL; temp = temp->next)
    {
      inBPMEvalEM(temp);
    }
}

Referenced by endmap2f(), and LOD_eval_list().

inComputeFirstPartials()

void OpenGLSurfaceEvaluator::inComputeFirstPartials ( REAL *  p, REAL *  pu, REAL *  pv  )

private

Definition at line 501 of file insurfeval.cc.

{
    pu[0] = pu[0]*p[3] - pu[3]*p[0];
    pu[1] = pu[1]*p[3] - pu[3]*p[1];
    pu[2] = pu[2]*p[3] - pu[3]*p[2];

    pv[0] = pv[0]*p[3] - pv[3]*p[0];
    pv[1] = pv[1]*p[3] - pv[3]*p[1];
    pv[2] = pv[2]*p[3] - pv[3]*p[2];
}

Referenced by inDoEvalCoord2(), inDoEvalCoord2EM(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), and inDoEvalCoord2NOGE_BV().

inComputeNormal2()

void OpenGLSurfaceEvaluator::inComputeNormal2 ( REAL *  pu, REAL *  pv, REAL *  n  )

private

Definition at line 518 of file insurfeval.cc.

{
  REAL mag; 

  n[0] = pu[1]*pv[2] - pu[2]*pv[1];
  n[1] = pu[2]*pv[0] - pu[0]*pv[2];
  n[2] = pu[0]*pv[1] - pu[1]*pv[0];  

  mag = sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]);

  if (mag > 0.0) {
     n[0] /= mag; 
     n[1] /= mag;
     n[2] /= mag;
  }
}

Referenced by inDoEvalCoord2(), inDoEvalCoord2EM(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), and inDoEvalCoord2NOGE_BV().

inDoDomain2EM()

void OpenGLSurfaceEvaluator::inDoDomain2EM ( surfEvalMachine *  em, REAL  u, REAL  v, REAL *  retPoint  )

private

Definition at line 1653 of file insurfeval.cc.

{
    int j, row, col;
    REAL the_uprime;
    REAL the_vprime;
    REAL p;
    REAL *data;

    if((em->u2 == em->u1) || (em->v2 == em->v1))
    return;
    the_uprime = (u - em->u1) / (em->u2 - em->u1);
    the_vprime = (v - em->v1) / (em->v2 - em->v1);
    
    /* Compute coefficients for values and derivs */

    /* Use already cached values if possible */
    if(em->uprime != the_uprime) {
        inPreEvaluate(em->uorder, the_uprime, em->ucoeff);
    em->uprime = the_uprime;
    }
    if (em->vprime != the_vprime) {
    inPreEvaluate(em->vorder, the_vprime, em->vcoeff);
    em->vprime = the_vprime;
    }

    for (j = 0; j < em->k; j++) {
    data=em->ctlPoints+j;
    retPoint[j] = 0.0;
    for (row = 0; row < em->uorder; row++)  {
        /* 
        ** Minor optimization.
        ** The col == 0 part of the loop is extracted so we don't
        ** have to initialize p and pdv to 0.
        */
        p = em->vcoeff[0] * (*data);
        data += em->k;
        for (col = 1; col < em->vorder; col++) {
        /* Incrementally build up p, pdv value */
        p += em->vcoeff[col] * (*data);
        data += em->k;
        }
        /* Use p, pdv value to incrementally add up r, du, dv */
        retPoint[j] += em->ucoeff[row] * p;
    }
    }  
}  

Referenced by inDoEvalCoord2EM().

inDoDomain2WithDerivs()

void OpenGLSurfaceEvaluator::inDoDomain2WithDerivs ( int  k, REAL  u, REAL  v, REAL  u1, REAL  u2, int  uorder, REAL  v1, REAL  v2, int  vorder, REAL *  baseData, REAL *  retPoint, REAL *  retdu, REAL *  retdv  )

private

Definition at line 949 of file insurfeval.cc.

{
    int j, row, col;
    REAL uprime;
    REAL vprime;
    REAL p;
    REAL pdv;
    REAL *data;

    if((u2 == u1) || (v2 == v1))
    return;
    uprime = (u - u1) / (u2 - u1);
    vprime = (v - v1) / (v2 - v1);
    
    /* Compute coefficients for values and derivs */

    /* Use already cached values if possible */
    if(global_uprime != uprime || global_uorder != uorder) {
        inPreEvaluateWithDeriv(uorder, uprime, global_ucoeff, global_ucoeffDeriv);
    global_uorder = uorder;
    global_uprime = uprime;
    }
    if (global_vprime != vprime || 
      global_vorder != vorder) {
    inPreEvaluateWithDeriv(vorder, vprime, global_vcoeff, global_vcoeffDeriv);
    global_vorder = vorder;
    global_vprime = vprime;
    }

    for (j = 0; j < k; j++) {
    data=baseData+j;
    retPoint[j] = retdu[j] = retdv[j] = 0.0;
    for (row = 0; row < uorder; row++)  {
        /* 
        ** Minor optimization.
        ** The col == 0 part of the loop is extracted so we don't
        ** have to initialize p and pdv to 0.
        */
        p = global_vcoeff[0] * (*data);
        pdv = global_vcoeffDeriv[0] * (*data);
        data += k;
        for (col = 1; col < vorder; col++) {
        /* Incrementally build up p, pdv value */
        p += global_vcoeff[col] * (*data);
        pdv += global_vcoeffDeriv[col] * (*data);
        data += k;
        }
        /* Use p, pdv value to incrementally add up r, du, dv */
        retPoint[j] += global_ucoeff[row] * p;
        retdu[j] += global_ucoeffDeriv[row] * p;
        retdv[j] += global_ucoeff[row] * pdv;
    }
    }  
}

Referenced by inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), and inDoEvalCoord2NOGE_BV().

inDoDomain2WithDerivsBU()

void OpenGLSurfaceEvaluator::inDoDomain2WithDerivsBU ( int  k, REAL  u, REAL  v, REAL  u1, REAL  u2, int  uorder, REAL  v1, REAL  v2, int  vorder, REAL *  baseData, REAL *  retPoint, REAL *  retdu, REAL *  retdv  )

private

Definition at line 868 of file insurfeval.cc.

{
  int j, col;

  REAL vprime;


  if((u2 == u1) || (v2 == v1))
    return;

  vprime = (v - v1) / (v2 - v1);


  if(global_vprime != vprime || global_vorder != vorder) {
    inPreEvaluateWithDeriv(vorder, vprime, global_vcoeff, global_vcoeffDeriv);
    global_vprime = vprime;
    global_vorder = vorder;
  }


  for(j=0; j<k; j++)
    {
      retPoint[j] = retdu[j] = retdv[j] = 0.0;
      for (col = 0; col < vorder; col++)  {
    retPoint[j] += global_BU[col][j] * global_vcoeff[col];
    retdu[j] += global_PBU[col][j] * global_vcoeff[col];
    retdv[j] += global_BU[col][j] * global_vcoeffDeriv[col];
      }
    }
}    

Referenced by inDoEvalCoord2NOGE_BU().

inDoDomain2WithDerivsBV()

void OpenGLSurfaceEvaluator::inDoDomain2WithDerivsBV ( int  k, REAL  u, REAL  v, REAL  u1, REAL  u2, int  uorder, REAL  v1, REAL  v2, int  vorder, REAL *  baseData, REAL *  retPoint, REAL *  retdu, REAL *  retdv  )

private

Definition at line 903 of file insurfeval.cc.

{
  int j, row;
  REAL uprime;


  if((u2 == u1) || (v2 == v1))
    return;
  uprime = (u - u1) / (u2 - u1);


  if(global_uprime != uprime || global_uorder != uorder) {
    inPreEvaluateWithDeriv(uorder, uprime, global_ucoeff, global_ucoeffDeriv);
    global_uprime = uprime;
    global_uorder = uorder;
  }


  for(j=0; j<k; j++)
    {
      retPoint[j] = retdu[j] = retdv[j] = 0.0;
      for (row = 0; row < uorder; row++)  {
    retPoint[j] += global_BV[row][j] * global_ucoeff[row];
    retdu[j] += global_BV[row][j] * global_ucoeffDeriv[row];
    retdv[j] += global_PBV[row][j] * global_ucoeff[row];
      }
    }
}

Referenced by inDoEvalCoord2NOGE_BV().

inDoDomain2WithDerivsEM()

void OpenGLSurfaceEvaluator::inDoDomain2WithDerivsEM ( surfEvalMachine *  em, REAL  u, REAL  v, REAL *  retPoint, REAL *  retdu, REAL *  retdv  )

private

Definition at line 1600 of file insurfeval.cc.

{
    int j, row, col;
    REAL the_uprime;
    REAL the_vprime;
    REAL p;
    REAL pdv;
    REAL *data;

    if((em->u2 == em->u1) || (em->v2 == em->v1))
    return;
    the_uprime = (u - em->u1) / (em->u2 - em->u1);
    the_vprime = (v - em->v1) / (em->v2 - em->v1);
    
    /* Compute coefficients for values and derivs */

    /* Use already cached values if possible */
    if(em->uprime != the_uprime) {
        inPreEvaluateWithDeriv(em->uorder, the_uprime, em->ucoeff, em->ucoeffDeriv);
    em->uprime = the_uprime;
    }
    if (em->vprime != the_vprime) {
    inPreEvaluateWithDeriv(em->vorder, the_vprime, em->vcoeff, em->vcoeffDeriv);
    em->vprime = the_vprime;
    }

    for (j = 0; j < em->k; j++) {
    data=em->ctlPoints+j;
    retPoint[j] = retdu[j] = retdv[j] = 0.0;
    for (row = 0; row < em->uorder; row++)  {
        /* 
        ** Minor optimization.
        ** The col == 0 part of the loop is extracted so we don't
        ** have to initialize p and pdv to 0.
        */
        p = em->vcoeff[0] * (*data);
        pdv = em->vcoeffDeriv[0] * (*data);
        data += em->k;
        for (col = 1; col < em->vorder; col++) {
        /* Incrementally build up p, pdv value */
        p += em->vcoeff[col] * (*data);
        pdv += em->vcoeffDeriv[col] * (*data);
        data += em->k;
        }
        /* Use p, pdv value to incrementally add up r, du, dv */
        retPoint[j] += em->ucoeff[row] * p;
        retdu[j] += em->ucoeffDeriv[row] * p;
        retdv[j] += em->ucoeff[row] * pdv;
    }
    }  
}  

Referenced by inDoEvalCoord2EM().

inDoEvalCoord2()

void OpenGLSurfaceEvaluator::inDoEvalCoord2 ( REAL  u, REAL  v, REAL *  retPoint, REAL *  retNormal  )

private

Definition at line 541 of file insurfeval.cc.

{

  REAL du[4];
  REAL dv[4];

 
  assert(global_ev_k>=3 && global_ev_k <= 4);
  /*compute homegeneous point and partial derivatives*/
  inDoDomain2WithDerivs(global_ev_k, u, v, global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, retPoint, du, dv);

#ifdef AVOID_ZERO_NORMAL

  if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
    {

      REAL tempdu[4];
      REAL tempdata[4];
      REAL u1 = global_ev_u1;
      REAL u2 = global_ev_u2;
      if(u-MYDELTA*(u2-u1) < u1)
    u = u+ MYDELTA*(u2-u1);
      else
    u = u-MYDELTA*(u2-u1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, tempdu, dv);
    }
  if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
    {
      REAL tempdv[4];
      REAL tempdata[4];
      REAL v1 = global_ev_v1;
      REAL v2 = global_ev_v2;
      if(v-MYDELTA*(v2-v1) < v1)
    v = v+ MYDELTA*(v2-v1);
      else
    v = v-MYDELTA*(v2-v1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, du, tempdv);
    }
#endif


  /*compute normal*/
  switch(global_ev_k){
  case 3:
    inComputeNormal2(du, dv, retNormal);

    break;
  case 4:
    inComputeFirstPartials(retPoint, du, dv);
    inComputeNormal2(du, dv, retNormal);
    /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
    retPoint[0] /= retPoint[3];
    retPoint[1] /= retPoint[3];
    retPoint[2] /= retPoint[3];
    break;
  }
  /*output this vertex*/
/*  inMeshStreamInsert(global_ms, retPoint, retNormal);*/



  glNormal3fv(retNormal);
  glVertex3fv(retPoint);




  #ifdef DEBUG
  printf("vertex(%f,%f,%f)\n", retPoint[0],retPoint[1],retPoint[2]);
  #endif
  


}

Referenced by inEvalCoord2f(), inEvalMesh2(), and inEvalPoint2().

inDoEvalCoord2EM()

void OpenGLSurfaceEvaluator::inDoEvalCoord2EM ( REAL  u, REAL  v  )

private

Definition at line 1702 of file insurfeval.cc.

{
  REAL temp_vertex[5];
  REAL temp_normal[3];
  REAL temp_color[4];
  REAL temp_texcoord[4];

  if(texcoord_flag)
    {
      inDoDomain2EM(&em_texcoord, u,v, temp_texcoord);
      texcoordCallBack(temp_texcoord, userData);
    }
  if(color_flag)
    {
      inDoDomain2EM(&em_color, u,v, temp_color);
      colorCallBack(temp_color, userData);
    }

  if(normal_flag) //there is a normla map
    {
      inDoDomain2EM(&em_normal, u,v, temp_normal);
      normalCallBack(temp_normal, userData);
    
      if(vertex_flag)
    {
      inDoDomain2EM(&em_vertex, u,v,temp_vertex);
      if(em_vertex.k == 4)
        {
          temp_vertex[0] /= temp_vertex[3];
          temp_vertex[1] /= temp_vertex[3];
          temp_vertex[2] /= temp_vertex[3];       
        }
          temp_vertex[3]=u;
          temp_vertex[4]=v;   
      vertexCallBack(temp_vertex, userData);
    }
    }
  else if(auto_normal_flag) //no normal map but there is a normal callbackfunctin
    {
      REAL du[4];
      REAL dv[4];
      
      /*compute homegeneous point and partial derivatives*/
      inDoDomain2WithDerivsEM(&em_vertex, u,v,temp_vertex,du,dv);

      if(em_vertex.k ==4)
    inComputeFirstPartials(temp_vertex, du, dv);

#ifdef AVOID_ZERO_NORMAL
      if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
    {
      
      REAL tempdu[4];
      REAL tempdata[4];
      REAL u1 = em_vertex.u1;
      REAL u2 = em_vertex.u2;
      if(u-MYDELTA*(u2-u1) < u1)
        u = u+ MYDELTA*(u2-u1);
      else
        u = u-MYDELTA*(u2-u1);
      inDoDomain2WithDerivsEM(&em_vertex,u,v, tempdata, tempdu, dv);

      if(em_vertex.k ==4)
        inComputeFirstPartials(temp_vertex, du, dv);      
    }
      else if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
    {
      REAL tempdv[4];
      REAL tempdata[4];
      REAL v1 = em_vertex.v1;
      REAL v2 = em_vertex.v2;
      if(v-MYDELTA*(v2-v1) < v1)
        v = v+ MYDELTA*(v2-v1);
      else
        v = v-MYDELTA*(v2-v1);
      inDoDomain2WithDerivsEM(&em_vertex,u,v, tempdata, du, tempdv);

      if(em_vertex.k ==4)
        inComputeFirstPartials(temp_vertex, du, dv);
    }
#endif

      /*compute normal*/
      switch(em_vertex.k){
      case 3:

    inComputeNormal2(du, dv, temp_normal);
    break;
      case 4:

//  inComputeFirstPartials(temp_vertex, du, dv);
    inComputeNormal2(du, dv, temp_normal);

    /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
    temp_vertex[0] /= temp_vertex[3];
    temp_vertex[1] /= temp_vertex[3];
    temp_vertex[2] /= temp_vertex[3];
    break;
      }
      normalCallBack(temp_normal, userData);
      temp_vertex[3] = u;
      temp_vertex[4] = v;
      vertexCallBack(temp_vertex, userData);
      
    }/*end if auto_normal*/
  else //no normal map, and no normal callback function
    {
      if(vertex_flag)
    {
      inDoDomain2EM(&em_vertex, u,v,temp_vertex);
      if(em_vertex.k == 4)
        {
          temp_vertex[0] /= temp_vertex[3];
          temp_vertex[1] /= temp_vertex[3];
          temp_vertex[2] /= temp_vertex[3];       
        }
          temp_vertex[3] = u;
          temp_vertex[4] = v;
      vertexCallBack(temp_vertex, userData);
    }
    }
}

Referenced by inBPMEvalEM().

inDoEvalCoord2NOGE()

void OpenGLSurfaceEvaluator::inDoEvalCoord2NOGE ( REAL  u, REAL  v, REAL *  retPoint, REAL *  retNormal  )

privatevirtual

Implements BasicSurfaceEvaluator.

Definition at line 749 of file insurfeval.cc.

{

  REAL du[4];
  REAL dv[4];

 
  assert(global_ev_k>=3 && global_ev_k <= 4);
  /*compute homegeneous point and partial derivatives*/
  inDoDomain2WithDerivs(global_ev_k, u, v, global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, retPoint, du, dv);


#ifdef AVOID_ZERO_NORMAL

  if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
    {

      REAL tempdu[4];
      REAL tempdata[4];
      REAL u1 = global_ev_u1;
      REAL u2 = global_ev_u2;
      if(u-MYDELTA*(u2-u1) < u1)
    u = u+ MYDELTA*(u2-u1);
      else
    u = u-MYDELTA*(u2-u1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, tempdu, dv);
    }
  if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
    {
      REAL tempdv[4];
      REAL tempdata[4];
      REAL v1 = global_ev_v1;
      REAL v2 = global_ev_v2;
      if(v-MYDELTA*(v2-v1) < v1)
    v = v+ MYDELTA*(v2-v1);
      else
    v = v-MYDELTA*(v2-v1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, du, tempdv);
    }
#endif

  /*compute normal*/
  switch(global_ev_k){
  case 3:
    inComputeNormal2(du, dv, retNormal);
    break;
  case 4:
    inComputeFirstPartials(retPoint, du, dv);
    inComputeNormal2(du, dv, retNormal);
    /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
    retPoint[0] /= retPoint[3];
    retPoint[1] /= retPoint[3];
    retPoint[2] /= retPoint[3];
    break;
  }
//  glNormal3fv(retNormal);
//  glVertex3fv(retPoint);
}

Referenced by inBPMEval().

inDoEvalCoord2NOGE_BU()

void OpenGLSurfaceEvaluator::inDoEvalCoord2NOGE_BU ( REAL  u, REAL  v, REAL *  retPoint, REAL *  retNormal  )

privatevirtual

Implements BasicSurfaceEvaluator.

Definition at line 621 of file insurfeval.cc.

{

  REAL du[4];
  REAL dv[4];

 
  assert(global_ev_k>=3 && global_ev_k <= 4);
  /*compute homegeneous point and partial derivatives*/
//   inPreEvaluateBU(global_ev_k, global_ev_uorder, global_ev_vorder, (u-global_ev_u1)/(global_ev_u2-global_ev_u1), global_ev_ctlPoints);
  inDoDomain2WithDerivsBU(global_ev_k, u, v, global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, retPoint, du, dv);


#ifdef AVOID_ZERO_NORMAL

  if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
    {

      REAL tempdu[4];
      REAL tempdata[4];
      REAL u1 = global_ev_u1;
      REAL u2 = global_ev_u2;
      if(u-MYDELTA*(u2-u1) < u1)
    u = u+ MYDELTA*(u2-u1);
      else
    u = u-MYDELTA*(u2-u1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, tempdu, dv);
    }
  if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
    {
      REAL tempdv[4];
      REAL tempdata[4];
      REAL v1 = global_ev_v1;
      REAL v2 = global_ev_v2;
      if(v-MYDELTA*(v2-v1) < v1)
    v = v+ MYDELTA*(v2-v1);
      else
    v = v-MYDELTA*(v2-v1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, du, tempdv);
    }
#endif

  /*compute normal*/
  switch(global_ev_k){
  case 3:
    inComputeNormal2(du, dv, retNormal);
    break;
  case 4:
    inComputeFirstPartials(retPoint, du, dv);
    inComputeNormal2(du, dv, retNormal);
    /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
    retPoint[0] /= retPoint[3];
    retPoint[1] /= retPoint[3];
    retPoint[2] /= retPoint[3];
    break;
  }
}

Referenced by inEvalVLine().

inDoEvalCoord2NOGE_BV()

void OpenGLSurfaceEvaluator::inDoEvalCoord2NOGE_BV ( REAL  u, REAL  v, REAL *  retPoint, REAL *  retNormal  )

privatevirtual

Implements BasicSurfaceEvaluator.

Definition at line 684 of file insurfeval.cc.

{

  REAL du[4];
  REAL dv[4];

 
  assert(global_ev_k>=3 && global_ev_k <= 4);
  /*compute homegeneous point and partial derivatives*/
//   inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);

  inDoDomain2WithDerivsBV(global_ev_k, u, v, global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, retPoint, du, dv);


#ifdef AVOID_ZERO_NORMAL

  if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
    {

      REAL tempdu[4];
      REAL tempdata[4];
      REAL u1 = global_ev_u1;
      REAL u2 = global_ev_u2;
      if(u-MYDELTA*(u2-u1) < u1)
    u = u+ MYDELTA*(u2-u1);
      else
    u = u-MYDELTA*(u2-u1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, tempdu, dv);
    }
  if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
    {
      REAL tempdv[4];
      REAL tempdata[4];
      REAL v1 = global_ev_v1;
      REAL v2 = global_ev_v2;
      if(v-MYDELTA*(v2-v1) < v1)
    v = v+ MYDELTA*(v2-v1);
      else
    v = v-MYDELTA*(v2-v1);
      inDoDomain2WithDerivs(global_ev_k, u,v,global_ev_u1, global_ev_u2, global_ev_uorder, global_ev_v1, global_ev_v2, global_ev_vorder, global_ev_ctlPoints, tempdata, du, tempdv);
    }
#endif

  /*compute normal*/
  switch(global_ev_k){
  case 3:
    inComputeNormal2(du, dv, retNormal);
    break;
  case 4:
    inComputeFirstPartials(retPoint, du, dv);
    inComputeNormal2(du, dv, retNormal);
    /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
    retPoint[0] /= retPoint[3];
    retPoint[1] /= retPoint[3];
    retPoint[2] /= retPoint[3];
    break;
  }
}

Referenced by inEvalULine().

inEvalCoord2f()

void OpenGLSurfaceEvaluator::inEvalCoord2f ( REAL  u, REAL  v  )

private

Definition at line 375 of file insurfeval.cc.

{

  REAL point[4];
  REAL normal[3];
  inDoEvalCoord2(u,v,point, normal);
}

Referenced by coord2f(), and inBPMEval().

inEvalMesh2()

void OpenGLSurfaceEvaluator::inEvalMesh2 ( int  lowU, int  lowV, int  highU, int  highV  )

private

Definition at line 400 of file insurfeval.cc.

{
  REAL du, dv;
  int i,j;
  REAL point[4];
  REAL normal[3];
  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=lowU; i<highU; 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=highV; j>=lowV; j--){
    REAL v1 = (j == global_grid_nv)? global_grid_v1: (global_grid_v0 +j*dv);
    
    inDoEvalCoord2(u1, v1, point, normal);
    inDoEvalCoord2(u2, v1, point, normal);
      }
      endqstrip();
    }
  }
  
  else{
    for(i=lowV; i<highV; 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=highU; j>=lowU; j--){
    REAL u1 = (j == global_grid_nu)? global_grid_u1: (global_grid_u0 +j*du);    
    inDoEvalCoord2(u1, v2, point, normal);
    inDoEvalCoord2(u1, v1, point, normal);
      }
      endqstrip();
    }
  }
    
}

Referenced by mapmesh2f().

inEvalPoint2()

void OpenGLSurfaceEvaluator::inEvalPoint2 ( int  i, int  j  )

private

Definition at line 362 of file insurfeval.cc.

{
  REAL du, dv;
  REAL point[4];
  REAL normal[3];
  REAL u,v;
  du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
  dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
  u = (i==global_grid_nu)? global_grid_u1:(global_grid_u0 + i*du);
  v = (j == global_grid_nv)? global_grid_v1: (global_grid_v0 +j*dv);
  inDoEvalCoord2(u,v,point,normal);
}

Referenced by point2i().

inEvalULine()

void OpenGLSurfaceEvaluator::inEvalULine ( int  n_points, REAL  v, REAL *  u_vals, int  stride, REAL  ret_points[][3], REAL  ret_normals[][3]  )

private

Definition at line 1125 of file insurfeval.cc.

{
  int i,k;
  REAL temp[4];
inPreEvaluateBV_intfac(v);

  for(i=0,k=0; i<n_points; i++, k += stride)
    {
      inDoEvalCoord2NOGE_BV(u_vals[k],v,temp, ret_normals[i]);

      ret_points[i][0] = temp[0];
      ret_points[i][1] = temp[1];
      ret_points[i][2] = temp[2];

    }

}

Referenced by inEvalUStrip().

inEvalUStrip()

void OpenGLSurfaceEvaluator::inEvalUStrip ( int  n_upper, REAL  v_upper, REAL *  upper_val, int  n_lower, REAL  v_lower, REAL *  lower_val  )

private

Definition at line 1166 of file insurfeval.cc.

{
  int i,j,k,l;
  REAL leftMostV[2];
 typedef REAL REAL3[3];

  REAL3* upperXYZ = (REAL3*) malloc(sizeof(REAL3)*n_upper);
  assert(upperXYZ);
  REAL3* upperNormal = (REAL3*) malloc(sizeof(REAL3) * n_upper);
  assert(upperNormal);
  REAL3* lowerXYZ = (REAL3*) malloc(sizeof(REAL3)*n_lower);
  assert(lowerXYZ);
  REAL3* lowerNormal = (REAL3*) malloc(sizeof(REAL3) * n_lower);
  assert(lowerNormal);
  
  inEvalULine(n_upper, v_upper, upper_val,  1, upperXYZ, upperNormal);
  inEvalULine(n_lower, v_lower, lower_val,  1, lowerXYZ, lowerNormal);



  REAL* leftMostXYZ;
  REAL* leftMostNormal;

  /*
   *the algorithm works by scanning from left to right.
   *leftMostV: the left most of the remaining verteces (on both upper and lower).
   *           it could an element of upperVerts or lowerVerts.
   *i: upperVerts[i] is the first vertex to the right of leftMostV on upper line   *j: lowerVerts[j] is the first vertex to the right of leftMostV on lower line   */

  /*initialize i,j,and leftMostV
   */
  if(upper_val[0] <= lower_val[0])
    {
      i=1;
      j=0;

      leftMostV[0] = upper_val[0];
      leftMostV[1] = v_upper;
      leftMostXYZ = upperXYZ[0];
      leftMostNormal = upperNormal[0];
    }
  else
    {
      i=0;
      j=1;

      leftMostV[0] = lower_val[0];
      leftMostV[1] = v_lower;

      leftMostXYZ = lowerXYZ[0];
      leftMostNormal = lowerNormal[0];
    }
  
  /*the main loop.
   *the invariance is that: 
   *at the beginning of each loop, the meaning of i,j,and leftMostV are 
   *maintained
   */
  while(1)
    {
      if(i >= n_upper) /*case1: no more in upper*/
        {
          if(j<n_lower-1) /*at least two vertices in lower*/
            {
              bgntfan();
          glNormal3fv(leftMostNormal);
              glVertex3fv(leftMostXYZ);

              while(j<n_lower){
        glNormal3fv(lowerNormal[j]);
        glVertex3fv(lowerXYZ[j]);
        j++;

              }
              endtfan();
            }
          break; /*exit the main loop*/
        }
      else if(j>= n_lower) /*case2: no more in lower*/
        {
          if(i<n_upper-1) /*at least two vertices in upper*/
            {
              bgntfan();
          glNormal3fv(leftMostNormal);
          glVertex3fv(leftMostXYZ);
          
              for(k=n_upper-1; k>=i; k--) /*reverse order for two-side lighting*/
        {
          glNormal3fv(upperNormal[k]);
          glVertex3fv(upperXYZ[k]);
        }

              endtfan();
            }
          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();

          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*/
                {
          glNormal3fv(upperNormal[l]);
          glVertex3fv(upperXYZ[l]);

                }
          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();
          glNormal3fv(upperNormal[i]);
          glVertex3fv(upperXYZ[i]);
          
              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;
          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);
}

Referenced by evalUStrip().

inEvalVLine()

void OpenGLSurfaceEvaluator::inEvalVLine ( int  n_points, REAL  u, REAL *  v_vals, int  stride, REAL  ret_points[][3], REAL  ret_normals[][3]  )

private

Definition at line 1144 of file insurfeval.cc.

{
  int i,k;
  REAL temp[4];
inPreEvaluateBU_intfac(u);
  for(i=0,k=0; i<n_points; i++, k += stride)
    {
      inDoEvalCoord2NOGE_BU(u, v_vals[k], temp, ret_normals[i]);
      ret_points[i][0] = temp[0];
      ret_points[i][1] = temp[1];
      ret_points[i][2] = temp[2];
    }
}

Referenced by inEvalVStrip().

inEvalVStrip()

void OpenGLSurfaceEvaluator::inEvalVStrip ( int  n_left, REAL  u_left, REAL *  left_val, int  n_right, REAL  u_right, REAL *  right_val  )

private

Definition at line 1355 of file insurfeval.cc.

{
  int i,j,k,l;
  REAL botMostV[2];
  typedef REAL REAL3[3];

  REAL3* leftXYZ = (REAL3*) malloc(sizeof(REAL3)*n_left);
  assert(leftXYZ);
  REAL3* leftNormal = (REAL3*) malloc(sizeof(REAL3) * n_left);
  assert(leftNormal);
  REAL3* rightXYZ = (REAL3*) malloc(sizeof(REAL3)*n_right);
  assert(rightXYZ);
  REAL3* rightNormal = (REAL3*) malloc(sizeof(REAL3) * n_right);
  assert(rightNormal);
  
  inEvalVLine(n_left, u_left, left_val,  1, leftXYZ, leftNormal);
  inEvalVLine(n_right, u_right, right_val,  1, rightXYZ, rightNormal);



  REAL* botMostXYZ;
  REAL* botMostNormal;

  /*
   *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];
      botMostXYZ = leftXYZ[0];
      botMostNormal = leftNormal[0];
    }
  else
    {
      i=0;
      j=1;

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

      botMostXYZ = rightXYZ[0];
      botMostNormal = rightNormal[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();
          glNormal3fv(botMostNormal);
              glVertex3fv(botMostXYZ);

              while(j<n_right){
        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();
          glNormal3fv(botMostNormal);
          glVertex3fv(botMostXYZ);
          
              for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
        {
          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();

          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*/
                {
          glNormal3fv(leftNormal[l]);
          glVertex3fv(leftXYZ[l]);

                }
          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();
          glNormal3fv(leftNormal[i]);
          glVertex3fv(leftXYZ[i]);
          
              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;
          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(rightXYZ);
  free(leftNormal);
  free(rightNormal);
}

Referenced by evalVStrip().

inMap2f()

void OpenGLSurfaceEvaluator::inMap2f ( int  k, REAL  ulower, REAL  uupper, int  ustride, int  uorder, REAL  vlower, REAL  vupper, int  vstride, int  vorder, REAL *  ctlPoints  )

private

Definition at line 444 of file insurfeval.cc.

{
  int i,j,x;
  REAL *data = global_ev_ctlPoints;
  


  if(k == GL_MAP2_VERTEX_3) k=3;
  else if (k==GL_MAP2_VERTEX_4) k =4;
  else {
    printf("error in inMap2f, maptype=%i is wrong, k,map is not updated\n", k);
    return;
  }
  
  global_ev_k = k;
  global_ev_u1 = ulower;
  global_ev_u2 = uupper;
  global_ev_ustride = ustride;
  global_ev_uorder = uorder;
  global_ev_v1 = vlower;
  global_ev_v2 = vupper;
  global_ev_vstride = vstride;
  global_ev_vorder = vorder;

  /*copy the contrl points from ctlPoints to global_ev_ctlPoints*/
  for (i=0; i<uorder; i++) {
    for (j=0; j<vorder; j++) {
      for (x=0; x<k; x++) {
    data[x] = ctlPoints[x];
      }
      ctlPoints += vstride;
      data += k;
    }
    ctlPoints += ustride - vstride * vorder;
  }

}

Referenced by inBPMEval(), and map2f().

inMap2fEM()

void OpenGLSurfaceEvaluator::inMap2fEM ( int  which, int  dimension, REAL  ulower, REAL  uupper, int  ustride, int  uorder, REAL  vlower, REAL  vupper, int  vstride, int  vorder, REAL *  ctlPoints  )

private

Definition at line 1540 of file insurfeval.cc.

{
  int i,j,x;
  surfEvalMachine *temp_em;
  switch(which){
  case 0: //vertex
    vertex_flag = 1;
    temp_em = &em_vertex;
    break;
  case 1: //normal
    normal_flag = 1;
    temp_em = &em_normal;
    break;
  case 2: //color
    color_flag = 1;
    temp_em = &em_color;
    break;
  default:
    texcoord_flag = 1;
    temp_em = &em_texcoord;
    break;
  }

  REAL *data = temp_em->ctlPoints;
  
  temp_em->uprime = -1;//initilized
  temp_em->vprime = -1;

  temp_em->k = k;
  temp_em->u1 = ulower;
  temp_em->u2 = uupper;
  temp_em->ustride = ustride;
  temp_em->uorder = uorder;
  temp_em->v1 = vlower;
  temp_em->v2 = vupper;
  temp_em->vstride = vstride;
  temp_em->vorder = vorder;

  /*copy the contrl points from ctlPoints to global_ev_ctlPoints*/
  for (i=0; i<uorder; i++) {
    for (j=0; j<vorder; j++) {
      for (x=0; x<k; x++) {
    data[x] = ctlPoints[x];
      }
      ctlPoints += vstride;
      data += k;
    }
    ctlPoints += ustride - vstride * vorder;
  }
}