source: trunk/src/opengl/glu/nurbs/interface/glsurfeval.h

Last change on this file was 3079, checked in by jeroen, 26 years ago

* empty log message *
File size: 14.5 KB
Line 
1/* $Id: glsurfeval.h,v 1.2 2000-03-11 09:05:03 jeroen Exp $ */
2/*
3** License Applicability. Except to the extent portions of this file are
4** made subject to an alternative license as permitted in the SGI Free
5** Software License B, Version 1.0 (the "License"), the contents of this
6** file are subject only to the provisions of the License. You may not use
7** this file except in compliance with the License. You may obtain a copy
8** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
9** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
10**
11** http://oss.sgi.com/projects/FreeB
12**
13** Note that, as provided in the License, the Software is distributed on an
14** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
15** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
16** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
17** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
18**
19** Original Code. The Original Code is: OpenGL Sample Implementation,
20** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
21** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
22** Copyright in any portions created by third parties is as indicated
23** elsewhere herein. All Rights Reserved.
24**
25** Additional Notice Provisions: The application programming interfaces
26** established by SGI in conjunction with the Original Code are The
27** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
28** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
29** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
30** Window System(R) (Version 1.3), released October 19, 1998. This software
31** was created using the OpenGL(R) version 1.2.1 Sample Implementation
32** published by SGI, but has not been independently verified as being
33** compliant with the OpenGL(R) version 1.2.1 Specification.
34*/
35
36/*
37 * glsurfeval.h
38 *
39 * $Date: 2000-03-11 09:05:03 $ $Revision: 1.2 $
40 * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/src/opengl/glu/nurbs/interface/glsurfeval.h,v 1.2 2000-03-11 09:05:03 jeroen Exp $
41 */
42
43#ifndef __gluglsurfeval_h_
44#define __gluglsurfeval_h_
45
46#include "basicsurfeval.h"
47#include "bezierPatchMesh.h" /* in case output triangles */
48#include "gl.h"
49
50class SurfaceMap;
51class OpenGLSurfaceEvaluator;
52class StoredVertex;
53
54#define TYPECOORD 1
55#define TYPEPOINT 2
56
57/* Cache up to 3 vertices from tmeshes */
58#define VERTEX_CACHE_SIZE 3
59
60/*for internal evaluator callback stuff*/
61#ifndef IN_MAX_BEZIER_ORDER
62#define IN_MAX_BEZIER_ORDER 40 /*XXX should be bigger than machine order*/
63#endif
64
65#ifndef IN_MAX_DIMENSION
66#define IN_MAX_DIMENSION 4
67#endif
68
69typedef struct surfEvalMachine{
70 REAL uprime;//cached previusly evaluated uprime.
71 REAL vprime;
72 int k; /*the dimension*/
73 REAL u1;
74 REAL u2;
75 int ustride;
76 int uorder;
77 REAL v1;
78 REAL v2;
79 int vstride;
80 int vorder;
81 REAL ctlPoints[IN_MAX_BEZIER_ORDER*IN_MAX_BEZIER_ORDER*IN_MAX_DIMENSION];
82 REAL ucoeff[IN_MAX_BEZIER_ORDER]; /*cache the polynomial values*/
83 REAL vcoeff[IN_MAX_BEZIER_ORDER];
84 REAL ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /*cache the polynomial derivatives*/
85 REAL vcoeffDeriv[IN_MAX_BEZIER_ORDER];
86} surfEvalMachine;
87
88
89
90class StoredVertex {
91public:
92 StoredVertex() { type = 0; }
93 ~StoredVertex(void) {}
94 void saveEvalCoord(REAL x, REAL y)
95 {coord[0] = x; coord[1] = y; type = TYPECOORD; }
96 void saveEvalPoint(long x, long y)
97 {point[0] = x; point[1] = y; type = TYPEPOINT; }
98 void invoke(OpenGLSurfaceEvaluator *eval);
99
100private:
101 int type;
102 REAL coord[2];
103 long point[2];
104};
105
106class OpenGLSurfaceEvaluator : public BasicSurfaceEvaluator {
107public:
108 OpenGLSurfaceEvaluator();
109 ~OpenGLSurfaceEvaluator( void );
110 void polymode( long style );
111 void range2f( long, REAL *, REAL * );
112 void domain2f( REAL, REAL, REAL, REAL );
113 void addMap( SurfaceMap * ) { }
114
115 void enable( long );
116 void disable( long );
117 void bgnmap2f( long );
118 void map2f( long, REAL, REAL, long, long,
119 REAL, REAL, long, long, REAL * );
120 void mapgrid2f( long, REAL, REAL, long, REAL, REAL );
121 void mapmesh2f( long, long, long, long, long );
122 void evalcoord2f( long, REAL, REAL );
123 void evalpoint2i( long, long );
124 void endmap2f( void );
125
126 void bgnline( void );
127 void endline( void );
128 void bgnclosedline( void );
129 void endclosedline( void );
130 void bgntmesh( void );
131 void swaptmesh( void );
132 void endtmesh( void );
133 void bgnqstrip( void );
134 void endqstrip( void );
135
136 void bgntfan( void );
137 void endtfan( void );
138 void evalUStrip(int n_upper, REAL v_upper, REAL* upper_val,
139 int n_lower, REAL v_lower, REAL* lower_val);
140 void evalVStrip(int n_left, REAL u_left, REAL* left_val,
141 int n_right, REAL u_right, REAL* right_val);
142
143 void coord2f( REAL, REAL );
144 void point2i( long, long );
145
146 void newtmeshvert( REAL, REAL );
147 void newtmeshvert( long, long );
148
149 void putCallBack(GLenum which, GLvoid (GLCALLBACK *fn)(...));
150 int get_vertices_call_back()
151 {
152 return output_triangles;
153 }
154 void put_vertices_call_back(int flag)
155 {
156 output_triangles = flag;
157 }
158
159 void put_callback_auto_normal(int flag)
160 {
161 callback_auto_normal = flag;
162 }
163
164 int get_callback_auto_normal()
165 {
166 return callback_auto_normal;
167 }
168
169 void set_callback_userData(void* data)
170 {
171 userData = data;
172 }
173
174 /**************begin for LOD_eval_list***********/
175 void LOD_eval_list(int level);
176
177
178
179
180private:
181 StoredVertex *vertexCache[VERTEX_CACHE_SIZE];
182 int tmeshing;
183 int which;
184 int vcount;
185
186 GLint gl_polygon_mode[2];/*to save and restore so that
187 *no side effect
188 */
189 bezierPatchMesh *global_bpm; //for output triangles
190 int output_triangles; //true 1 or false 0
191
192
193
194 void (GLCALLBACK *beginCallBackN) (GLenum type);
195 void (GLCALLBACK *endCallBackN) (void);
196 void (GLCALLBACK *vertexCallBackN) (const GLfloat *vert);
197 void (GLCALLBACK *normalCallBackN) (const GLfloat *normal);
198 void (GLCALLBACK *colorCallBackN) (const GLfloat *color);
199 void (GLCALLBACK *texcoordCallBackN) (const GLfloat *texcoord);
200
201 void (GLCALLBACK *beginCallBackData) (GLenum type, void* data);
202 void (GLCALLBACK *endCallBackData) (void* data);
203 void (GLCALLBACK *vertexCallBackData) (const GLfloat *vert, void* data);
204 void (GLCALLBACK *normalCallBackData) (const GLfloat *normal, void* data);
205 void (GLCALLBACK *colorCallBackData) (const GLfloat *color, void* data);
206 void (GLCALLBACK *texcoordCallBackData) (const GLfloat *texcoord, void* data);
207
208 void beginCallBack (GLenum type, void* data);
209 void endCallBack (void* data);
210 void vertexCallBack (const GLfloat *vert, void* data);
211 void normalCallBack (const GLfloat *normal, void* data);
212 void colorCallBack (const GLfloat *color, void* data);
213 void texcoordCallBack (const GLfloat *texcoord, void* data);
214
215
216 void* userData; /* the opaque pointer for Data callback functions.*/
217
218 /*LOD evaluation*/
219 void LOD_triangle(REAL A[2], REAL B[2], REAL C[2],
220 int level);
221 void LOD_eval(int num_vert, REAL* verts, int type, int level);
222
223 int LOD_eval_level; /* set by LOD_eval_list() */
224
225 /*************begin for internal evaluators*****************/
226
227 /*the following global variables are only defined in this file.
228 *They are used to cache the precomputed Bezier polynomial values.
229 *These calues may be used consecutively in which case we don't have
230 *recompute these values again.
231 */
232 int global_uorder; /*store the uorder in the previous evaluation*/
233 int global_vorder; /*store the vorder in the previous evaluation*/
234 REAL global_uprime;
235 REAL global_vprime;
236 REAL global_vprime_BV;
237 REAL global_uprime_BU;
238 int global_uorder_BV; /*store the uorder in the previous evaluation*/
239 int global_vorder_BV; /*store the vorder in the previous evaluation*/
240 int global_uorder_BU; /*store the uorder in the previous evaluation*/
241 int global_vorder_BU; /*store the vorder in the previous evaluation*/
242
243 REAL global_ucoeff[IN_MAX_BEZIER_ORDER]; /*cache the polynomial values*/
244 REAL global_vcoeff[IN_MAX_BEZIER_ORDER];
245 REAL global_ucoeffDeriv[IN_MAX_BEZIER_ORDER]; /*cache the polynomial derivatives*/
246 REAL global_vcoeffDeriv[IN_MAX_BEZIER_ORDER];
247
248 REAL global_BV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION];
249 REAL global_PBV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION];
250 REAL global_BU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION];
251 REAL global_PBU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION];
252 REAL* global_baseData;
253
254 int global_ev_k; /*the dimension*/
255 REAL global_ev_u1;
256 REAL global_ev_u2;
257 int global_ev_ustride;
258 int global_ev_uorder;
259 REAL global_ev_v1;
260 REAL global_ev_v2;
261 int global_ev_vstride;
262 int global_ev_vorder;
263 REAL global_ev_ctlPoints[IN_MAX_BEZIER_ORDER*IN_MAX_BEZIER_ORDER*IN_MAX_DIMENSION];
264
265 REAL global_grid_u0;
266 REAL global_grid_u1;
267 int global_grid_nu;
268 REAL global_grid_v0;
269 REAL global_grid_v1;
270 int global_grid_nv;
271
272/*functions*/
273 void inDoDomain2WithDerivs(int k, REAL u, REAL v,
274 REAL u1, REAL u2, int uorder,
275 REAL v1, REAL v2, int vorder,
276 REAL *baseData,
277 REAL *retPoint, REAL *retdu, REAL *retdv);
278 void inPreEvaluate(int order, REAL vprime, REAL *coeff);
279 void inPreEvaluateWithDeriv(int order, REAL vprime, REAL *coeff, REAL *coeffDeriv);
280 void inComputeFirstPartials(REAL *p, REAL *pu, REAL *pv);
281 void inComputeNormal2(REAL *pu, REAL *pv, REAL *n);
282 void inDoEvalCoord2(REAL u, REAL v,
283 REAL *retPoint, REAL *retNormal);
284 void inDoEvalCoord2NOGE(REAL u, REAL v,
285 REAL *retPoint, REAL *retNormal);
286 void inMap2f(int k,
287 REAL ulower,
288 REAL uupper,
289 int ustride,
290 int uorder,
291 REAL vlower,
292 REAL vupper,
293 int vstride,
294 int vorder,
295 REAL *ctlPoints);
296
297 void inMapGrid2f(int nu, REAL u0, REAL u1,
298 int nv, REAL v0, REAL v1);
299
300 void inEvalMesh2(int lowU, int lowV, int highU, int highV);
301 void inEvalPoint2(int i, int j);
302 void inEvalCoord2f(REAL u, REAL v);
303
304void inEvalULine(int n_points, REAL v, REAL* u_vals,
305 int stride, REAL ret_points[][3], REAL ret_normals[][3]);
306
307void inEvalVLine(int n_points, REAL u, REAL* v_vals,
308 int stride, REAL ret_points[][3], REAL ret_normals[][3]);
309
310void inEvalUStrip(int n_upper, REAL v_upper, REAL* upper_val,
311 int n_lower, REAL v_lower, REAL* lower_val
312 );
313void inEvalVStrip(int n_left, REAL u_left, REAL* left_val, int n_right, REAL u_right, REAL* right_val);
314
315void inPreEvaluateBV(int k, int uorder, int vorder, REAL vprime, REAL *baseData);
316void inPreEvaluateBU(int k, int uorder, int vorder, REAL uprime, REAL *baseData);
317void inPreEvaluateBV_intfac(REAL v )
318 {
319 inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);
320 }
321
322void inPreEvaluateBU_intfac(REAL u)
323 {
324 inPreEvaluateBU(global_ev_k, global_ev_uorder, global_ev_vorder, (u-global_ev_u1)/(global_ev_u2-global_ev_u1), global_ev_ctlPoints);
325 }
326
327void inDoDomain2WithDerivsBV(int k, REAL u, REAL v,
328 REAL u1, REAL u2, int uorder,
329 REAL v1, REAL v2, int vorder,
330 REAL *baseData,
331 REAL *retPoint, REAL* retdu, REAL *retdv);
332
333void inDoDomain2WithDerivsBU(int k, REAL u, REAL v,
334 REAL u1, REAL u2, int uorder,
335 REAL v1, REAL v2, int vorder,
336 REAL *baseData,
337 REAL *retPoint, REAL* retdu, REAL *retdv);
338
339
340void inDoEvalCoord2NOGE_BV(REAL u, REAL v,
341 REAL *retPoint, REAL *retNormal);
342
343void inDoEvalCoord2NOGE_BU(REAL u, REAL v,
344 REAL *retPoint, REAL *retNormal);
345
346void inBPMEval(bezierPatchMesh* bpm);
347void inBPMListEval(bezierPatchMesh* list);
348
349/*-------------begin for surfEvalMachine -------------*/
350surfEvalMachine em_vertex;
351surfEvalMachine em_normal;
352surfEvalMachine em_color;
353surfEvalMachine em_texcoord;
354
355int auto_normal_flag; //whether to output normla or not in callback
356 //determined by GL_AUTO_NORMAL and callback_auto_normal
357int callback_auto_normal; //GLU_CALLBACK_AUTO_NORMAL_EXT
358int vertex_flag;
359int normal_flag;
360int color_flag;
361int texcoord_flag;
362
363void inMap2fEM(int which, //0:vert,1:norm,2:color,3:tex
364 int dimension,
365 REAL ulower,
366 REAL uupper,
367 int ustride,
368 int uorder,
369 REAL vlower,
370 REAL vupper,
371 int vstride,
372 int vorder,
373 REAL *ctlPoints);
374
375void inDoDomain2WithDerivsEM(surfEvalMachine *em, REAL u, REAL v,
376 REAL *retPoint, REAL *retdu, REAL *retdv);
377void inDoDomain2EM(surfEvalMachine *em, REAL u, REAL v,
378 REAL *retPoint);
379 void inDoEvalCoord2EM(REAL u, REAL v);
380
381void inBPMEvalEM(bezierPatchMesh* bpm);
382void inBPMListEvalEM(bezierPatchMesh* list);
383
384/*-------------end for surfEvalMachine -------------*/
385
386
387 /*************end for internal evaluators*****************/
388
389};
390
391inline void StoredVertex::invoke(OpenGLSurfaceEvaluator *eval)
392{
393 switch(type) {
394 case TYPECOORD:
395 eval->coord2f(coord[0], coord[1]);
396 break;
397 case TYPEPOINT:
398 eval->point2i(point[0], point[1]);
399 break;
400 default:
401 break;
402 }
403}
404
405#endif /* __gluglsurfeval_h_ */
Note: See TracBrowser for help on using the repository browser.