src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/mesa/src/src/glu/sgi/libnurbs/interface/glsurfeval.h - public/gem5-resources - Git at Google

 /*
  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice including the dates of first publication and
  * either this permission notice or a reference to
  * http://oss.sgi.com/projects/FreeB/
  * shall be included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  * shall not be used in advertising or otherwise to promote the sale, use or
  * other dealings in this Software without prior written authorization from
  * Silicon Graphics, Inc.
  */

 /*
  * glsurfeval.h
  *
  */

 #ifndef __gluglsurfeval_h_
 #define __gluglsurfeval_h_

 #include "basicsurfeval.h"
 #include "bezierPatchMesh.h" //in case output triangles
 #include <GL/gl.h>
 #include <GL/glu.h>

 class SurfaceMap;
 class OpenGLSurfaceEvaluator;
 class StoredVertex;

 #define TYPECOORD	1
 #define TYPEPOINT	2

 /* Cache up to 3 vertices from tmeshes */
 #define VERTEX_CACHE_SIZE	3

 /*for internal evaluator callback stuff*/
 #ifndef IN_MAX_BEZIER_ORDER
 #define IN_MAX_BEZIER_ORDER 40 /*XXX should be bigger than machine order*/
 #endif

 #ifndef IN_MAX_DIMENSION
 #define IN_MAX_DIMENSION 4
 #endif

 typedef struct surfEvalMachine{
   REAL uprime;//cached previusly evaluated uprime.
   REAL vprime;
   int k; /*the dimension*/
   REAL u1;
   REAL u2;
   int ustride;
   int uorder;
   REAL v1;
   REAL v2;
   int vstride;
   int vorder;
   REAL ctlPoints[IN_MAX_BEZIER_ORDER*IN_MAX_BEZIER_ORDER*IN_MAX_DIMENSION];
   REAL ucoeff[IN_MAX_BEZIER_ORDER]; /*cache the polynomial values*/
   REAL vcoeff[IN_MAX_BEZIER_ORDER];
   REAL ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /*cache the polynomial derivatives*/
   REAL vcoeffDeriv[IN_MAX_BEZIER_ORDER];
 } surfEvalMachine;


 class StoredVertex {
 public:
     		StoredVertex() { type = 0; }
 		~StoredVertex(void) {}
     void	saveEvalCoord(REAL x, REAL y)
 		    {coord[0] = x; coord[1] = y; type = TYPECOORD; }
     void	saveEvalPoint(long x, long y)
 		    {point[0] = x; point[1] = y; type = TYPEPOINT; }
     void	invoke(OpenGLSurfaceEvaluator *eval);

 private:
     int		type;
     REAL	coord[2];
     long	point[2];
 };

 class OpenGLSurfaceEvaluator : public BasicSurfaceEvaluator {
 public:
 			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 );

 #ifdef _WIN32
     void 	        putCallBack(GLenum which, void (GLAPIENTRY *fn)() );
 #else
     void 	        putCallBack(GLenum which, _GLUfuncptr fn );
 #endif

     int                 get_vertices_call_back()
       {
 	return output_triangles;
       }
     void                put_vertices_call_back(int flag)
       {
 	output_triangles = flag;
       }

     void                 put_callback_auto_normal(int flag)
       {
         callback_auto_normal = flag;
       }

    int                   get_callback_auto_normal()
      {
         return callback_auto_normal;
       }

    void                  set_callback_userData(void* data)
      {
        userData = data;
      }

     /**************begin for LOD_eval_list***********/
     void LOD_eval_list(int level);


 private:
     StoredVertex	*vertexCache[VERTEX_CACHE_SIZE];
     int			tmeshing;
     int			which;
     int			vcount;

     GLint              gl_polygon_mode[2];/*to save and restore so that
 					 *no side effect
 					 */
     bezierPatchMesh        *global_bpm; //for output triangles
     int                output_triangles; //true 1 or false 0


     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* data);
     void (GLAPIENTRY *endCallBackData)   (void* data);
     void (GLAPIENTRY *vertexCallBackData) (const GLfloat *vert, void* data);
     void (GLAPIENTRY *normalCallBackData) (const GLfloat *normal, void* data);
     void (GLAPIENTRY *colorCallBackData) (const GLfloat *color, void* data);
     void (GLAPIENTRY *texcoordCallBackData) (const GLfloat *texcoord, void* data);

     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* userData; //the opaque pointer for Data callback functions.

    /*LOD evaluation*/
    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);

   int LOD_eval_level; //set by LOD_eval_list()

    /*************begin for internal evaluators*****************/

  /*the following global variables are only defined in this file.
  *They are used to cache the precomputed Bezier polynomial values.
  *These calues may be used consecutively in which case we don't have
  *recompute these values again.
  */
  int global_uorder; /*store the uorder in the previous evaluation*/
  int global_vorder; /*store the vorder in the previous evaluation*/
  REAL global_uprime;
  REAL global_vprime;
  REAL global_vprime_BV;
  REAL global_uprime_BU;
  int global_uorder_BV; /*store the uorder in the previous evaluation*/
  int global_vorder_BV; /*store the vorder in the previous evaluation*/
  int global_uorder_BU; /*store the uorder in the previous evaluation*/
  int global_vorder_BU; /*store the vorder in the previous evaluation*/

  REAL global_ucoeff[IN_MAX_BEZIER_ORDER]; /*cache the polynomial values*/
  REAL global_vcoeff[IN_MAX_BEZIER_ORDER];
  REAL global_ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /*cache the polynomial derivatives*/
  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; /*the dimension*/
  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;

 /*functions*/
  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 )
   {
    inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);
   }

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

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

 /*-------------begin for surfEvalMachine -------------*/
 surfEvalMachine em_vertex;
 surfEvalMachine em_normal;
 surfEvalMachine em_color;
 surfEvalMachine em_texcoord;

 int auto_normal_flag; //whether to output normla or not in callback
                       //determined by GL_AUTO_NORMAL and callback_auto_normal
 int callback_auto_normal; //GLU_CALLBACK_AUTO_NORMAL_EXT
 int vertex_flag;
 int normal_flag;
 int color_flag;
 int texcoord_flag;

 void inMap2fEM(int which, //0:vert,1:norm,2:color,3:tex
 	       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);

 /*-------------end for surfEvalMachine -------------*/


    /*************end for internal evaluators*****************/

 };

 inline void StoredVertex::invoke(OpenGLSurfaceEvaluator *eval)
 {
     switch(type) {
       case TYPECOORD:
 	eval->coord2f(coord[0], coord[1]);
 	break;
       case TYPEPOINT:
 	eval->point2i(point[0], point[1]);
 	break;
       default:
 	break;
     }
 }

 #endif /* __gluglsurfeval_h_ */
	/*
	* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
	* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice including the dates of first publication and
	* either this permission notice or a reference to
	* http://oss.sgi.com/projects/FreeB/
	* shall be included in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
	* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	* SOFTWARE.
	*
	* Except as contained in this notice, the name of Silicon Graphics, Inc.
	* shall not be used in advertising or otherwise to promote the sale, use or
	* other dealings in this Software without prior written authorization from
	* Silicon Graphics, Inc.
	*/

	/*
	* glsurfeval.h
	*
	*/

	#ifndef __gluglsurfeval_h_
	#define __gluglsurfeval_h_

	#include "basicsurfeval.h"
	#include "bezierPatchMesh.h" //in case output triangles
	#include <GL/gl.h>
	#include <GL/glu.h>

	class SurfaceMap;
	class OpenGLSurfaceEvaluator;
	class StoredVertex;

	#define TYPECOORD 1
	#define TYPEPOINT 2

	/* Cache up to 3 vertices from tmeshes */
	#define VERTEX_CACHE_SIZE 3

	/for internal evaluator callback stuff/
	#ifndef IN_MAX_BEZIER_ORDER
	#define IN_MAX_BEZIER_ORDER 40 /XXX should be bigger than machine order/
	#endif

	#ifndef IN_MAX_DIMENSION
	#define IN_MAX_DIMENSION 4
	#endif

	typedef struct surfEvalMachine{
	REAL uprime;//cached previusly evaluated uprime.
	REAL vprime;
	int k; /the dimension/
	REAL u1;
	REAL u2;
	int ustride;
	int uorder;
	REAL v1;
	REAL v2;
	int vstride;
	int vorder;
	REAL ctlPoints[IN_MAX_BEZIER_ORDERIN_MAX_BEZIER_ORDERIN_MAX_DIMENSION];
	REAL ucoeff[IN_MAX_BEZIER_ORDER]; /cache the polynomial values/
	REAL vcoeff[IN_MAX_BEZIER_ORDER];
	REAL ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /cache the polynomial derivatives/
	REAL vcoeffDeriv[IN_MAX_BEZIER_ORDER];
	} surfEvalMachine;



	class StoredVertex {
	public:
	StoredVertex() { type = 0; }
	~StoredVertex(void) {}
	void saveEvalCoord(REAL x, REAL y)
	{coord[0] = x; coord[1] = y; type = TYPECOORD; }
	void saveEvalPoint(long x, long y)
	{point[0] = x; point[1] = y; type = TYPEPOINT; }
	void invoke(OpenGLSurfaceEvaluator *eval);

	private:
	int type;
	REAL coord[2];
	long point[2];
	};

	class OpenGLSurfaceEvaluator : public BasicSurfaceEvaluator {
	public:
	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 );

	#ifdef _WIN32
	void putCallBack(GLenum which, void (GLAPIENTRY *fn)() );
	#else
	void putCallBack(GLenum which, _GLUfuncptr fn );
	#endif

	int get_vertices_call_back()
	{
	return output_triangles;
	}
	void put_vertices_call_back(int flag)
	{
	output_triangles = flag;
	}

	void put_callback_auto_normal(int flag)
	{
	callback_auto_normal = flag;
	}

	int get_callback_auto_normal()
	{
	return callback_auto_normal;
	}

	void set_callback_userData(void* data)
	{
	userData = data;
	}

	/************begin for LOD_eval_list*********/
	void LOD_eval_list(int level);




	private:
	StoredVertex *vertexCache[VERTEX_CACHE_SIZE];
	int tmeshing;
	int which;
	int vcount;

	GLint gl_polygon_mode[2];/*to save and restore so that
	*no side effect
	*/
	bezierPatchMesh *global_bpm; //for output triangles
	int output_triangles; //true 1 or false 0



	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 data);
	void (GLAPIENTRY endCallBackData) (void data);
	void (GLAPIENTRY vertexCallBackData) (const GLfloat vert, void* data);
	void (GLAPIENTRY normalCallBackData) (const GLfloat normal, void* data);
	void (GLAPIENTRY colorCallBackData) (const GLfloat color, void* data);
	void (GLAPIENTRY texcoordCallBackData) (const GLfloat texcoord, void* data);

	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* userData; //the opaque pointer for Data callback functions.

	/LOD evaluation/
	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);

	int LOD_eval_level; //set by LOD_eval_list()

	/***********begin for internal evaluators***************/

	/*the following global variables are only defined in this file.
	*They are used to cache the precomputed Bezier polynomial values.
	*These calues may be used consecutively in which case we don't have
	*recompute these values again.
	*/
	int global_uorder; /store the uorder in the previous evaluation/
	int global_vorder; /store the vorder in the previous evaluation/
	REAL global_uprime;
	REAL global_vprime;
	REAL global_vprime_BV;
	REAL global_uprime_BU;
	int global_uorder_BV; /store the uorder in the previous evaluation/
	int global_vorder_BV; /store the vorder in the previous evaluation/
	int global_uorder_BU; /store the uorder in the previous evaluation/
	int global_vorder_BU; /store the vorder in the previous evaluation/

	REAL global_ucoeff[IN_MAX_BEZIER_ORDER]; /cache the polynomial values/
	REAL global_vcoeff[IN_MAX_BEZIER_ORDER];
	REAL global_ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /cache the polynomial derivatives/
	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; /the dimension/
	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_ORDERIN_MAX_BEZIER_ORDERIN_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;

	/functions/
	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 )
	{
	inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);
	}

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

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

	/-------------begin for surfEvalMachine -------------/
	surfEvalMachine em_vertex;
	surfEvalMachine em_normal;
	surfEvalMachine em_color;
	surfEvalMachine em_texcoord;

	int auto_normal_flag; //whether to output normla or not in callback
	//determined by GL_AUTO_NORMAL and callback_auto_normal
	int callback_auto_normal; //GLU_CALLBACK_AUTO_NORMAL_EXT
	int vertex_flag;
	int normal_flag;
	int color_flag;
	int texcoord_flag;

	void inMap2fEM(int which, //0:vert,1:norm,2:color,3:tex
	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);

	/-------------end for surfEvalMachine -------------/


	/***********end for internal evaluators***************/

	};

	inline void StoredVertex::invoke(OpenGLSurfaceEvaluator *eval)
	{
	switch(type) {
	case TYPECOORD:
	eval->coord2f(coord[0], coord[1]);
	break;
	case TYPEPOINT:
	eval->point2i(point[0], point[1]);
	break;
	default:
	break;
	}
	}

	#endif /* __gluglsurfeval_h_ */