+++ /dev/null
-/*
-** License Applicability. Except to the extent portions of this file are
-** made subject to an alternative license as permitted in the SGI Free
-** Software License B, Version 1.1 (the "License"), the contents of this
-** file are subject only to the provisions of the License. You may not use
-** this file except in compliance with the License. You may obtain a copy
-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
-**
-** http://oss.sgi.com/projects/FreeB
-**
-** Note that, as provided in the License, the Software is distributed on an
-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
-**
-** Original Code. The Original Code is: OpenGL Sample Implementation,
-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
-** Copyright in any portions created by third parties is as indicated
-** elsewhere herein. All Rights Reserved.
-**
-** Additional Notice Provisions: The application programming interfaces
-** established by SGI in conjunction with the Original Code are The
-** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
-** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
-** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
-** Window System(R) (Version 1.3), released October 19, 1998. This software
-** was created using the OpenGL(R) version 1.2.1 Sample Implementation
-** published by SGI, but has not been independently verified as being
-** compliant with the OpenGL(R) version 1.2.1 Specification.
-*/
-
-/*
- * glsurfeval.c++
- *
- */
-
-/* Polynomial Evaluator Interface */
-#include "gluos.h"
-//#include <stdio.h>
-//#include "glimports.h"
-#include "glrenderer.h"
-//#include "glsurfeval.h"
-//#include "nurbsconsts.h"
-//#include "bezierPatchMesh.h"
-
-
-//extern int surfcount;
-//int surfcount=0;
-
-/*#define USE_INTERNAL_EVAL*/ //use internal evaluator
-
-/*whether do evaluation or not*/
-/*#define NO_EVALUATION*/
-
-//#define USE_LOD //for LOD test, have to turn on USE_LOD in insurfeval.c++ too
-
-/*for statistics*/
-//#define STATISTICS
-#ifdef STATISTICS
-static int STAT_num_of_triangles=0;
-static int STAT_num_of_eval_vertices=0;
-static int STAT_num_of_quad_strips=0;
-#endif
-
-/*for output triangles*/
-/*#define OUTPUT_TRIANGLES*/
-
-
-/*#define FOR_CHRIS*/
-#ifdef FOR_CHRIS
-extern "C" { void evalUStripExt(int n_upper, REAL v_upper, REAL* upper_val,
- int n_lower, REAL v_lower, REAL* lower_val);}
-
-extern "C" { void evalVStripExt(int n_left, REAL u_left, REAL* left_val,
- int n_right, REAL u_right, REAL* right_val);
- }
-#endif
-
-
-/**************begin for LOD_eval_list***********/
-void OpenGLSurfaceEvaluator::LOD_eval_list(int level)
-{
- 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);
-}
-
-
-OpenGLSurfaceEvaluator::OpenGLSurfaceEvaluator()
-{
- 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()
-{
- for (int ii= 0; ii< VERTEX_CACHE_SIZE; ii++) {
- delete vertexCache[ii];
- vertexCache[ii]= 0;
- }
-}
-
-/*---------------------------------------------------------------------------
- * disable - turn off a map
- *---------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::disable(long type)
-{
- glDisable((GLenum) type);
-}
-
-/*---------------------------------------------------------------------------
- * enable - turn on a map
- *---------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::enable(long type)
-{
- glEnable((GLenum) type);
-}
-
-/*-------------------------------------------------------------------------
- * mapgrid2f - define a lattice of points with origin and offset
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::mapgrid2f(long nu, REAL u0, REAL u1, long nv, REAL v0, REAL v1)
-{
-#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
-}
-
-void
-OpenGLSurfaceEvaluator::polymode(long style)
-{
- 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;
- }
- }
-}
-
-void
-OpenGLSurfaceEvaluator::bgnline(void)
-{
- if(output_triangles)
- bezierPatchMeshBeginStrip(global_bpm, GL_LINE_STRIP);
- else
- glBegin((GLenum) GL_LINE_STRIP);
-}
-
-void
-OpenGLSurfaceEvaluator::endline(void)
-{
- if(output_triangles)
- bezierPatchMeshEndStrip(global_bpm);
- else
- glEnd();
-}
-
-void
-OpenGLSurfaceEvaluator::range2f(long type, REAL *from, REAL *to)
-{
-}
-
-void
-OpenGLSurfaceEvaluator::domain2f(REAL ulo, REAL uhi, REAL vlo, REAL vhi)
-{
-}
-
-void
-OpenGLSurfaceEvaluator::bgnclosedline(void)
-{
- if(output_triangles)
- bezierPatchMeshBeginStrip(global_bpm, GL_LINE_LOOP);
- else
- glBegin((GLenum) GL_LINE_LOOP);
-}
-
-void
-OpenGLSurfaceEvaluator::endclosedline(void)
-{
- if(output_triangles)
- bezierPatchMeshEndStrip(global_bpm);
- else
- glEnd();
-}
-
-
-
-
-
-void
-OpenGLSurfaceEvaluator::bgntmesh(void)
-{
-
- tmeshing = 1;
- which = 0;
- vcount = 0;
-
- if(output_triangles)
- bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLES);
- else
- glBegin((GLenum) GL_TRIANGLES);
-
-}
-
-void
-OpenGLSurfaceEvaluator::swaptmesh(void)
-{
- which = 1 - which;
-
-}
-
-void
-OpenGLSurfaceEvaluator::endtmesh(void)
-{
- tmeshing = 0;
-
-
- if(output_triangles)
- bezierPatchMeshEndStrip(global_bpm);
- else
- glEnd();
-}
-
-void
-OpenGLSurfaceEvaluator::bgntfan(void)
-{
-
- if(output_triangles)
- bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLE_FAN);
- else
- glBegin((GLenum) GL_TRIANGLE_FAN);
-
-}
-void
-OpenGLSurfaceEvaluator::endtfan(void)
-{
- if(output_triangles)
- bezierPatchMeshEndStrip(global_bpm);
- else
- glEnd();
-}
-
-void
-OpenGLSurfaceEvaluator::evalUStrip(int n_upper, REAL v_upper, REAL* upper_val, int n_lower, REAL v_lower, REAL* lower_val)
-{
-#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
-
-}
-
-
-void
-OpenGLSurfaceEvaluator::evalVStrip(int n_left, REAL u_left, REAL* left_val, int n_right, REAL u_right, REAL* right_val)
-{
-#ifdef USE_INTERNAL_EVAL
- inEvalVStrip(n_left, u_left, left_val,
- n_right, u_right, right_val);
-#else
-
-#ifdef FOR_CHRIS
- evalVStripExt(n_left, u_left, left_val,
- n_right, u_right, right_val);
- return;
-
-#endif
-
- int i,j,k,l;
- REAL botMostV[2];
- /*
- *the algorithm works by scanning from bot to top.
- *botMostV: the bot most of the remaining verteces (on both left and right).
- * it could an element of leftVerts or rightVerts.
- *i: leftVerts[i] is the first vertex to the top of botMostV on left line
- *j: rightVerts[j] is the first vertex to the top of botMostV on rightline
- */
-
- /*initialize i,j,and botMostV
- */
- if(left_val[0] <= right_val[0])
- {
- i=1;
- j=0;
-
- botMostV[0] = u_left;
- botMostV[1] = left_val[0];
- }
- else
- {
- i=0;
- j=1;
-
- botMostV[0] = u_right;
- botMostV[1] = right_val[0];
- }
-
- /*the main loop.
- *the invariance is that:
- *at the beginning of each loop, the meaning of i,j,and botMostV are
- *maintained
- */
- while(1)
- {
- if(i >= n_left) /*case1: no more in left*/
- {
- if(j<n_right-1) /*at least two vertices in right*/
- {
- bgntfan();
- coord2f(botMostV[0], botMostV[1]);
- while(j<n_right){
- coord2f(u_right, right_val[j]);
-// glNormal3fv(rightNormal[j]);
-// glVertex3fv(rightXYZ[j]);
- j++;
-
- }
- endtfan();
- }
- break; /*exit the main loop*/
- }
- else if(j>= n_right) /*case2: no more in right*/
- {
- if(i<n_left-1) /*at least two vertices in left*/
- {
- bgntfan();
- coord2f(botMostV[0], botMostV[1]);
-// glNormal3fv(botMostNormal);
-// glVertex3fv(botMostXYZ);
-
- for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
- {
- coord2f(u_left, left_val[k]);
-// glNormal3fv(leftNormal[k]);
-// glVertex3fv(leftXYZ[k]);
- }
-
- endtfan();
- }
- break; /*exit the main loop*/
- }
- else /* case3: neither is empty, plus the botMostV, there is at least one triangle to output*/
- {
- if(left_val[i] <= right_val[j])
- {
- bgntfan();
- coord2f(u_right, right_val[j]);
-// glNormal3fv(rightNormal[j]);
-// glVertex3fv(rightXYZ[j]);
-
- /*find the last k>=i such that
- *leftverts[k][0] <= rightverts[j][0]
- */
- k=i;
-
- while(k<n_left)
- {
- if(left_val[k] > right_val[j])
- break;
- k++;
-
- }
- k--;
-
-
- for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
- {
- coord2f(u_left, left_val[l]);
-// glNormal3fv(leftNormal[l]);
-// glVertex3fv(leftXYZ[l]);
-
- }
- coord2f(botMostV[0], botMostV[1]);
-// glNormal3fv(botMostNormal);
-// glVertex3fv(botMostXYZ);
-
- endtfan();
-
- /*update i and botMostV for next loop
- */
- i = k+1;
-
- botMostV[0] = u_left;
- botMostV[1] = left_val[k];
-// botMostNormal = leftNormal[k];
-// botMostXYZ = leftXYZ[k];
- }
- else /*left_val[i] > right_val[j])*/
- {
- bgntfan();
- coord2f(u_left, left_val[i]);
-// glNormal3fv(leftNormal[i]);
-// glVertex3fv(leftXYZ[i]);
-
- coord2f(botMostV[0], botMostV[1]);
-// glNormal3fv(botMostNormal);
-// glVertex3fv(botMostXYZ);
-
-
- /*find the last k>=j such that
- *rightverts[k][0] < leftverts[i][0]
- */
- k=j;
- while(k< n_right)
- {
- if(right_val[k] >= left_val[i])
- break;
- coord2f(u_right, right_val[k]);
-// glNormal3fv(rightNormal[k]);
-// glVertex3fv(rightXYZ[k]);
-
- k++;
- }
- endtfan();
-
- /*update j and botMostV for next loop
- */
- j=k;
- botMostV[0] = u_right;
- botMostV[1] = right_val[j-1];
-
-// botMostNormal = rightNormal[j-1];
-// botMostXYZ = rightXYZ[j-1];
- }
- }
- }
- //clean up
-// free(leftXYZ);
-// free(leftNormal);
-// free(rightXYZ);
-// free(rightNormal);
-#endif
-}
-
-
-void
-OpenGLSurfaceEvaluator::bgnqstrip(void)
-{
- if(output_triangles)
- bezierPatchMeshBeginStrip(global_bpm, GL_QUAD_STRIP);
- else
- glBegin((GLenum) GL_QUAD_STRIP);
-
-#ifdef STATISTICS
- STAT_num_of_quad_strips++;
-#endif
-}
-
-void
-OpenGLSurfaceEvaluator::endqstrip(void)
-{
- if(output_triangles)
- bezierPatchMeshEndStrip(global_bpm);
- else
- glEnd();
-
-}
-
-/*-------------------------------------------------------------------------
- * bgnmap2f - preamble to surface definition and evaluations
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::bgnmap2f(long)
-{
- if(output_triangles)
- {
- /*deallocate the space which may has been
- *allocated by global_bpm previously
- */
- if(global_bpm != NULL) {
- bezierPatchMeshListDelete(global_bpm);
- global_bpm = NULL;
- }
-
-
- /*
- auto_normal_flag = 1; //always output normal in callback mode.
- //we could have used the following code,
- //but Inspector doesn't have gl context
- //before it calls tessellator.
- //this way is temporary.
- */
- //NEWCALLBACK
- //if one of the two normal callback functions are set,
- //then set
- if(normalCallBackN != NULL ||
- normalCallBackData != NULL)
- auto_normal_flag = 1;
- else
- auto_normal_flag = 0;
-
- //initialize so that no maps initially
- vertex_flag = 0;
- normal_flag = 0;
- color_flag = 0;
- texcoord_flag = 0;
-
- /*
- if(glIsEnabled(GL_AUTO_NORMAL) == GL_TRUE)
- auto_normal_flag = 1;
- else if (callback_auto_normal == 1)
- auto_normal_flag = 1;
- else
- auto_normal_flag = 0;
- */
- 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);
- }
-
-}
-
-/*-------------------------------------------------------------------------
- * endmap2f - postamble to a map
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::endmap2f(void)
-{
-
- if(output_triangles)
- {
- //bezierPatchMeshListDelDeg(global_bpm);
-
- // bezierPatchMeshListEval(global_bpm);
-
- //surfcount++;
- //printf("surfcount=%i\n", surfcount);
- //if(surfcount == 8) exit(0);
-
- inBPMListEvalEM(global_bpm);
-
-
-
-/*
- global_bpm = bezierPatchMeshListReverse(global_bpm);
- {
- float *vertex_array;
- float *normal_array;
- int *length_array;
- int *type_array;
- int num_strips;
- bezierPatchMeshListCollect(global_bpm, &vertex_array, &normal_array, &length_array, &type_array, &num_strips);
- drawStrips(vertex_array, normal_array, length_array, type_array, num_strips);
- free(vertex_array);
- free(normal_array);
- free(length_array);
- free(type_array);
- }
-*/
-
- //bezierPatchMeshListPrint(global_bpm);
- //bezierPatchMeshListDraw(global_bpm);
-
-// printf("num triangles=%i\n", bezierPatchMeshListNumTriangles(global_bpm));
-
-#ifdef USE_LOD
-#else
- bezierPatchMeshListDelete(global_bpm);
- global_bpm = NULL;
-#endif
- 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
-}
-
-}
-
-/*-------------------------------------------------------------------------
- * map2f - pass a desription of a surface map
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::map2f(
- long _type,
- REAL _ulower, /* u lower domain coord */
- REAL _uupper, /* u upper domain coord */
- long _ustride, /* interpoint distance */
- long _uorder, /* parametric order */
- REAL _vlower, /* v lower domain coord */
- REAL _vupper, /* v upper domain coord */
- long _vstride, /* interpoint distance */
- long _vorder, /* parametric order */
- REAL *pts) /* control points */
-{
-#ifdef USE_INTERNAL_EVAL
- inMap2f((int) _type, (REAL) _ulower, (REAL) _uupper,
- (int) _ustride, (int) _uorder, (REAL) _vlower,
- (REAL) _vupper, (int) _vstride, (int) _vorder,
- (REAL *) pts);
-#else
-
-
-
- if(output_triangles)
- {
- if(global_bpm == NULL)
- global_bpm = bezierPatchMeshMake2(10,10);
- if(
- (global_bpm->bpatch == NULL &&
- (_type == GL_MAP2_VERTEX_3 || _type == GL_MAP2_VERTEX_4))
- ||
- (global_bpm->bpatch_normal == NULL &&
- (_type == GL_MAP2_NORMAL))
- ||
- (global_bpm->bpatch_color == NULL &&
- (_type == GL_MAP2_INDEX || _type == GL_MAP2_COLOR_4))
- ||
- (global_bpm->bpatch_texcoord == NULL &&
- (_type == GL_MAP2_TEXTURE_COORD_1 ||
- _type == GL_MAP2_TEXTURE_COORD_2 ||
- _type == GL_MAP2_TEXTURE_COORD_3 ||
- _type == GL_MAP2_TEXTURE_COORD_4 )
- ))
- {
- bezierPatchMeshPutPatch(global_bpm, (int) _type, _ulower, _uupper,(int) _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
- }
- else /*new surface patch (with multiple maps) starts*/
- {
- bezierPatchMesh *temp = bezierPatchMeshMake2(10,10);
- bezierPatchMeshPutPatch(temp, (int) _type, _ulower, _uupper,(int) _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
- global_bpm = bezierPatchMeshListInsert(global_bpm, temp);
-
- /*
- global_bpm = bezierPatchMeshListInsert(global_bpm,
- bezierPatchMeshMake(
- (int) _type, _ulower, _uupper,(int) _ustride, (int) _uorder, _vlower, _vupper, (int) _vstride, (int) _vorder, pts, 10, 10));
- */
- }
- }
- else /*not output triangles*/
- {
- glMap2f((GLenum) _type, (GLfloat) _ulower, (GLfloat) _uupper,
- (GLint) _ustride, (GLint) _uorder, (GLfloat) _vlower,
- (GLfloat) _vupper, (GLint) _vstride, (GLint) _vorder,
- (const GLfloat *) pts);
- }
-
-#endif
-}
-
-
-/*-------------------------------------------------------------------------
- * mapmesh2f - evaluate a mesh of points on lattice
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::mapmesh2f(long style, long umin, long umax, long vmin, long vmax)
-{
-#ifdef NO_EVALUATION
-return;
-#endif
-
-#ifdef USE_INTERNAL_EVAL
- inEvalMesh2((int)umin, (int)vmin, (int)umax, (int)vmax);
-#else
-
-
-
-if(output_triangles)
-{
-#ifdef USE_LOD
- bezierPatchMeshBeginStrip(global_bpm, GL_POLYGON);
- bezierPatchMeshInsertUV(global_bpm, global_grid_u0, global_grid_v0);
- bezierPatchMeshInsertUV(global_bpm, global_grid_u1, global_grid_v1);
- bezierPatchMeshInsertUV(global_bpm, (REAL)global_grid_nu, (REAL)global_grid_nv);
- bezierPatchMeshInsertUV(global_bpm, (REAL)umin, (REAL)vmin);
- bezierPatchMeshInsertUV(global_bpm, (REAL)umax, (REAL)vmax);
- bezierPatchMeshEndStrip(global_bpm);
-
-#else
-
- REAL du, dv;
- long i,j;
- if(global_grid_nu == 0 || global_grid_nv == 0)
- return; /*no points need to be output*/
- du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
- dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
-
- if(global_grid_nu >= global_grid_nv){
-
- for(i=umin; i<umax; i++){
- REAL u1 = (i==global_grid_nu)? global_grid_u1:(global_grid_u0 + i*du);
- REAL u2 = ((i+1) == global_grid_nu)? global_grid_u1: (global_grid_u0+(i+1)*du);
-
- bgnqstrip();
- for(j=vmax; j>=vmin; j--){
- REAL v1 = (j == global_grid_nv)? global_grid_v1: (global_grid_v0 +j*dv);
-
- coord2f(u1, v1);
- coord2f(u2, v1);
- }
- endqstrip();
- }
- }
- else{
-
- for(i=vmin; i<vmax; i++){
- REAL v1 = (i==global_grid_nv)? global_grid_v1:(global_grid_v0 + i*dv);
- REAL v2 = ((i+1) == global_grid_nv)? global_grid_v1: (global_grid_v0+(i+1)*dv);
-
- bgnqstrip();
- for(j=umax; j>=umin; j--){
- REAL u1 = (j == global_grid_nu)? global_grid_u1: (global_grid_u0 +j*du);
- coord2f(u1, v2);
- coord2f(u1, v1);
- }
- endqstrip();
- }
- }
-#endif
-}
-else
-{
- switch(style) {
- default:
- case N_MESHFILL:
- glEvalMesh2((GLenum) GL_FILL, (GLint) umin, (GLint) umax,
- (GLint) vmin, (GLint) vmax);
- break;
- case N_MESHLINE:
- glEvalMesh2((GLenum) GL_LINE, (GLint) umin, (GLint) umax,
- (GLint) vmin, (GLint) vmax);
- break;
- case N_MESHPOINT:
- glEvalMesh2((GLenum) GL_POINT, (GLint) umin, (GLint) umax,
- (GLint) vmin, (GLint) vmax);
- break;
- }
- }
-
-#endif
-
-#ifdef STATISTICS
- STAT_num_of_quad_strips += (umax-umin)*(vmax-vmin);
-#endif
-}
-
-/*-------------------------------------------------------------------------
- * evalcoord2f - evaluate a point on a surface
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::evalcoord2f(long, REAL u, REAL v)
-{
-
-
-#ifdef NO_EVALUATION
-return;
-#endif
-
-
- newtmeshvert(u, v);
-}
-
-/*-------------------------------------------------------------------------
- * evalpoint2i - evaluate a grid point
- *-------------------------------------------------------------------------
- */
-void
-OpenGLSurfaceEvaluator::evalpoint2i(long u, long v)
-{
-#ifdef NO_EVALUATION
-return;
-#endif
-
- newtmeshvert(u, v);
-}
-
-void
-OpenGLSurfaceEvaluator::point2i( long u, long v )
-{
-#ifdef NO_EVALUATION
-return;
-#else
-
-#ifdef USE_INTERNAL_EVAL
- inEvalPoint2( (int)u, (int)v);
-#else
-
-
-if(output_triangles)
-{
-
- REAL du, dv;
- REAL fu,fv;
- du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
- dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
- fu = (u==global_grid_nu)? global_grid_u1:(global_grid_u0 + u*du);
- fv = (v == global_grid_nv)? global_grid_v1: (global_grid_v0 +v*dv);
- coord2f(fu,fv);
-}
-else
- glEvalPoint2((GLint) u, (GLint) v);
-
-
-#endif
-
-#ifdef STATISTICS
- STAT_num_of_eval_vertices++;
-#endif
-
-#endif
-
-}
-
-void
-OpenGLSurfaceEvaluator::coord2f( REAL u, REAL v )
-{
-#ifdef NO_EVALUATION
-return;
-#else
-
-#ifdef USE_INTERNAL_EVAL
- inEvalCoord2f( u, v);
-#else
-
-
-if(output_triangles)
- bezierPatchMeshInsertUV(global_bpm, u,v);
-else
- glEvalCoord2f((GLfloat) u, (GLfloat) v);
-
-
-#endif
-
-
-#ifdef STATISTICS
- STAT_num_of_eval_vertices++;
-#endif
-
-#endif
-}
-
-void
-OpenGLSurfaceEvaluator::newtmeshvert( long u, long v )
-{
-#ifdef NO_EVALUATION
-return;
-#else
-
- if (tmeshing) {
-
- if (vcount == 2) {
- vertexCache[0]->invoke(this);
- vertexCache[1]->invoke(this);
- point2i( u, v);
-
- } else {
- vcount++;
- }
-
- vertexCache[which]->saveEvalPoint(u, v);
- which = 1 - which;
- } else {
- point2i( u, v);
- }
-#endif
-}
-
-void
-OpenGLSurfaceEvaluator::newtmeshvert( REAL u, REAL v )
-{
-#ifdef NO_EVALUATION
-return;
-#else
- if (tmeshing) {
-
-
- if (vcount == 2) {
- vertexCache[0]->invoke(this);
- vertexCache[1]->invoke(this);
- coord2f(u,v);
-
- } else {
- vcount++;
- }
-
- vertexCache[which]->saveEvalCoord(u, v);
- which = 1 - which;
- } else {
-
- coord2f( u, v);
- }
-#endif
-
-}
-
-#ifdef _WIN32
-void OpenGLSurfaceEvaluator::putCallBack(GLenum which, void (GLAPIENTRY *fn)() )
-#else
-void OpenGLSurfaceEvaluator::putCallBack(GLenum which, _GLUfuncptr fn )
-#endif
-{
- switch(which)
- {
- case GLU_NURBS_BEGIN:
- beginCallBackN = (void (GLAPIENTRY *) (GLenum)) fn;
- break;
- case GLU_NURBS_END:
- endCallBackN = (void (GLAPIENTRY *) (void)) fn;
- break;
- case GLU_NURBS_VERTEX:
- vertexCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
- break;
- case GLU_NURBS_NORMAL:
- normalCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
- break;
- case GLU_NURBS_COLOR:
- colorCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
- break;
- case GLU_NURBS_TEXTURE_COORD:
- texcoordCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
- break;
- case GLU_NURBS_BEGIN_DATA:
- beginCallBackData = (void (GLAPIENTRY *) (GLenum, void*)) fn;
- break;
- case GLU_NURBS_END_DATA:
- endCallBackData = (void (GLAPIENTRY *) (void*)) fn;
- break;
- case GLU_NURBS_VERTEX_DATA:
- vertexCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
- break;
- case GLU_NURBS_NORMAL_DATA:
- normalCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
- break;
- case GLU_NURBS_COLOR_DATA:
- colorCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
- break;
- case GLU_NURBS_TEXTURE_COORD_DATA:
- texcoordCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
- break;
-
- }
-}
-
-
-void
-OpenGLSurfaceEvaluator::beginCallBack(GLenum which, void *data)
-{
- if(beginCallBackData)
- beginCallBackData(which, data);
- else if(beginCallBackN)
- beginCallBackN(which);
-}
-
-void
-OpenGLSurfaceEvaluator::endCallBack(void *data)
-{
- if(endCallBackData)
- endCallBackData(data);
- else if(endCallBackN)
- endCallBackN();
-}
-
-void
-OpenGLSurfaceEvaluator::vertexCallBack(const GLfloat *vert, void* data)
-{
- if(vertexCallBackData)
- vertexCallBackData(vert, data);
- else if(vertexCallBackN)
- vertexCallBackN(vert);
-}
-
-
-void
-OpenGLSurfaceEvaluator::normalCallBack(const GLfloat *normal, void* data)
-{
- if(normalCallBackData)
- normalCallBackData(normal, data);
- else if(normalCallBackN)
- normalCallBackN(normal);
-}
-
-void
-OpenGLSurfaceEvaluator::colorCallBack(const GLfloat *color, void* data)
-{
- if(colorCallBackData)
- colorCallBackData(color, data);
- else if(colorCallBackN)
- colorCallBackN(color);
-}
-
-void
-OpenGLSurfaceEvaluator::texcoordCallBack(const GLfloat *texcoord, void* data)
-{
- if(texcoordCallBackData)
- texcoordCallBackData(texcoord, data);
- else if(texcoordCallBackN)
- texcoordCallBackN(texcoord);
-}
-
-
-
-
projects / reactos.git / blobdiff