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 ()
virtual void	range2f (long, REAL *, REAL *)
virtual void	domain2f (REAL, REAL, REAL, REAL)
virtual void	enable (long)
virtual void	disable (long)
virtual void	bgnmap2f (long)
virtual void	map2f (long, REAL, REAL, long, long, REAL, REAL, long, long, REAL *)
virtual void	mapgrid2f (long, REAL, REAL, long, REAL, REAL)
virtual void	mapmesh2f (long, long, long, long, long)
virtual void	evalcoord2f (long, REAL, REAL)
virtual void	evalpoint2i (long, long)
virtual void	endmap2f (void)
virtual void	polymode (long)
virtual void	bgnline (void)
virtual void	endline (void)
virtual void	bgnclosedline (void)
virtual void	endclosedline (void)
virtual void	bgntmesh (void)
virtual void	swaptmesh (void)
virtual void	endtmesh (void)
virtual void	bgnqstrip (void)
virtual void	endqstrip (void)
virtual void	bgntfan (void)
virtual void	endtfan (void)
virtual void	evalUStrip (int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)=0
virtual void	evalVStrip (int n_left, REAL u_left, REAL *left_val, int n_right, REAL u_right, REAL *right_val)=0
virtual void	inDoEvalCoord2NOGE (REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
virtual void	inDoEvalCoord2NOGE_BU (REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
virtual void	inDoEvalCoord2NOGE_BV (REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
virtual void	inPreEvaluateBV_intfac (REAL v)=0
virtual void	inPreEvaluateBU_intfac (REAL u)=0
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;
  }
}

Referenced by inBPMEvalEM().

inMapGrid2f()

void OpenGLSurfaceEvaluator::inMapGrid2f ( int  nu, REAL  u0, REAL  u1, int  nv, REAL  v0, REAL  v1  )

private

Definition at line 389 of file insurfeval.cc.

{
 global_grid_u0 = u0;
 global_grid_u1 = u1;
 global_grid_nu = nu;
 global_grid_v0 = v0;
 global_grid_v1 = v1;
 global_grid_nv = nv;
}

Referenced by mapgrid2f().

inPreEvaluate()

void OpenGLSurfaceEvaluator::inPreEvaluate ( int  order, REAL  vprime, REAL *  coeff  )

private

Definition at line 1022 of file insurfeval.cc.

{
  int i, j;
  REAL oldval, temp;
  REAL oneMinusvprime;
  
  /*
   * Minor optimization
   * Compute orders 1 and 2 outright, and set coeff[0], coeff[1] to
     * their i==1 loop values to avoid the initialization and the i==1 loop.
     */
  if (order == 1) {
    coeff[0] = 1.0;
    return;
  }
  
  oneMinusvprime = 1-vprime;
  coeff[0] = oneMinusvprime;
  coeff[1] = vprime;
  if (order == 2) return;
  
  for (i = 2; i < order; i++) {
    oldval = coeff[0] * vprime;
    coeff[0] = oneMinusvprime * coeff[0];
    for (j = 1; j < i; j++) {
      temp = oldval;
      oldval = coeff[j] * vprime;
        coeff[j] = temp + oneMinusvprime * coeff[j];
    }
    coeff[j] = oldval;
  }
}

Referenced by inDoDomain2EM().

inPreEvaluateBU()

void OpenGLSurfaceEvaluator::inPreEvaluateBU ( int  k, int  uorder, int  vorder, REAL  uprime, REAL *  baseData  )

private

Definition at line 838 of file insurfeval.cc.

{
  int j,row,col;
  REAL p, pdu;
  REAL *data;
 
  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++){
    data = baseData+j;
    for(col=0; col<vorder; col++){
      data = baseData+j + k*col;
      p = global_ucoeff[0] * (*data);
      pdu = global_ucoeffDeriv[0] * (*data);
      data += k*uorder;
      for(row = 1; row < uorder; row++){
    p += global_ucoeff[row] *  (*data);
    pdu += global_ucoeffDeriv[row] * (*data);
    data += k * uorder;
      }
      global_BU[col][j]  = p;
      global_PBU[col][j]  = pdu;
    }
  }
}

