1 /*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 *
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
29 */
30 /*
31 ** Author: Eric Veach, July 1994.
32 **
33 */
34
35 #include "gluos.h"
36 //#include <stddef.h>
37 #include <assert.h>
38 //#include <setjmp.h>
39 #include "memalloc.h"
40 #include "tess.h"
41 //#include "mesh.h"
42 #include "normal.h"
43 #include "sweep.h"
44 #include "tessmono.h"
45 #include "render.h"
46
47 #define GLU_TESS_DEFAULT_TOLERANCE 0.0
48 #define GLU_TESS_MESH 100112 /* void (*)(GLUmesh *mesh) */
49
50 #ifndef TRUE
51 #define TRUE 1
52 #endif
53 #ifndef FALSE
54 #define FALSE 0
55 #endif
56
noBegin(GLenum type)57 /*ARGSUSED*/ static void GLAPIENTRY noBegin( GLenum type ) {}
noEdgeFlag(GLboolean boundaryEdge)58 /*ARGSUSED*/ static void GLAPIENTRY noEdgeFlag( GLboolean boundaryEdge ) {}
noVertex(void * data)59 /*ARGSUSED*/ static void GLAPIENTRY noVertex( void *data ) {}
noEnd(void)60 /*ARGSUSED*/ static void GLAPIENTRY noEnd( void ) {}
noError(GLenum errnum)61 /*ARGSUSED*/ static void GLAPIENTRY noError( GLenum errnum ) {}
noCombine(GLdouble coords[3],void * data[4],GLfloat weight[4],void ** dataOut)62 /*ARGSUSED*/ static void GLAPIENTRY noCombine( GLdouble coords[3], void *data[4],
63 GLfloat weight[4], void **dataOut ) {}
noMesh(GLUmesh * mesh)64 /*ARGSUSED*/ static void GLAPIENTRY noMesh( GLUmesh *mesh ) {}
65
66
__gl_noBeginData(GLenum type,void * polygonData)67 /*ARGSUSED*/ void GLAPIENTRY __gl_noBeginData( GLenum type,
68 void *polygonData ) {}
__gl_noEdgeFlagData(GLboolean boundaryEdge,void * polygonData)69 /*ARGSUSED*/ void GLAPIENTRY __gl_noEdgeFlagData( GLboolean boundaryEdge,
70 void *polygonData ) {}
__gl_noVertexData(void * data,void * polygonData)71 /*ARGSUSED*/ void GLAPIENTRY __gl_noVertexData( void *data,
72 void *polygonData ) {}
__gl_noEndData(void * polygonData)73 /*ARGSUSED*/ void GLAPIENTRY __gl_noEndData( void *polygonData ) {}
__gl_noErrorData(GLenum errnum,void * polygonData)74 /*ARGSUSED*/ void GLAPIENTRY __gl_noErrorData( GLenum errnum,
75 void *polygonData ) {}
__gl_noCombineData(GLdouble coords[3],void * data[4],GLfloat weight[4],void ** outData,void * polygonData)76 /*ARGSUSED*/ void GLAPIENTRY __gl_noCombineData( GLdouble coords[3],
77 void *data[4],
78 GLfloat weight[4],
79 void **outData,
80 void *polygonData ) {}
81
82 /* Half-edges are allocated in pairs (see mesh.c) */
83 typedef struct { GLUhalfEdge e, eSym; } EdgePair;
84
85 #undef MAX
86 #define MAX(a,b) ((a) > (b) ? (a) : (b))
87 #define MAX_FAST_ALLOC (MAX(sizeof(EdgePair), \
88 MAX(sizeof(GLUvertex),sizeof(GLUface))))
89
90
91 GLUtesselator * GLAPIENTRY
gluNewTess(void)92 gluNewTess( void )
93 {
94 GLUtesselator *tess;
95
96 /* Only initialize fields which can be changed by the api. Other fields
97 * are initialized where they are used.
98 */
99
100 if (memInit( MAX_FAST_ALLOC ) == 0) {
101 return 0; /* out of memory */
102 }
103 tess = (GLUtesselator *)memAlloc( sizeof( GLUtesselator ));
104 if (tess == NULL) {
105 return 0; /* out of memory */
106 }
107
108 tess->state = T_DORMANT;
109
110 tess->normal[0] = 0;
111 tess->normal[1] = 0;
112 tess->normal[2] = 0;
113
114 tess->relTolerance = GLU_TESS_DEFAULT_TOLERANCE;
115 tess->windingRule = GLU_TESS_WINDING_ODD;
116 tess->flagBoundary = FALSE;
117 tess->boundaryOnly = FALSE;
118
119 tess->callBegin = &noBegin;
120 tess->callEdgeFlag = &noEdgeFlag;
121 tess->callVertex = &noVertex;
122 tess->callEnd = &noEnd;
123
124 tess->callError = &noError;
125 tess->callCombine = &noCombine;
126 tess->callMesh = &noMesh;
127
128 tess->callBeginData= &__gl_noBeginData;
129 tess->callEdgeFlagData= &__gl_noEdgeFlagData;
130 tess->callVertexData= &__gl_noVertexData;
131 tess->callEndData= &__gl_noEndData;
132 tess->callErrorData= &__gl_noErrorData;
133 tess->callCombineData= &__gl_noCombineData;
134
135 tess->polygonData= NULL;
136
137 return tess;
138 }
139
MakeDormant(GLUtesselator * tess)140 static void MakeDormant( GLUtesselator *tess )
141 {
142 /* Return the tessellator to its original dormant state. */
143
144 if( tess->mesh != NULL ) {
145 __gl_meshDeleteMesh( tess->mesh );
146 }
147 tess->state = T_DORMANT;
148 tess->lastEdge = NULL;
149 tess->mesh = NULL;
150 }
151
152 #define RequireState( tess, s ) if( tess->state != s ) GotoState(tess,s)
153
GotoState(GLUtesselator * tess,enum TessState newState)154 static void GotoState( GLUtesselator *tess, enum TessState newState )
155 {
156 while( tess->state != newState ) {
157 /* We change the current state one level at a time, to get to
158 * the desired state.
159 */
160 if( tess->state < newState ) {
161 switch( tess->state ) {
162 case T_DORMANT:
163 CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_POLYGON );
164 gluTessBeginPolygon( tess, NULL );
165 break;
166 case T_IN_POLYGON:
167 CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_CONTOUR );
168 gluTessBeginContour( tess );
169 break;
170 default:
171 ;
172 }
173 } else {
174 switch( tess->state ) {
175 case T_IN_CONTOUR:
176 CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_CONTOUR );
177 gluTessEndContour( tess );
178 break;
179 case T_IN_POLYGON:
180 CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_POLYGON );
181 /* gluTessEndPolygon( tess ) is too much work! */
182 MakeDormant( tess );
183 break;
184 default:
185 ;
186 }
187 }
188 }
189 }
190
191
192 void GLAPIENTRY
gluDeleteTess(GLUtesselator * tess)193 gluDeleteTess( GLUtesselator *tess )
194 {
195 RequireState( tess, T_DORMANT );
196 memFree( tess );
197 }
198
199
200 void GLAPIENTRY
gluTessProperty(GLUtesselator * tess,GLenum which,GLdouble value)201 gluTessProperty( GLUtesselator *tess, GLenum which, GLdouble value )
202 {
203 GLenum windingRule;
204
205 switch( which ) {
206 case GLU_TESS_TOLERANCE:
207 if( value < 0.0 || value > 1.0 ) break;
208 tess->relTolerance = value;
209 return;
210
211 case GLU_TESS_WINDING_RULE:
212 windingRule = (GLenum) value;
213 if( windingRule != value ) break; /* not an integer */
214
215 switch( windingRule ) {
216 case GLU_TESS_WINDING_ODD:
217 case GLU_TESS_WINDING_NONZERO:
218 case GLU_TESS_WINDING_POSITIVE:
219 case GLU_TESS_WINDING_NEGATIVE:
220 case GLU_TESS_WINDING_ABS_GEQ_TWO:
221 tess->windingRule = windingRule;
222 return;
223 default:
224 break;
225 }
226
227 case GLU_TESS_BOUNDARY_ONLY:
228 tess->boundaryOnly = (value != 0);
229 return;
230
231 default:
232 CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
233 return;
234 }
235 CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_VALUE );
236 }
237
238 /* Returns tessellator property */
239 void GLAPIENTRY
gluGetTessProperty(GLUtesselator * tess,GLenum which,GLdouble * value)240 gluGetTessProperty( GLUtesselator *tess, GLenum which, GLdouble *value )
241 {
242 switch (which) {
243 case GLU_TESS_TOLERANCE:
244 /* tolerance should be in range [0..1] */
245 assert(0.0 <= tess->relTolerance && tess->relTolerance <= 1.0);
246 *value= tess->relTolerance;
247 break;
248 case GLU_TESS_WINDING_RULE:
249 assert(tess->windingRule == GLU_TESS_WINDING_ODD ||
250 tess->windingRule == GLU_TESS_WINDING_NONZERO ||
251 tess->windingRule == GLU_TESS_WINDING_POSITIVE ||
252 tess->windingRule == GLU_TESS_WINDING_NEGATIVE ||
253 tess->windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
254 *value= tess->windingRule;
255 break;
256 case GLU_TESS_BOUNDARY_ONLY:
257 assert(tess->boundaryOnly == TRUE || tess->boundaryOnly == FALSE);
258 *value= tess->boundaryOnly;
259 break;
260 default:
261 *value= 0.0;
262 CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
263 break;
264 }
265 } /* gluGetTessProperty() */
266
267 void GLAPIENTRY
gluTessNormal(GLUtesselator * tess,GLdouble x,GLdouble y,GLdouble z)268 gluTessNormal( GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z )
269 {
270 tess->normal[0] = x;
271 tess->normal[1] = y;
272 tess->normal[2] = z;
273 }
274
275 void GLAPIENTRY
gluTessCallback(GLUtesselator * tess,GLenum which,_GLUfuncptr fn)276 gluTessCallback( GLUtesselator *tess, GLenum which, _GLUfuncptr fn)
277 {
278 switch( which ) {
279 case GLU_TESS_BEGIN:
280 tess->callBegin = (fn == NULL) ? &noBegin : (void (GLAPIENTRY *)(GLenum)) fn;
281 return;
282 case GLU_TESS_BEGIN_DATA:
283 tess->callBeginData = (fn == NULL) ?
284 &__gl_noBeginData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
285 return;
286 case GLU_TESS_EDGE_FLAG:
287 tess->callEdgeFlag = (fn == NULL) ? &noEdgeFlag :
288 (void (GLAPIENTRY *)(GLboolean)) fn;
289 /* If the client wants boundary edges to be flagged,
290 * we render everything as separate triangles (no strips or fans).
291 */
292 tess->flagBoundary = (fn != NULL);
293 return;
294 case GLU_TESS_EDGE_FLAG_DATA:
295 tess->callEdgeFlagData= (fn == NULL) ?
296 &__gl_noEdgeFlagData : (void (GLAPIENTRY *)(GLboolean, void *)) fn;
297 /* If the client wants boundary edges to be flagged,
298 * we render everything as separate triangles (no strips or fans).
299 */
300 tess->flagBoundary = (fn != NULL);
301 return;
302 case GLU_TESS_VERTEX:
303 tess->callVertex = (fn == NULL) ? &noVertex :
304 (void (GLAPIENTRY *)(void *)) fn;
305 return;
306 case GLU_TESS_VERTEX_DATA:
307 tess->callVertexData = (fn == NULL) ?
308 &__gl_noVertexData : (void (GLAPIENTRY *)(void *, void *)) fn;
309 return;
310 case GLU_TESS_END:
311 tess->callEnd = (fn == NULL) ? &noEnd : (void (GLAPIENTRY *)(void)) fn;
312 return;
313 case GLU_TESS_END_DATA:
314 tess->callEndData = (fn == NULL) ? &__gl_noEndData :
315 (void (GLAPIENTRY *)(void *)) fn;
316 return;
317 case GLU_TESS_ERROR:
318 tess->callError = (fn == NULL) ? &noError : (void (GLAPIENTRY *)(GLenum)) fn;
319 return;
320 case GLU_TESS_ERROR_DATA:
321 tess->callErrorData = (fn == NULL) ?
322 &__gl_noErrorData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
323 return;
324 case GLU_TESS_COMBINE:
325 tess->callCombine = (fn == NULL) ? &noCombine :
326 (void (GLAPIENTRY *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
327 return;
328 case GLU_TESS_COMBINE_DATA:
329 tess->callCombineData = (fn == NULL) ? &__gl_noCombineData :
330 (void (GLAPIENTRY *)(GLdouble [3],
331 void *[4],
332 GLfloat [4],
333 void **,
334 void *)) fn;
335 return;
336 case GLU_TESS_MESH:
337 tess->callMesh = (fn == NULL) ? &noMesh : (void (GLAPIENTRY *)(GLUmesh *)) fn;
338 return;
339 default:
340 CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
341 return;
342 }
343 }
344
AddVertex(GLUtesselator * tess,GLdouble coords[3],void * data)345 static int AddVertex( GLUtesselator *tess, GLdouble coords[3], void *data )
346 {
347 GLUhalfEdge *e;
348
349 e = tess->lastEdge;
350 if( e == NULL ) {
351 /* Make a self-loop (one vertex, one edge). */
352
353 e = __gl_meshMakeEdge( tess->mesh );
354 if (e == NULL) return 0;
355 if ( !__gl_meshSplice( e, e->Sym ) ) return 0;
356 } else {
357 /* Create a new vertex and edge which immediately follow e
358 * in the ordering around the left face.
359 */
360 if (__gl_meshSplitEdge( e ) == NULL) return 0;
361 e = e->Lnext;
362 }
363
364 /* The new vertex is now e->Org. */
365 e->Org->data = data;
366 e->Org->coords[0] = coords[0];
367 e->Org->coords[1] = coords[1];
368 e->Org->coords[2] = coords[2];
369
370 /* The winding of an edge says how the winding number changes as we
371 * cross from the edge''s right face to its left face. We add the
372 * vertices in such an order that a CCW contour will add +1 to
373 * the winding number of the region inside the contour.
374 */
375 e->winding = 1;
376 e->Sym->winding = -1;
377
378 tess->lastEdge = e;
379
380 return 1;
381 }
382
383
CacheVertex(GLUtesselator * tess,GLdouble coords[3],void * data)384 static void CacheVertex( GLUtesselator *tess, GLdouble coords[3], void *data )
385 {
386 CachedVertex *v = &tess->cache[tess->cacheCount];
387
388 v->data = data;
389 v->coords[0] = coords[0];
390 v->coords[1] = coords[1];
391 v->coords[2] = coords[2];
392 ++tess->cacheCount;
393 }
394
395
EmptyCache(GLUtesselator * tess)396 static int EmptyCache( GLUtesselator *tess )
397 {
398 CachedVertex *v = tess->cache;
399 CachedVertex *vLast;
400
401 tess->mesh = __gl_meshNewMesh();
402 if (tess->mesh == NULL) return 0;
403
404 for( vLast = v + tess->cacheCount; v < vLast; ++v ) {
405 if ( !AddVertex( tess, v->coords, v->data ) ) return 0;
406 }
407 tess->cacheCount = 0;
408 tess->emptyCache = FALSE;
409
410 return 1;
411 }
412
413
414 void GLAPIENTRY
gluTessVertex(GLUtesselator * tess,GLdouble coords[3],void * data)415 gluTessVertex( GLUtesselator *tess, GLdouble coords[3], void *data )
416 {
417 int i, tooLarge = FALSE;
418 GLdouble x, clamped[3];
419
420 RequireState( tess, T_IN_CONTOUR );
421
422 if( tess->emptyCache ) {
423 if ( !EmptyCache( tess ) ) {
424 CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
425 return;
426 }
427 tess->lastEdge = NULL;
428 }
429 for( i = 0; i < 3; ++i ) {
430 x = coords[i];
431 if( x < - GLU_TESS_MAX_COORD ) {
432 x = - GLU_TESS_MAX_COORD;
433 tooLarge = TRUE;
434 }
435 if( x > GLU_TESS_MAX_COORD ) {
436 x = GLU_TESS_MAX_COORD;
437 tooLarge = TRUE;
438 }
439 clamped[i] = x;
440 }
441 if( tooLarge ) {
442 CALL_ERROR_OR_ERROR_DATA( GLU_TESS_COORD_TOO_LARGE );
443 }
444
445 if( tess->mesh == NULL ) {
446 if( tess->cacheCount < TESS_MAX_CACHE ) {
447 CacheVertex( tess, clamped, data );
448 return;
449 }
450 if ( !EmptyCache( tess ) ) {
451 CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
452 return;
453 }
454 }
455 if ( !AddVertex( tess, clamped, data ) ) {
456 CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
457 }
458 }
459
460
461 void GLAPIENTRY
gluTessBeginPolygon(GLUtesselator * tess,void * data)462 gluTessBeginPolygon( GLUtesselator *tess, void *data )
463 {
464 RequireState( tess, T_DORMANT );
465
466 tess->state = T_IN_POLYGON;
467 tess->cacheCount = 0;
468 tess->emptyCache = FALSE;
469 tess->mesh = NULL;
470
471 tess->polygonData= data;
472 }
473
474
475 void GLAPIENTRY
gluTessBeginContour(GLUtesselator * tess)476 gluTessBeginContour( GLUtesselator *tess )
477 {
478 RequireState( tess, T_IN_POLYGON );
479
480 tess->state = T_IN_CONTOUR;
481 tess->lastEdge = NULL;
482 if( tess->cacheCount > 0 ) {
483 /* Just set a flag so we don't get confused by empty contours
484 * -- these can be generated accidentally with the obsolete
485 * NextContour() interface.
486 */
487 tess->emptyCache = TRUE;
488 }
489 }
490
491
492 void GLAPIENTRY
gluTessEndContour(GLUtesselator * tess)493 gluTessEndContour( GLUtesselator *tess )
494 {
495 RequireState( tess, T_IN_CONTOUR );
496 tess->state = T_IN_POLYGON;
497 }
498
499 void GLAPIENTRY
gluTessEndPolygon(GLUtesselator * tess)500 gluTessEndPolygon( GLUtesselator *tess )
501 {
502 GLUmesh *mesh;
503
504 if (setjmp(tess->env) != 0) {
505 /* come back here if out of memory */
506 CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
507 return;
508 }
509
510 RequireState( tess, T_IN_POLYGON );
511 tess->state = T_DORMANT;
512
513 if( tess->mesh == NULL ) {
514 if( ! tess->flagBoundary && tess->callMesh == &noMesh ) {
515
516 /* Try some special code to make the easy cases go quickly
517 * (eg. convex polygons). This code does NOT handle multiple contours,
518 * intersections, edge flags, and of course it does not generate
519 * an explicit mesh either.
520 */
521 if( __gl_renderCache( tess )) {
522 tess->polygonData= NULL;
523 return;
524 }
525 }
526 if ( !EmptyCache( tess ) ) longjmp(tess->env,1); /* could've used a label*/
527 }
528
529 /* Determine the polygon normal and project vertices onto the plane
530 * of the polygon.
531 */
532 __gl_projectPolygon( tess );
533
534 /* __gl_computeInterior( tess ) computes the planar arrangement specified
535 * by the given contours, and further subdivides this arrangement
536 * into regions. Each region is marked "inside" if it belongs
537 * to the polygon, according to the rule given by tess->windingRule.
538 * Each interior region is guaranteed be monotone.
539 */
540 if ( !__gl_computeInterior( tess ) ) {
541 longjmp(tess->env,1); /* could've used a label */
542 }
543
544 mesh = tess->mesh;
545 if( ! tess->fatalError ) {
546 int rc = 1;
547
548 /* If the user wants only the boundary contours, we throw away all edges
549 * except those which separate the interior from the exterior.
550 * Otherwise we tessellate all the regions marked "inside".
551 */
552 if( tess->boundaryOnly ) {
553 rc = __gl_meshSetWindingNumber( mesh, 1, TRUE );
554 } else {
555 rc = __gl_meshTessellateInterior( mesh );
556 }
557 if (rc == 0) longjmp(tess->env,1); /* could've used a label */
558
559 __gl_meshCheckMesh( mesh );
560
561 if( tess->callBegin != &noBegin || tess->callEnd != &noEnd
562 || tess->callVertex != &noVertex || tess->callEdgeFlag != &noEdgeFlag
563 || tess->callBeginData != &__gl_noBeginData
564 || tess->callEndData != &__gl_noEndData
565 || tess->callVertexData != &__gl_noVertexData
566 || tess->callEdgeFlagData != &__gl_noEdgeFlagData )
567 {
568 if( tess->boundaryOnly ) {
569 __gl_renderBoundary( tess, mesh ); /* output boundary contours */
570 } else {
571 __gl_renderMesh( tess, mesh ); /* output strips and fans */
572 }
573 }
574 if( tess->callMesh != &noMesh ) {
575
576 /* Throw away the exterior faces, so that all faces are interior.
577 * This way the user doesn't have to check the "inside" flag,
578 * and we don't need to even reveal its existence. It also leaves
579 * the freedom for an implementation to not generate the exterior
580 * faces in the first place.
581 */
582 __gl_meshDiscardExterior( mesh );
583 (*tess->callMesh)( mesh ); /* user wants the mesh itself */
584 tess->mesh = NULL;
585 tess->polygonData= NULL;
586 return;
587 }
588 }
589 __gl_meshDeleteMesh( mesh );
590 tess->polygonData= NULL;
591 tess->mesh = NULL;
592 }
593
594
595 /*XXXblythe unused function*/
596 #if 0
597 void GLAPIENTRY
598 gluDeleteMesh( GLUmesh *mesh )
599 {
600 __gl_meshDeleteMesh( mesh );
601 }
602 #endif
603
604
605
606 /*******************************************************/
607
608 /* Obsolete calls -- for backward compatibility */
609
610 void GLAPIENTRY
gluBeginPolygon(GLUtesselator * tess)611 gluBeginPolygon( GLUtesselator *tess )
612 {
613 gluTessBeginPolygon( tess, NULL );
614 gluTessBeginContour( tess );
615 }
616
617
618 /*ARGSUSED*/
619 void GLAPIENTRY
gluNextContour(GLUtesselator * tess,GLenum type)620 gluNextContour( GLUtesselator *tess, GLenum type )
621 {
622 gluTessEndContour( tess );
623 gluTessBeginContour( tess );
624 }
625
626
627 void GLAPIENTRY
gluEndPolygon(GLUtesselator * tess)628 gluEndPolygon( GLUtesselator *tess )
629 {
630 gluTessEndContour( tess );
631 gluTessEndPolygon( tess );
632 }
633