ReactOS  0.4.11-dev-465-g0e6bc23
backend.cc
Go to the documentation of this file.
1 /*
2 ** License Applicability. Except to the extent portions of this file are
3 ** made subject to an alternative license as permitted in the SGI Free
4 ** Software License B, Version 1.1 (the "License"), the contents of this
5 ** file are subject only to the provisions of the License. You may not use
6 ** this file except in compliance with the License. You may obtain a copy
7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
9 **
10 ** http://oss.sgi.com/projects/FreeB
11 **
12 ** Note that, as provided in the License, the Software is distributed on an
13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
17 **
18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
21 ** Copyright in any portions created by third parties is as indicated
22 ** elsewhere herein. All Rights Reserved.
23 **
24 ** Additional Notice Provisions: The application programming interfaces
25 ** established by SGI in conjunction with the Original Code are The
26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
31 ** published by SGI, but has not been independently verified as being
32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
33 */
34 
35 /*
36  * backend.c++
37  *
38  */
39 
40 /* Bezier surface backend
41  - interprets display mode (wireframe,shaded,...)
42 */
43 //#include <stdio.h>
44 //#include "glimports.h"
45 //#include "mystdio.h"
46 #include "backend.h"
47 #include "basiccrveval.h"
48 #include "basicsurfeval.h"
49 
50 #define NOWIREFRAME
51 
52 
53 /*-------------------------------------------------------------------------
54  * bgnsurf - preamble to surface definition and evaluations
55  *-------------------------------------------------------------------------
56  */
57 void
58 Backend::bgnsurf( int wiretris, int wirequads, long nuid )
59 {
60 /*#ifndef NOWIREFRAME*/ //need this for old version
61  wireframetris = wiretris;
62  wireframequads = wirequads;
63 /*#endif*/
64 
65  /*in the spec, GLU_DISPLAY_MODE is either
66  * GLU_FILL
67  * GLU_OUTLINE_POLY
68  * GLU_OUTLINE_PATCH.
69  *In fact, GLU_FLL is has the same effect as
70  * set GL_FRONT_AND_BACK to be GL_FILL
71  * and GLU_OUTLINE_POLY is the same as set
72  * GL_FRONT_AND_BACK to be GL_LINE
73  *It is more efficient to do this once at the beginning of
74  *each surface than to do it for each primitive.
75  * The internal has more options: outline_triangle and outline_quad
76  *can be seperated. But since this is not in spec, and more importantly,
77  *this is not so useful, so we don't need to keep this option.
78  */
79 
80  surfaceEvaluator.bgnmap2f( nuid );
81 
82  if(wiretris)
84  else
86 }
87 
88 void
89 Backend::patch( REAL ulo, REAL uhi, REAL vlo, REAL vhi )
90 {
91  surfaceEvaluator.domain2f( ulo, uhi, vlo, vhi );
92 }
93 
94 void
96 {
97  surfaceEvaluator.range2f( type, from, to );
98 }
99 
100 /*-------------------------------------------------------------------------
101  * surfpts - pass a desription of a surface map
102  *-------------------------------------------------------------------------
103  */
104 void
106  long type, /* geometry, color, texture, normal */
107  REAL *pts, /* control points */
108  long ustride, /* distance to next point in u direction */
109  long vstride, /* distance to next point in v direction */
110  int uorder, /* u parametric order */
111  int vorder, /* v parametric order */
112  REAL ulo, /* u lower bound */
113  REAL uhi, /* u upper bound */
114  REAL vlo, /* v lower bound */
115  REAL vhi ) /* v upper bound */
116 {
117  surfaceEvaluator.map2f( type,ulo,uhi,ustride,uorder,vlo,vhi,vstride,vorder,pts );
118  surfaceEvaluator.enable( type );
119 }
120 
121 /*-------------------------------------------------------------------------
122  * surfgrid - define a lattice of points with origin and offset
123  *-------------------------------------------------------------------------
124  */
125 void
126 Backend::surfgrid( REAL u0, REAL u1, long nu, REAL v0, REAL v1, long nv )
127 {
128  surfaceEvaluator.mapgrid2f( nu, u0, u1, nv, v0, v1 );
129 }
130 
131 /*-------------------------------------------------------------------------
132  * surfmesh - evaluate a mesh of points on lattice
133  *-------------------------------------------------------------------------
134  */
135 void
136 Backend::surfmesh( long u, long v, long n, long m )
137 {
138 #ifndef NOWIREFRAME
139  if( wireframequads ) {
140  long v0, v1;
141  long u0f = u, u1f = u+n;
142  long v0f = v, v1f = v+m;
143  long parity = (u & 1);
144 
145  for( v0 = v0f, v1 = v0f++ ; v0<v1f; v0 = v1, v1++ ) {
147  for( long u = u0f; u<=u1f; u++ ) {
148  if( parity ) {
149  surfaceEvaluator.evalpoint2i( u, v0 );
150  surfaceEvaluator.evalpoint2i( u, v1 );
151  } else {
152  surfaceEvaluator.evalpoint2i( u, v1 );
153  surfaceEvaluator.evalpoint2i( u, v0 );
154  }
155  parity = 1 - parity;
156  }
158  }
159  } else {
160  surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m );
161  }
162 #else
163  if( wireframequads ) {
164 
165  surfaceEvaluator.mapmesh2f( N_MESHLINE, u, u+n, v, v+m );
166  } else {
167 
168  surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m );
169  }
170 #endif
171 }
172 
173 /*-------------------------------------------------------------------------
174  * endsurf - postamble to surface
175  *-------------------------------------------------------------------------
176  */
177 void
179 {
181 }
182 
183 /***************************************/
184 void
186 {
188 /*
189  if(wireframetris)
190  surfaceEvaluator.polymode( N_MESHLINE );
191  else
192  surfaceEvaluator.polymode( N_MESHFILL );
193 */
194 }
195 
196 void
198 {
200 }
201 
202 void
204 {
206 /*
207  if(wireframequads)
208  surfaceEvaluator.polymode( N_MESHLINE );
209  else
210  surfaceEvaluator.polymode( N_MESHFILL );
211 */
212 }
213 
214 void
216 {
218 }
219 
220 void
221 Backend::evalUStrip(int n_upper, REAL v_upper, REAL* upper_val,
222  int n_lower, REAL v_lower, REAL* lower_val
223  )
224 {
225  surfaceEvaluator.evalUStrip(n_upper, v_upper, upper_val,
226  n_lower, v_lower, lower_val);
227 }
228 
229 void
230 Backend::evalVStrip(int n_left, REAL u_left, REAL* left_val,
231  int n_right, REAL u_right, REAL* right_val
232  )
233 {
234  surfaceEvaluator.evalVStrip(n_left, u_left, left_val,
235  n_right, u_right, right_val);
236 }
237 
238 /***************************************/
239 
240 
241 /*-------------------------------------------------------------------------
242  * bgntmesh - preamble to a triangle mesh
243  *-------------------------------------------------------------------------
244  */
245 void
246 Backend::bgntmesh( const char * )
247 {
248 #ifndef NOWIREFRAME
249 
250  meshindex = 0; /* I think these need to be initialized to zero */
251  npts = 0;
252 
253  if( !wireframetris ) {
255  }
256 #else
257 
258  if( wireframetris ) {
261  } else {
264  }
265 #endif
266 }
267 
268 void
270 {
271  if( v->isGridVert() ) {
272  tmeshvert( v->g );
273  } else {
274  tmeshvert( v->t );
275  }
276 }
277 
278 void
280 {
281 // surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], temp, ttt);
282 #ifdef USE_OPTTT
283  surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], t->cache_point, t->cache_normal);
284 #endif
285 }
286 
287 //opt for a line with the same u.
288 void
290 {
291 #ifdef USE_OPTTT
292  surfaceEvaluator.inDoEvalCoord2NOGE_BU( t->param[0], t->param[1], t->cache_point, t->cache_normal);
293 #endif
294 }
295 
296 //opt for a line with the same v.
297 void
299 {
300 #ifdef USE_OPTTT
301  surfaceEvaluator.inDoEvalCoord2NOGE_BV( t->param[0], t->param[1], t->cache_point, t->cache_normal);
302 #endif
303 }
304 
305 void
307 {
309 }
310 
311 void
313 {
315 }
316 
317 
318 /*-------------------------------------------------------------------------
319  * tmeshvert - evaluate a point on a triangle mesh
320  *-------------------------------------------------------------------------
321  */
322 void
324 {
325 
326 #ifndef NOWIREFRAME
327  const long nuid = t->nuid;
328 #endif
329  const REAL u = t->param[0];
330  const REAL v = t->param[1];
331 
332 #ifndef NOWIREFRAME
333  npts++;
334  if( wireframetris ) {
335  if( npts >= 3 ) {
337  if( mesh[0][2] == 0 )
338  surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] );
339  else
340  surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
341  if( mesh[1][2] == 0 )
342  surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] );
343  else
344  surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
345  surfaceEvaluator.evalcoord2f( nuid, u, v );
347  }
348  mesh[meshindex][0] = u;
349  mesh[meshindex][1] = v;
350  mesh[meshindex][2] = 0;
351  mesh[meshindex][3] = nuid;
352  meshindex = (meshindex+1) % 2;
353  } else {
354  surfaceEvaluator.evalcoord2f( nuid, u, v );
355  }
356 #else
357 
358  surfaceEvaluator.evalcoord2f( 0, u, v );
359 //for uninitial memory read surfaceEvaluator.evalcoord2f( nuid, u, v );
360 #endif
361 }
362 
363 //the same as tmeshvert(trimvertex), for efficiency purpose
364 void
366 {
367 #ifndef NOWIREFRAME
368  const long nuid = 0;
369 
370  npts++;
371  if( wireframetris ) {
372  if( npts >= 3 ) {
374  if( mesh[0][2] == 0 )
375  surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] );
376  else
377  surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
378  if( mesh[1][2] == 0 )
379  surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] );
380  else
381  surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
382  surfaceEvaluator.evalcoord2f( nuid, u, v );
384  }
385  mesh[meshindex][0] = u;
386  mesh[meshindex][1] = v;
387  mesh[meshindex][2] = 0;
388  mesh[meshindex][3] = nuid;
389  meshindex = (meshindex+1) % 2;
390  } else {
391  surfaceEvaluator.evalcoord2f( nuid, u, v );
392  }
393 #else
394 
395  surfaceEvaluator.evalcoord2f( 0, u, v );
396 #endif
397 }
398 
399 /*-------------------------------------------------------------------------
400  * tmeshvert - evaluate a grid point of a triangle mesh
401  *-------------------------------------------------------------------------
402  */
403 void
405 {
406  const long u = g->gparam[0];
407  const long v = g->gparam[1];
408 
409 #ifndef NOWIREFRAME
410  npts++;
411  if( wireframetris ) {
412  if( npts >= 3 ) {
414  if( mesh[0][2] == 0 )
415  surfaceEvaluator.evalcoord2f( (long) mesh[0][3], mesh[0][0], mesh[0][1] );
416  else
417  surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
418  if( mesh[1][2] == 0 )
419  surfaceEvaluator.evalcoord2f( (long) mesh[1][3], mesh[1][0], mesh[1][1] );
420  else
421  surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
424  }
425  mesh[meshindex][0] = u;
426  mesh[meshindex][1] = v;
427  mesh[meshindex][2] = 1;
428  meshindex = (meshindex+1) % 2;
429  } else {
431  }
432 #else
434 #endif
435 }
436 
437 /*-------------------------------------------------------------------------
438  * swaptmesh - perform a swap of the triangle mesh pointers
439  *-------------------------------------------------------------------------
440  */
441 void
443 {
444 #ifndef NOWIREFRAME
445  if( wireframetris ) {
446  meshindex = 1 - meshindex;
447  } else {
449  }
450 #else
452 #endif
453 }
454 
455 /*-------------------------------------------------------------------------
456  * endtmesh - postamble to triangle mesh
457  *-------------------------------------------------------------------------
458  */
459 void
461 {
462 #ifndef NOWIREFRAME
463  if( ! wireframetris )
465 #else
467 /* surfaceEvaluator.polymode( N_MESHFILL );*/
468 #endif
469 }
470 
471 
472 /*-------------------------------------------------------------------------
473  * bgnoutline - preamble to outlined rendering
474  *-------------------------------------------------------------------------
475  */
476 void
478 {
480 }
481 
482 /*-------------------------------------------------------------------------
483  * linevert - evaluate a point on an outlined contour
484  *-------------------------------------------------------------------------
485  */
486 void
488 {
489  surfaceEvaluator.evalcoord2f( t->nuid, t->param[0], t->param[1] );
490 }
491 
492 /*-------------------------------------------------------------------------
493  * linevert - evaluate a grid point of an outlined contour
494  *-------------------------------------------------------------------------
495  */
496 void
498 {
499  surfaceEvaluator.evalpoint2i( g->gparam[0], g->gparam[1] );
500 }
501 
502 /*-------------------------------------------------------------------------
503  * endoutline - postamble to outlined rendering
504  *-------------------------------------------------------------------------
505  */
506 void
508 {
510 }
511 
512 /*-------------------------------------------------------------------------
513  * triangle - output a triangle
514  *-------------------------------------------------------------------------
515  */
516 void
518 {
519 /* bgntmesh( "spittriangle" );*/
520  bgntfan();
521  tmeshvert( a );
522  tmeshvert( b );
523  tmeshvert( c );
524  endtfan();
525 /* endtmesh();*/
526 }
527 
528 void
530 {
532 }
533 
534 void
536 {
537  curveEvaluator.domain1f( ulo, uhi );
538 }
539 
540 void
542  long type, /* geometry, color, texture, normal */
543  REAL *pts, /* control points */
544  long stride, /* distance to next point */
545  int order, /* parametric order */
546  REAL ulo, /* lower parametric bound */
547  REAL uhi ) /* upper parametric bound */
548 
549 {
550  curveEvaluator.map1f( type, ulo, uhi, stride, order, pts );
551  curveEvaluator.enable( type );
552 }
553 
554 void
555 Backend::curvgrid( REAL u0, REAL u1, long nu )
556 {
557  curveEvaluator.mapgrid1f( nu, u0, u1 );
558 }
559 
560 void
561 Backend::curvmesh( long from, long n )
562 {
563  curveEvaluator.mapmesh1f( N_MESHFILL, from, from+n );
564 }
565 
566 void
568 {
569  curveEvaluator.evalcoord1f( 0, u );
570 }
571 
572 void
574 {
576 }
577 
578 void
580 {
582 }
583 
584 void
586 {
588 }
virtual void bgntmesh(void)
void surfmesh(long, long, long, long)
Definition: backend.cc:136
virtual void enable(long)
Definition: basiccrveval.cc:61
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308
void bgncurv(void)
Definition: backend.cc:529
virtual void bgnmap2f(long)
void bgntmesh(const char *)
Definition: backend.cc:246
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
void curvpt(REAL)
Definition: backend.cc:567
void bgntfan()
Definition: backend.cc:185
int wireframetris
Definition: backend.h:105
virtual void endmap2f(void)
TrimVertex * t
void endtmesh(void)
Definition: backend.cc:460
virtual void domain2f(REAL, REAL, REAL, REAL)
void patch(REAL, REAL, REAL, REAL)
Definition: backend.cc:89
virtual void mapgrid2f(long, REAL, REAL, long, REAL, REAL)
GLfloat v0
Definition: glext.h:6061
void tmeshvertNOGE(TrimVertex *t)
Definition: backend.cc:279
int npts
Definition: backend.h:107
BasicCurveEvaluator & curveEvaluator
Definition: backend.h:48
void preEvaluateBU(REAL u)
Definition: backend.cc:306
void triangle(TrimVertex *, TrimVertex *, TrimVertex *)
Definition: backend.cc:517
virtual void evalcoord2f(long, REAL, REAL)
GLdouble GLdouble t
Definition: gl.h:2047
void curvpts(long, REAL *, long, int, REAL, REAL)
Definition: backend.cc:541
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
virtual void bgnline(void)
void preEvaluateBV(REAL v)
Definition: backend.cc:312
void tmeshvertNOGE_BV(TrimVertex *t)
Definition: backend.cc:298
void endoutline(void)
Definition: backend.cc:507
GLenum GLclampf GLint GLenum GLuint GLenum GLenum GLsizei GLenum const GLvoid GLfloat GLfloat GLfloat GLfloat GLclampd GLint GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean GLboolean GLboolean GLboolean GLint GLenum GLsizei const GLvoid GLenum GLint GLenum GLint GLint GLsizei GLint GLenum GLint GLint GLint GLint GLsizei GLenum GLsizei const GLuint GLboolean GLenum GLenum GLint GLsizei GLenum GLsizei GLenum const GLvoid GLboolean const GLboolean GLenum const GLdouble * u
Definition: glfuncs.h:88
int meshindex
Definition: backend.h:109
int wireframequads
Definition: backend.h:106
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
GLdouble u1
Definition: glext.h:8308
void tmeshvert(GridTrimVertex *)
Definition: backend.cc:269
void endsurf(void)
Definition: backend.cc:178
virtual void endqstrip(void)
#define N_MESHLINE
Definition: displaymode.h:37
virtual void inPreEvaluateBV_intfac(REAL v)=0
GLuint n
Definition: s_context.h:57
void swaptmesh(void)
Definition: backend.cc:442
long gparam[2]
Definition: gridvertex.h:40
void surfbbox(long, REAL *, REAL *)
Definition: backend.cc:95
void endtfan()
Definition: backend.cc:197
virtual void endclosedline(void)
void endcurv(void)
Definition: backend.cc:585
void endline(void)
Definition: backend.cc:579
#define N_MESHFILL
Definition: displaymode.h:36
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_BU(REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
GridVertex * g
GLboolean GLboolean g
Definition: glext.h:6204
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizei stride
Definition: glext.h:5848
void endqstrip()
Definition: backend.cc:215
virtual void enable(long)
long nuid
Definition: trimvertex.h:50
virtual void map1f(long, REAL, REAL, long, long, REAL *)
Definition: basiccrveval.cc:85
virtual void mapmesh2f(long, long, long, long, long)
virtual void mapmesh1f(long, long, long)
const GLubyte * c
Definition: glext.h:8905
virtual void domain1f(REAL, REAL)
Definition: basiccrveval.cc:45
void segment(REAL, REAL)
Definition: backend.cc:535
void bgnqstrip()
Definition: backend.cc:203
REAL mesh[3][4]
Definition: backend.h:108
virtual void endline(void)
void linevert(TrimVertex *)
Definition: backend.cc:487
void surfpts(long, REAL *, long, long, int, int, REAL, REAL, REAL, REAL)
Definition: backend.cc:105
void curvgrid(REAL, REAL, long)
Definition: backend.cc:555
BasicSurfaceEvaluator & surfaceEvaluator
Definition: backend.h:49
virtual void endtmesh(void)
void bgnoutline(void)
Definition: backend.cc:477
virtual void bgnline(void)
void curvmesh(long, long)
Definition: backend.cc:561
virtual void evalUStrip(int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)=0
const GLfloat * m
Definition: glext.h:10848
virtual void endtfan(void)
void bgnsurf(int, int, long)
Definition: backend.cc:58
const GLdouble * v
Definition: gl.h:2040
virtual void bgnclosedline(void)
virtual void inPreEvaluateBU_intfac(REAL u)=0
void bgnline(void)
Definition: backend.cc:573
virtual void range2f(long, REAL *, REAL *)
virtual void map2f(long, REAL, REAL, long, long, REAL, REAL, long, long, REAL *)
REAL param[2]
Definition: trimvertex.h:45
virtual void mapgrid1f(long, REAL, REAL)
Definition: basiccrveval.cc:93
CONST GLfloat m[16]
Definition: m_xform.h:144
virtual void polymode(long)
void surfgrid(REAL, REAL, long, REAL, REAL, long)
Definition: backend.cc:126
void evalUStrip(int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)
Definition: backend.cc:221
void evalVStrip(int n_left, REAL u_left, REAL *left_val, int n_right, REAL v_right, REAL *right_val)
Definition: backend.cc:230
void tmeshvertNOGE_BU(TrimVertex *t)
Definition: backend.cc:289
virtual void endmap1f(void)
virtual void swaptmesh(void)
virtual void endline(void)
virtual void bgnqstrip(void)
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
float REAL
Definition: types.h:41
CardRegion * from
Definition: spigame.cpp:19
virtual void bgnmap1f(long)
Definition: basiccrveval.cc:77
virtual void inDoEvalCoord2NOGE(REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
GLfloat GLfloat v1
Definition: glext.h:6062
virtual void evalpoint2i(long, long)
virtual void evalcoord1f(long, REAL)
virtual void inDoEvalCoord2NOGE_BV(REAL u, REAL v, REAL *ret_point, REAL *ret_normal)=0
virtual void bgntfan(void)