Referenced by inPreEvaluateBU_intfac().

inPreEvaluateBU_intfac()

void OpenGLSurfaceEvaluator::inPreEvaluateBU_intfac ( REAL  u )

inlineprivatevirtual

Implements BasicSurfaceEvaluator.

Definition at line 321 of file glsurfeval.h.

  {
    inPreEvaluateBU(global_ev_k, global_ev_uorder, global_ev_vorder, (u-global_ev_u1)/(global_ev_u2-global_ev_u1), global_ev_ctlPoints); 
  }

Referenced by inEvalVLine().

inPreEvaluateBV()

void OpenGLSurfaceEvaluator::inPreEvaluateBV ( int  k, int  uorder, int  vorder, REAL  vprime, REAL *  baseData  )

private

Definition at line 809 of file insurfeval.cc.

{
  int j,row,col;
  REAL p, pdv;
  REAL *data;
 
  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++){
    data = baseData+j;
    for(row=0; row<uorder; row++){
      p = global_vcoeff[0] * (*data);
      pdv = global_vcoeffDeriv[0] * (*data);
      data += k;
      for(col = 1; col < vorder; col++){
    p += global_vcoeff[col] *  (*data);
    pdv += global_vcoeffDeriv[col] * (*data);
    data += k;
      }
      global_BV[row][j]  = p;
      global_PBV[row][j]  = pdv;
    }
  }
}

Referenced by inPreEvaluateBV_intfac().

inPreEvaluateBV_intfac()

void OpenGLSurfaceEvaluator::inPreEvaluateBV_intfac ( REAL  v )

inlineprivatevirtual

Implements BasicSurfaceEvaluator.

Definition at line 316 of file glsurfeval.h.

  {
   inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);
  }

Referenced by inEvalULine().

inPreEvaluateWithDeriv()

void OpenGLSurfaceEvaluator::inPreEvaluateWithDeriv ( int  order, REAL  vprime, REAL *  coeff, REAL *  coeffDeriv  )

private

Definition at line 1066 of file insurfeval.cc.

{
  int i, j;
  REAL oldval, temp;
  REAL oneMinusvprime;
  
  oneMinusvprime = 1-vprime;
  /*
   * Minor optimization
   * Compute orders 1 and 2 outright, and set coeff[0], coeff[1] to 
   * their i==1 loop values to avoid the initialization and the i==1 loop.
   */
  if (order == 1) {
    coeff[0] = 1.0;
    coeffDeriv[0] = 0.0;
    return;
  } else if (order == 2) {
    coeffDeriv[0] = -1.0;
    coeffDeriv[1] = 1.0;
    coeff[0] = oneMinusvprime;
    coeff[1] = vprime;
    return;
  }
  coeff[0] = oneMinusvprime;
  coeff[1] = vprime;
  for (i = 2; i < order - 1; i++) {
    oldval = coeff[0] * vprime;
    coeff[0] = oneMinusvprime * coeff[0];
    for (j = 1; j < i; j++) {
      temp = oldval;
      oldval = coeff[j] * vprime;
      coeff[j] = temp + oneMinusvprime * coeff[j];
    }
    coeff[j] = oldval;
  }
  coeffDeriv[0] = -coeff[0];
  /*
   ** Minor optimization:
   ** Would make this a "for (j=1; j<order-1; j++)" loop, but it is always
   ** executed at least once, so this is more efficient.
   */
  j=1;
  do {
    coeffDeriv[j] = coeff[j-1] - coeff[j];
    j++;
  } while (j < order - 1);
  coeffDeriv[j] = coeff[j-1];
  
  oldval = coeff[0] * vprime;
  coeff[0] = oneMinusvprime * coeff[0];
  for (j = 1; j < i; j++) {
    temp = oldval;
    oldval = coeff[j] * vprime;
    coeff[j] = temp + oneMinusvprime * coeff[j];
  }
  coeff[j] = oldval;
}

Referenced by inDoDomain2WithDerivs(), inDoDomain2WithDerivsBU(), inDoDomain2WithDerivsBV(), inDoDomain2WithDerivsEM(), inPreEvaluateBU(), and inPreEvaluateBV().

LOD_eval()

void OpenGLSurfaceEvaluator::LOD_eval ( int  num_vert, REAL *  verts, int  type, int  level  )

private

Referenced by inBPMEvalEM().

LOD_eval_list()

void OpenGLSurfaceEvaluator::LOD_eval_list

(

int

level

)

Definition at line 84 of file glsurfeval.cc.

{
  if(level == 0)
    LOD_eval_level = 1;
  else if(level == 1)
    LOD_eval_level = 2;
  else if(level == 2)
    LOD_eval_level = 4;
  else
    LOD_eval_level = 8;
 
  inBPMListEvalEM(global_bpm);
}

Referenced by GLUnurbs::LOD_eval_list().

LOD_triangle()

void OpenGLSurfaceEvaluator::LOD_triangle ( REAL  A[2], REAL  B[2], REAL  C[2], int  level  )

private

map2f()

void OpenGLSurfaceEvaluator::map2f ( long  _type, REAL  _ulower, REAL  _uupper, long  _ustride, long  _uorder, REAL  _vlower, REAL  _vupper, long  _vstride, long  _vorder, REAL *  pts  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 872 of file glsurfeval.cc.

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

mapgrid2f()

void OpenGLSurfaceEvaluator::mapgrid2f ( long  nu, REAL  u0, REAL  u1, long  nv, REAL  v0, REAL  v1  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 195 of file glsurfeval.cc.

{
#ifdef USE_INTERNAL_EVAL
  inMapGrid2f((int) nu, (REAL) u0, (REAL) u1, (int) nv,
          (REAL) v0, (REAL) v1);
#else
 
  if(output_triangles)  
    {
      global_grid_u0 = u0;
      global_grid_u1 = u1;
      global_grid_nu = nu;
      global_grid_v0 = v0;
      global_grid_v1 = v1;
      global_grid_nv = nv;
    }
  else
    glMapGrid2d((GLint) nu, (GLdouble) u0, (GLdouble) u1, (GLint) nv,
        (GLdouble) v0, (GLdouble) v1);
 
#endif
}

mapmesh2f()

void OpenGLSurfaceEvaluator::mapmesh2f ( long  style, long  umin, long  umax, long  vmin, long  vmax  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 946 of file glsurfeval.cc.

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

newtmeshvert() [1/2]

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

Definition at line 1134 of file glsurfeval.cc.

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

newtmeshvert() [2/2]

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

Definition at line 1160 of file glsurfeval.cc.

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

Referenced by evalcoord2f(), and evalpoint2i().

normalCallBack()

void OpenGLSurfaceEvaluator::normalCallBack ( const GLfloat *  normal, void *  data  )

private

Definition at line 1265 of file glsurfeval.cc.

{
  if(normalCallBackData)
    normalCallBackData(normal, data);
  else if(normalCallBackN)
    normalCallBackN(normal);
}

Referenced by inBPMEval(), inBPMEvalEM(), and inDoEvalCoord2EM().

point2i()

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

Definition at line 1069 of file glsurfeval.cc.

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

Referenced by StoredVertex::invoke(), and newtmeshvert().

polymode()

void OpenGLSurfaceEvaluator::polymode ( long  style )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 219 of file glsurfeval.cc.

{
  if(! output_triangles)
    {
      switch(style) {
      default:
      case N_MESHFILL:
        
    glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_FILL);
    break;
      case N_MESHLINE:
    glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_LINE);
    break;
      case N_MESHPOINT:
    glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_POINT);
    break;
      }
    }
}

put_callback_auto_normal()

void OpenGLSurfaceEvaluator::put_callback_auto_normal ( int  flag )

inline

Definition at line 158 of file glsurfeval.h.

      {
        callback_auto_normal = flag;
      } 

Referenced by GLUnurbs::put_callback_auto_normal().

put_vertices_call_back()

void OpenGLSurfaceEvaluator::put_vertices_call_back ( int  flag )

inline

Definition at line 153 of file glsurfeval.h.

      {
    output_triangles = flag;
      }

Referenced by GLUnurbs::put_callbackFlag(), and GLUnurbs::put_vertices_call_back().

putCallBack()

void OpenGLSurfaceEvaluator::putCallBack	(	GLenum	which,
		_GLUfuncptr	fn
	)

Definition at line 1190 of file glsurfeval.cc.

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

Referenced by GLUnurbs::putSurfCallBack().

range2f()

void OpenGLSurfaceEvaluator::range2f ( long  type, REAL *  from, REAL *  to  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 258 of file glsurfeval.cc.

{
}

set_callback_userData()

void OpenGLSurfaceEvaluator::set_callback_userData ( void *  data )

inline

Definition at line 168 of file glsurfeval.h.

     {
       userData = data;
     }

Referenced by GLUnurbs::setNurbsCallbackData().

swaptmesh()

void OpenGLSurfaceEvaluator::swaptmesh ( void  )

virtual

Reimplemented from BasicSurfaceEvaluator.

Definition at line 305 of file glsurfeval.cc.

{
    which = 1 - which;
 
}

texcoordCallBack()

void OpenGLSurfaceEvaluator::texcoordCallBack ( const GLfloat *  texcoord, void *  data  )

private

Definition at line 1283 of file glsurfeval.cc.

{
  if(texcoordCallBackData)
    texcoordCallBackData(texcoord, data);
  else if(texcoordCallBackN)
    texcoordCallBackN(texcoord);
}

Referenced by inDoEvalCoord2EM().

vertexCallBack()

void OpenGLSurfaceEvaluator::vertexCallBack ( const GLfloat *  vert, void *  data  )

private

Definition at line 1255 of file glsurfeval.cc.

{
  if(vertexCallBackData)
    vertexCallBackData(vert, data);
  else if(vertexCallBackN)
    vertexCallBackN(vert);
}

Referenced by inBPMEval(), inBPMEvalEM(), and inDoEvalCoord2EM().

void() [1/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  beginCallBackData )

private

void() [2/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  beginCallBackN )

private

void() [3/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  colorCallBackData ) const

private

void() [4/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  colorCallBackN ) const

private

void() [5/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  endCallBackData )

private

void() [6/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  endCallBackN )

private

void() [7/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  normalCallBackData ) const

private

void() [8/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  normalCallBackN ) const

private

void() [9/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  texcoordCallBackData ) const

private

void() [10/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  texcoordCallBackN ) const

private

void() [11/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  vertexCallBackData ) const

private

void() [12/12]

OpenGLSurfaceEvaluator::void ( GLAPIENTRY *  vertexCallBackN ) const

private

Member Data Documentation

auto_normal_flag

int OpenGLSurfaceEvaluator::auto_normal_flag

private

Definition at line 354 of file glsurfeval.h.

Referenced by bgnmap2f(), inDoEvalCoord2EM(), and OpenGLSurfaceEvaluator().

callback_auto_normal

int OpenGLSurfaceEvaluator::callback_auto_normal

private

Definition at line 356 of file glsurfeval.h.

Referenced by get_callback_auto_normal(), OpenGLSurfaceEvaluator(), and put_callback_auto_normal().

color_flag

int OpenGLSurfaceEvaluator::color_flag

private

Definition at line 359 of file glsurfeval.h.

Referenced by bgnmap2f(), inDoEvalCoord2EM(), inMap2fEM(), and OpenGLSurfaceEvaluator().

data

void * OpenGLSurfaceEvaluator::data

private

Definition at line 200 of file glsurfeval.h.

Referenced by inDoDomain2EM(), inDoDomain2WithDerivs(), inDoDomain2WithDerivsEM(), inPreEvaluateBU(), inPreEvaluateBV(), and set_callback_userData().

em_color

surfEvalMachine OpenGLSurfaceEvaluator::em_color

private

Definition at line 351 of file glsurfeval.h.

Referenced by inDoEvalCoord2EM(), inMap2fEM(), and OpenGLSurfaceEvaluator().

em_normal

surfEvalMachine OpenGLSurfaceEvaluator::em_normal

private

Definition at line 350 of file glsurfeval.h.

Referenced by inDoEvalCoord2EM(), inMap2fEM(), and OpenGLSurfaceEvaluator().

em_texcoord

surfEvalMachine OpenGLSurfaceEvaluator::em_texcoord

private

Definition at line 352 of file glsurfeval.h.

Referenced by inDoEvalCoord2EM(), inMap2fEM(), and OpenGLSurfaceEvaluator().

em_vertex

surfEvalMachine OpenGLSurfaceEvaluator::em_vertex

private

Definition at line 349 of file glsurfeval.h.

Referenced by inDoEvalCoord2EM(), inMap2fEM(), and OpenGLSurfaceEvaluator().

gl_polygon_mode

GLint OpenGLSurfaceEvaluator::gl_polygon_mode[2]

private

Definition at line 185 of file glsurfeval.h.

Referenced by bgnmap2f(), and endmap2f().

global_baseData

REAL* OpenGLSurfaceEvaluator::global_baseData

private

Definition at line 251 of file glsurfeval.h.

Referenced by OpenGLSurfaceEvaluator().

global_bpm

bezierPatchMesh* OpenGLSurfaceEvaluator::global_bpm

private

Definition at line 188 of file glsurfeval.h.

Referenced by bgnclosedline(), bgnline(), bgnmap2f(), bgnqstrip(), bgntfan(), bgntmesh(), coord2f(), endclosedline(), endline(), endmap2f(), endqstrip(), endtfan(), endtmesh(), LOD_eval_list(), map2f(), mapmesh2f(), and OpenGLSurfaceEvaluator().

global_BU

REAL OpenGLSurfaceEvaluator::global_BU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]

private

Definition at line 249 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivsBU(), and inPreEvaluateBU().

global_BV

REAL OpenGLSurfaceEvaluator::global_BV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]

private

Definition at line 247 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivsBV(), and inPreEvaluateBV().

global_ev_ctlPoints

REAL OpenGLSurfaceEvaluator::global_ev_ctlPoints[IN_MAX_BEZIER_ORDER *IN_MAX_BEZIER_ORDER *IN_MAX_DIMENSION]

private

Definition at line 262 of file glsurfeval.h.

Referenced by inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), inPreEvaluateBU_intfac(), and inPreEvaluateBV_intfac().

global_ev_k

int OpenGLSurfaceEvaluator::global_ev_k

private

Definition at line 253 of file glsurfeval.h.

Referenced by inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), inPreEvaluateBU_intfac(), and inPreEvaluateBV_intfac().

global_ev_u1

REAL OpenGLSurfaceEvaluator::global_ev_u1

private

Definition at line 254 of file glsurfeval.h.

Referenced by inBPMEval(), inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), and inPreEvaluateBU_intfac().

global_ev_u2

REAL OpenGLSurfaceEvaluator::global_ev_u2

private

Definition at line 255 of file glsurfeval.h.

Referenced by inBPMEval(), inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), and inPreEvaluateBU_intfac().

global_ev_uorder

int OpenGLSurfaceEvaluator::global_ev_uorder

private

Definition at line 257 of file glsurfeval.h.

Referenced by inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), inPreEvaluateBU_intfac(), and inPreEvaluateBV_intfac().

global_ev_ustride

int OpenGLSurfaceEvaluator::global_ev_ustride

private

Definition at line 256 of file glsurfeval.h.

Referenced by inMap2f().

global_ev_v1

REAL OpenGLSurfaceEvaluator::global_ev_v1

private

Definition at line 258 of file glsurfeval.h.

Referenced by inBPMEval(), inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), and inPreEvaluateBV_intfac().

global_ev_v2

REAL OpenGLSurfaceEvaluator::global_ev_v2

private

Definition at line 259 of file glsurfeval.h.

Referenced by inBPMEval(), inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), and inPreEvaluateBV_intfac().

global_ev_vorder

int OpenGLSurfaceEvaluator::global_ev_vorder

private

Definition at line 261 of file glsurfeval.h.

Referenced by inDoEvalCoord2(), inDoEvalCoord2NOGE(), inDoEvalCoord2NOGE_BU(), inDoEvalCoord2NOGE_BV(), inMap2f(), inPreEvaluateBU_intfac(), and inPreEvaluateBV_intfac().

global_ev_vstride

int OpenGLSurfaceEvaluator::global_ev_vstride

private

Definition at line 260 of file glsurfeval.h.

Referenced by inMap2f().

global_grid_nu

int OpenGLSurfaceEvaluator::global_grid_nu

private

Definition at line 266 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_grid_nv

int OpenGLSurfaceEvaluator::global_grid_nv

private

Definition at line 269 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_grid_u0

REAL OpenGLSurfaceEvaluator::global_grid_u0

private

Definition at line 264 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_grid_u1

REAL OpenGLSurfaceEvaluator::global_grid_u1

private

Definition at line 265 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_grid_v0

REAL OpenGLSurfaceEvaluator::global_grid_v0

private

Definition at line 267 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_grid_v1

REAL OpenGLSurfaceEvaluator::global_grid_v1

private

Definition at line 268 of file glsurfeval.h.

Referenced by inEvalMesh2(), inEvalPoint2(), inMapGrid2f(), mapgrid2f(), mapmesh2f(), and point2i().

global_PBU

REAL OpenGLSurfaceEvaluator::global_PBU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]

private

Definition at line 250 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivsBU(), and inPreEvaluateBU().

global_PBV

REAL OpenGLSurfaceEvaluator::global_PBV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]

private

Definition at line 248 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivsBV(), and inPreEvaluateBV().

global_ucoeff

REAL OpenGLSurfaceEvaluator::global_ucoeff[IN_MAX_BEZIER_ORDER]

private

Definition at line 242 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivs(), inDoDomain2WithDerivsBV(), and inPreEvaluateBU().

global_ucoeffDeriv

REAL OpenGLSurfaceEvaluator::global_ucoeffDeriv[IN_MAX_BEZIER_ORDER]

private

Definition at line 244 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivs(), inDoDomain2WithDerivsBV(), and inPreEvaluateBU().

global_uorder

int OpenGLSurfaceEvaluator::global_uorder

private

Definition at line 231 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivs(), inDoDomain2WithDerivsBV(), inPreEvaluateBU(), and OpenGLSurfaceEvaluator().

global_uorder_BU

int OpenGLSurfaceEvaluator::global_uorder_BU

private

Definition at line 239 of file glsurfeval.h.

Referenced by OpenGLSurfaceEvaluator().

global_uorder_BV

int OpenGLSurfaceEvaluator::global_uorder_BV

private

Definition at line 237 of file glsurfeval.h.

Referenced by OpenGLSurfaceEvaluator().

global_uprime

REAL OpenGLSurfaceEvaluator::global_uprime

private

Definition at line 233 of file glsurfeval.h.

Referenced by inDoDomain2WithDerivs(), inDoDomain2WithDerivsBV(), inPreEvaluate