projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
OCC22391 Polylines arrays not drawn for mesh with VBO flag enabled
[occt.git] / src / OpenGl / OpenGl_polygonholes.cxx
CommitLineData
7fd59977 1/***********************************************************************
2
3FONCTION :
4----------
5File OpenGl_polygonholes :
6
7
8REMARQUES:
9----------
10
11
12HISTORIQUE DES MODIFICATIONS :
13--------------------------------
14xx-xx-xx : xxx ; Creation.
1511-03-96 : FMN ; Correction warning compilation
1601-04-96 : CAL ; Integration MINSK portage WNT
1709-08-96 : FMN ; Suppression appel glMatrixMode() avant glGetFloatv()
1821-10-96 : FMN ; Suppression LMC_COLOR fait dans OpenGl_execstruct.c
1923-12-97 : FMN ; Suppression TelSetFrontFaceAttri et TelSetBackFaceAttri
20Suppression TelBackInteriorStyle, TelBackInteriorStyleIndex
21et TelBackInteriorShadingMethod
2203-03-98 : FMN ; Suppression variable externe TglWhetherPerspective
2308-03-01 : GG ; BUC60823 Avoid crash in the normal computation method
24on confuse point.
25
26************************************************************************/
27
28/*----------------------------------------------------------------------*/
29/*
30* Includes
31*/
32
33
34#include <OpenGl_tgl_all.hxx>
35
36#include <stddef.h>
37#include <stdio.h>
38#include <stdlib.h>
39
40#include <OpenGl_cmn_varargs.hxx>
41#include <OpenGl_Extension.hxx>
42#include <OpenGl_telem_attri.hxx>
43#include <OpenGl_tsm.hxx>
44#include <OpenGl_telem.hxx>
45#include <OpenGl_telem_util.hxx>
46#include <OpenGl_telem_highlight.hxx>
47#include <OpenGl_telem_inquire.hxx>
48#include <OpenGl_telem_view.hxx>
49#include <OpenGl_tgl_funcs.hxx>
50#include <OpenGl_Memory.hxx>
51
52#ifndef WNT
53#if !defined(APIENTRY)
54# define APIENTRY
55#endif // APIENTRY
56# define STATIC static
57#else
58# include <GL\GLU.H>
59# define STATIC
60typedef double GLUcoord;
61#endif /* WNT */
62
63
64/*----------------------------------------------------------------------*/
65/*
66* Variables statiques
67*/
68
69static TStatus PolygonHolesDisplay( TSM_ELEM_DATA, Tint, cmn_key* );
70static TStatus PolygonHolesAdd( TSM_ELEM_DATA, Tint, cmn_key* );
71static TStatus PolygonHolesDelete( TSM_ELEM_DATA, Tint, cmn_key* );
72static TStatus PolygonHolesPrint( TSM_ELEM_DATA, Tint, cmn_key* );
73static TStatus PolygonHolesInquire( TSM_ELEM_DATA, Tint, cmn_key* );
74
75#if !defined(GLU_VERSION_1_2)
76#define GLUtesselator GLUtriangulatorObj
77void gluTessBeginContour();
78void gluTessBeginPolygon();
79void gluTessEndPolygon();
80void gluTessEndContour();
81#endif
82
83
84/*----------------------------------------------------------------------*/
85/*
86* Typedef
87*/
88
89struct EXTRA_VERTEX
90{
91 GLfloat vert[3];
92 int ind;
93 IMPLEMENT_MEMORY_OPERATORS
94};
95typedef EXTRA_VERTEX* extra_vertex;
96
97struct SEQ_
98{
99 Tint ts_num, ts_alloc;
100 void **tmesh_sequence;
101 GLenum triangle_type; /* FSXXX OPTI */
102 IMPLEMENT_MEMORY_OPERATORS
103};
104
105struct DISPLAY_
106{
107 Tint num_of_seq;
108 Tint num_alloc;
109 SEQ_ *seq;
110 IMPLEMENT_MEMORY_OPERATORS
111};
112
113struct TEL_POLYGON_HOLES_DATA
114{
115 Tint num_vertices; /* Number of vertices */
116 Tint facet_flag; /* TEL_FA_NONE or TEL_FA_NORMAL */
117 Tint vertex_flag; /* TEL_VT_NONE or TEL_VT_NORMAL */
118 Tint shape_flag; /* TEL_SHAPE_UNKNOWN or TEL_SHAPE_COMPLEX or
119 TEL_SHAPE_CONVEX or TEL_SHAPE_CONCAVE */
120 TEL_POINT fnormal; /* Facet normal */
121 Tint *edgevis; /* edge visibility flags */
122 tel_colour fcolour; /* Facet colour */
123 Tint num_bounds; /* number of bounds */
124 Tint *bounds; /* Array of length num_bounds */
125 tel_point vertices; /* Vertices */
126 tel_colour vcolours; /* Vertex colour values */
127 tel_point vnormals; /* Vertex normals */
128 DISPLAY_ *display; /* FSXXX plus utilise ? */
129 GLuint triangle_dl1; /* triangle display list 1 */
130 GLuint triangle_dl2; /* triangle display list 2 */
131 GLuint triangle_dl3; /* triangle display list 3 */
132};
133typedef TEL_POLYGON_HOLES_DATA* tel_polygon_holes_data;
134
135static TEL_POLYGON_HOLES_DATA polygon_holes_defaults =
136{
137 0, /* num_vertices */
138 TEL_FA_NONE, /* facet_flag */
139 TEL_VT_NONE, /* vertex_flag */
140 TEL_SHAPE_UNKNOWN, /* shape_flag */
141 {{ ( float )0.0, ( float )0.0, ( float )0.0 }}, /* fnormal */
142 0, /* edgevis */
143 0, /* fcolour */
144 0, /* num_bounds */
145 0, /* bounds */
146 0, /* vertices */
147 0, /* vcolours */
148 0, /* vnormals */
149 0, /* display */
150 0, /* triangle_dl1 */
151 0, /* triangle_dl2 */
152 0 /* triangle_dl3 */
153};
154
155static void bgntriangulate( tel_polygon_holes_data, void (APIENTRY*)() );
156static void endtriangulate(void);
157STATIC void APIENTRY out_vertex1( void* );
158STATIC void APIENTRY out_vertex2( void* );
159STATIC void APIENTRY out_vertex3( void* );
160static void draw_tmesh( tel_polygon_holes_data, Tint );
161static void draw_polygon_holes( tel_polygon_holes_data, Tint,
162 Tint, Tint );
163static void draw_edges( tel_polygon_holes_data, Tmatrix3, tel_colour, Tint,
164 TelCullMode, Tint, Tint );
165
166static TStatus (*MtdTbl[])( TSM_ELEM_DATA, Tint, cmn_key* ) =
167{
168 PolygonHolesDisplay, /* PickTraverse */
169 PolygonHolesDisplay,
170 PolygonHolesAdd,
171 PolygonHolesDelete,
172 PolygonHolesPrint,
173 PolygonHolesInquire
174};
175
176
177MtblPtr
178TelPolygonHolesInitClass( TelType* el )
179{
180 *el = TelPolygonHoles;
181 return MtdTbl;
182}
183
184static TStatus
185PolygonHolesAdd( TSM_ELEM_DATA d, Tint n, cmn_key *k )
186{
187 Tint i, j, m;
188 tel_polygon_holes_data data;
189
190 for( i = 0; i < n; i++ )
191 {
192 if( k[i]->id == NUM_FACETS_ID )
193 break;
194 }
195 if( i == n )
196 return TFailure;
197
198 if( !(k[i]->data.ldata) )
199 return TFailure;
200
201 for( j = 0; j < n; j++ )
202 {
203 if( k[j]->id == BOUNDS_DATA_ID )
204 break;
205 }
206 if( j == n )
207 return TFailure;
208
209 data = new TEL_POLYGON_HOLES_DATA();
210 if( !data )
211 return TFailure;
212
213 /* load defaults */
214 memcpy( data, &polygon_holes_defaults, sizeof(TEL_POLYGON_HOLES_DATA) );
215
216 data->num_bounds = k[i]->data.ldata;
217 data->bounds = new Tint[data->num_bounds];
218 memcpy( data->bounds, k[j]->data.pdata, data->num_bounds*sizeof(Tint) );
219
220 for( m = 0, data->num_vertices = 0; m < data->num_bounds; m++ )
221 data->num_vertices += data->bounds[m];
222
223 for( i = 0; i < n; i++ )
224 {
225 if( k[i]->id == VERTICES_ID )
226 break;
227 }
228 if( i == n )
229 return TFailure;
230
231 if( !(k[i]->data.ldata) )
232 return TFailure;
233
234 data->vertices = new TEL_POINT[data->num_vertices];
235 memcpy( data->vertices, k[i]->data.pdata, data->num_vertices*sizeof(TEL_POINT) );
236
237 for( i = 0; i < n; i++ )
238 {
239 switch( k[i]->id )
240 {
241 case FNORMALS_ID:
242 data->facet_flag = TEL_FA_NORMAL;
243 memcpy( &data->fnormal, k[i]->data.pdata, sizeof(TEL_POINT) );
244 vecnrm( data->fnormal.xyz );
245 break;
246
247 case FACET_COLOUR_VALS_ID:
248 data->fcolour = new TEL_COLOUR();
249 memcpy( data->fcolour, k[i]->data.pdata, sizeof(TEL_COLOUR) );
250 break;
251
252 case EDGE_DATA_ID:
253 data->edgevis = new Tint[data->num_vertices];
254 memcpy( data->edgevis, k[i]->data.pdata, sizeof(Tint) );
255 break;
256
257 case VERTEX_COLOUR_VALS_ID:
258 data->vcolours = new TEL_COLOUR[data->num_vertices];
259 memcpy( data->vcolours, k[i]->data.pdata, data->num_vertices*sizeof(TEL_COLOUR) );
260 break;
261
262 case VNORMALS_ID:
263 data->vertex_flag = TEL_VT_NORMAL;
264 data->vnormals = new TEL_POINT[data->num_vertices];
265 memcpy( data->vnormals, k[i]->data.pdata, data->num_vertices*sizeof(TEL_POINT) );
266 for( j = 0; j < data->num_vertices; j++ )
267 vecnrm( data->vnormals[j].xyz );
268 break;
269
270 case SHAPE_FLAG_ID:
271 data->shape_flag = k[i]->data.ldata;
272 break;
273 }
274 }
275
276 if( data->facet_flag != TEL_FA_NORMAL )
277 {
278#ifdef BUC60823
279 TelGetPolygonNormal( data->vertices, NULL,
280 data->num_vertices, data->fnormal.xyz );
281#else
282 TelGetNormal( data->vertices[0].xyz, data->vertices[1].xyz,
283 data->vertices[2].xyz, data->fnormal.xyz );
284 vecnrm( data->fnormal.xyz );
285#endif
286 }
287 ((tsm_elem_data)(d.pdata))->pdata = data;
288
289 return TSuccess;
290}
291
292
293
294static TStatus
295PolygonHolesDisplay( TSM_ELEM_DATA data, Tint n, cmn_key *k )
296{
297 Tint front_face = 1;
298 Tmatrix3 mat;
299 CMN_KEY k11, k12, k13, k14, k16, k17, k19, k111,
300 k112, k113, k117;
301
302 Tint fl=0;
303 Tint front_lighting_model, back_lighting_model;
304 Tint front_lighting_model_preserve, back_lighting_model_preserve;
305 Tint front_shading_method;
306 Tint interior_style;
307 Tint interior_index;
308 TEL_COLOUR interior_colour, back_interior_colour;
309 TEL_COLOUR point_colour, edge_colour;
310 TelCullMode face_culling_mode;
311 Tint face_distinguishing_mode;
312
313 tel_polygon_holes_data d;
314
315 k11.id = TelFaceDistinguishingMode;
316 k12.id = TelInteriorReflectanceEquation;
317 k13.id = TelInteriorShadingMethod;
318 k14.id = TelBackInteriorReflectanceEquation;
319 k16.id = TelFaceCullingMode;
320 k17.id = TelInteriorStyle;
321 k19.id = TelInteriorStyleIndex;
322 k111.id = TelInteriorColour;
323 k111.data.pdata = &interior_colour;
324 k112.id = TelBackInteriorColour;
325 k112.data.pdata = &back_interior_colour;
326 k113.id = TelPolymarkerColour;
327 k113.data.pdata = &point_colour;
328 k117.id = TelEdgeColour;
329 k117.data.pdata = &edge_colour;
330
331 TsmGetAttri( 11, &k11, &k12, &k13, &k14, &k16, &k17,
332 &k19, &k111, &k112, &k113, &k117 );
333
334 face_distinguishing_mode = k11.data.ldata;
335 front_lighting_model = k12.data.ldata;
336 front_lighting_model_preserve = k12.data.ldata;
337 front_shading_method = k13.data.ldata;
338 back_lighting_model = k14.data.ldata;
339 back_lighting_model_preserve = k14.data.ldata;
340 face_culling_mode = (TelCullMode)k16.data.ldata;
341 interior_style = k17.data.ldata;
342 interior_index = k19.data.ldata;
343
344 if( k[0]->id == TOn )
345 { /* Use highlight colours */
346 TEL_HIGHLIGHT hrep;
347 CMN_KEY kkk, kkl;
348
349 k11.id = TelHighlightIndex;
350 TsmGetAttri( 1, &k11 );
351 if( TelGetHighlightRep( TglActiveWs, k11.data.ldata, &hrep )
352 == TSuccess )
353 {
354 if( hrep.type == TelHLForcedColour )
355 {
356 edge_colour = back_interior_colour = interior_colour = hrep.col;
357 front_lighting_model = back_lighting_model = CALL_PHIGS_REFL_NONE;
358 kkk.id = TelInteriorReflectanceEquation;
359 kkk.data.ldata = CALL_PHIGS_REFL_NONE;
360 kkl.id = TelBackInteriorReflectanceEquation;
361 kkl.data.ldata = CALL_PHIGS_REFL_NONE;
362 TsmSetAttri( 2, &kkk, &kkl );
363 fl = 0;
364 }
365 else
366 {
367 edge_colour = hrep.col;
368 k[0]->id = TOff;
369 }
370 }
371 else
372 {
373 TelGetHighlightRep( TglActiveWs, 0, &hrep );
374 if( hrep.type == TelHLForcedColour )
375 {
376 back_interior_colour = interior_colour = hrep.col;
377 front_lighting_model = back_lighting_model = CALL_PHIGS_REFL_NONE;
378 kkk.id = TelInteriorReflectanceEquation;
379 kkk.data.ldata = CALL_PHIGS_REFL_NONE;
380 kkl.id = TelBackInteriorReflectanceEquation;
381 kkl.data.ldata = CALL_PHIGS_REFL_NONE;
382 TsmSetAttri( 2, &kkk, &kkl );
383 fl = 0;
384 }
385 else
386 k[0]->id = TOff;
387 }
388 }
389
390 d = (tel_polygon_holes_data)data.pdata;
391
392 glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat *) mat);
393
394 if( face_distinguishing_mode == TOn )
395 {
396 if( ( face_culling_mode == TelCullBack && front_face ) ||
397 ( face_culling_mode == TelCullNone && front_face ) )
398 {
399 glColor3fv( interior_colour.rgb );
400
401 draw_polygon_holes(d, interior_style, front_lighting_model, k[0]->id);
402 }
403 else if( ( face_culling_mode == TelCullFront && !front_face ) ||
404 ( face_culling_mode == TelCullNone && !front_face ) )
405 {
406 /* CMN_KEY k; */
407 glColor3fv( back_interior_colour.rgb );
408
409 draw_polygon_holes( d, interior_style,
410 back_lighting_model, k[0]->id);
411 }
412 }
413 else
414 {
415 if( ( face_culling_mode == TelCullBack && front_face ) ||
416 ( face_culling_mode == TelCullFront && !front_face ) ||
417 ( face_culling_mode == TelCullNone ) )
418 {
419 glColor3fv( interior_colour.rgb );
420
421 draw_polygon_holes(d, interior_style, front_lighting_model, k[0]->id);
422 }
423 }
424
425
426 /*A remplacer par le call-back GLU_EDGE_FLAG , A TESTER */
427 draw_edges( d, mat, &edge_colour, face_distinguishing_mode,
428 face_culling_mode, interior_style, interior_style );
429
430 if( fl )
431 {
432 CMN_KEY kkk, kkl;
433
434 kkk.id = TelInteriorReflectanceEquation;
435 kkk.data.ldata = front_lighting_model_preserve;
436 kkl.id = TelBackInteriorReflectanceEquation;
437 kkl.data.ldata = back_lighting_model_preserve;
438 TsmSetAttri( 2, &kkk, &kkl );
439 }
440
441 return TSuccess;
442
443}
444
445static GLUtesselator *tripak;
446
447static void
448draw_polygon_holes( tel_polygon_holes_data d,
449 Tint style, Tint u, Tint hflag )
450{
451 long i, j, m;
452
453 GLdouble xyz[3];
454
455 tel_point pvn;
456 tel_colour pfc, pvc;
457
458 pfc = d->fcolour;
459 pvc = d->vcolours;
460 pvn = d->vnormals;
461
462 if( hflag )
463 {
464 pvc = pfc = 0;
465 }
466
467 if( pfc )
468 glColor3fv( pfc->rgb );
469 if( u != CALL_PHIGS_REFL_NONE )
470 glNormal3fv( d->fnormal.xyz );
471
472 if( d->display == 0 )
473 {
474
475 if( u == CALL_PHIGS_REFL_NONE )
476 {
477 if( pvc )
478 {
479 bgntriangulate( d, (void (APIENTRY*)())out_vertex2 );
480 }
481 else
482 {
483 bgntriangulate( d, (void (APIENTRY*)())out_vertex1 );
484 }
485 }
486 else
487 {
488 if( pvn )
489 {
490 bgntriangulate( d, (void (APIENTRY*)())out_vertex3 );
491 }
492 else
493 {
494 bgntriangulate( d, (void (APIENTRY*)())out_vertex1 );
495 }
496 }
497 gluTessBeginPolygon( tripak, NULL );
498 for( i = 0, m = 0; i < d->num_bounds; i++ )
499 {
500 gluTessBeginContour( tripak );
501 for( j = 0; j < d->bounds[i]; j++ )
502 {
503 xyz[0] = d->vertices[m].xyz[0];
504 xyz[1] = d->vertices[m].xyz[1];
505 xyz[2] = d->vertices[m].xyz[2];
506#ifndef WNT
507 gluTessVertex( tripak, xyz, (void *)m );
508#else
509 {
510 GLdouble v[ 3 ];
511 v[ 0 ] = d -> vertices[ m ].xyz[ 0 ];
512 v[ 1 ] = d -> vertices[ m ].xyz[ 1 ];
513 v[ 2 ] = d -> vertices[ m ].xyz[ 2 ];
514
515 gluTessVertex ( tripak, v, ( void* )m );
516 }
517#endif /* WNT */
518 m++;
519 }
520 gluTessEndContour( tripak );
521 }
522 gluTessEndPolygon( tripak );
523 endtriangulate();
524 }
525 else
526 {
527 if( u == CALL_PHIGS_REFL_NONE )
528 {
529 if( pvc )
530 draw_tmesh( d, 2 );
531 else
532 draw_tmesh( d, 1 );
533 }
534 else
535 {
536 if( pvn )
537 draw_tmesh( d, 3 );
538 else
539 draw_tmesh( d, 1 );
540 }
541 }
542
543
544}
545
546static void
547draw_tmesh( tel_polygon_holes_data d, Tint v )
548{
549 Tint i, j, k;
550 DISPLAY_ *dis;
551 SEQ_ *s;
552
553 dis = d->display;
554 for( i = 0; i < dis->num_of_seq; i++ )
555 {
556 s = &(dis->seq[i]);
557
558 glBegin(s->triangle_type);
559 switch( v )
560 {
561 case 1:
562 {
563 for( j = 0, k = 0; j < s->ts_num; j++ )
564 {
565 if ( s->tmesh_sequence[j] < (void *)0xffff ) {
566 glVertex3fv( d->vertices[ (long)s->tmesh_sequence[ j ] ].xyz );
567 }
568 else {
569 extra_vertex b = (extra_vertex)s->tmesh_sequence[j];
570 glVertex3fv( b->vert );
571 }
572 }
573 break;
574 }
575 case 2:
576 {
577 for( j = 0, k = 0; j < s->ts_num; j++ )
578 {
579 if ( s->tmesh_sequence[j] < (void *)0xffff ) {
580 glColor3fv( d->vcolours[ (long) s->tmesh_sequence[ j ] ].rgb );
581 glVertex3fv( d->vertices[ (long) s->tmesh_sequence[ j ] ].xyz );
582 } else {
583 extra_vertex b = (extra_vertex)s->tmesh_sequence[j];
584 glColor3fv( d->vcolours[(b->ind)].rgb);
585 glVertex3fv( b->vert );
586 }
587 }
588 break;
589 }
590 case 3:
591 {
592 for( j = 0, k = 0; j < s->ts_num; j++ )
593 {
594 if ( s->tmesh_sequence[j] < (void *)0xffff) {
595 glNormal3fv( d->vnormals[ (long) s->tmesh_sequence[ j ] ].xyz );
596 glVertex3fv( d->vertices[ (long) s->tmesh_sequence[ j ] ].xyz );
597 } else {
598 extra_vertex b = (extra_vertex)s->tmesh_sequence[j];
599 glNormal3fv( d->vnormals[(b->ind)].xyz);
600 glVertex3fv( b->vert );
601 }
602 }
603 break;
604 }
605 }
606 glEnd();
607 }
608}
609
610
611static TStatus
612PolygonHolesDelete( TSM_ELEM_DATA data, Tint n, cmn_key *k )
613{
614 tel_polygon_holes_data p = (tel_polygon_holes_data)data.pdata;
615 if( p->fcolour )
616 //cmn_freemem( p->fcolour );
617 delete p->fcolour;
618 if( p->vertices )
619 //cmn_freemem( p->vertices );
620 delete[] p->vertices;
621 if( p->vcolours )
622 //cmn_freemem( p->vcolours );
623 delete[] p->vcolours;
624 if( p->vnormals )
625 //cmn_freemem( p->vnormals );
626 delete[] p->vnormals;
627 if( p->bounds )
628 //cmn_freemem( p->bounds );
629 delete[] p->bounds;
630 if( p->edgevis )
631 //cmn_freemem( p->edgevis );
632 delete[] p->edgevis;
633 if( p->display )
634 {
635 Tint i, j;
636
637 for( i = 0; i < p->display->num_of_seq; i++ )
638 {
639 if( p->display->seq[i].tmesh_sequence ) {
640 for ( j = 0; j < p->display->seq[i].ts_num ; j++ ) {
641 if ( p->display->seq[i].tmesh_sequence[j] >= (void *)0xffff )
642 free(p->display->seq[i].tmesh_sequence[j]);
643 }
644 }
645 delete[] p->display->seq[i].tmesh_sequence;
646 }
647 delete[] p->display->seq;
648 delete p->display;
649 }
650
651
652 if (data.pdata)
653 delete data.pdata;
654 return TSuccess;
655}
656
657
658static TStatus
659PolygonHolesPrint( TSM_ELEM_DATA data, Tint n, cmn_key *k )
660{
661 Tint i;
662 tel_polygon_holes_data p = (tel_polygon_holes_data)data.pdata;
663
664 fprintf( stdout, "TelPolygonHoles. Number of bounds: %d\n", p->num_bounds );
665 switch( p->shape_flag )
666 {
667 case TEL_SHAPE_UNKNOWN:
668 fprintf( stdout, "\t\tShape Flag : UNKNOWN\n" );
669 break;
670
671 case TEL_SHAPE_COMPLEX:
672 fprintf( stdout, "\t\tShape Flag : COMPLEX\n" );
673 break;
674
675 case TEL_SHAPE_CONCAVE:
676 fprintf( stdout, "\t\tShape Flag : CONCAVE\n" );
677 break;
678
679 case TEL_SHAPE_CONVEX:
680 fprintf( stdout, "\t\tShape Flag : CONVEX\n" );
681 break;
682
683 }
684 switch( p->facet_flag )
685 {
686 case TEL_FA_NONE:
687 if( p->fcolour )
688 fprintf( stdout, "\t\tFacet Flag : COLOUR\n" );
689 else
690 fprintf( stdout, "\t\tFacet Flag : NONE\n" );
691 break;
692
693 case TEL_FA_NORMAL:
694 if( p->fcolour )
695 fprintf( stdout, "\t\tFacet Flag : COLOURNORMAL\n" );
696 else
697 fprintf( stdout, "\t\tFacet Flag : NORMAL\n" );
698 break;
699 }
700 switch( p->vertex_flag )
701 {
702 case TEL_VT_NONE:
703 if( p->vcolours )
704 fprintf( stdout, "\t\tVertex Flag : COLOUR\n" );
705 else
706 fprintf( stdout, "\t\tVertex Flag : NONE\n" );
707 break;
708
709 case TEL_VT_NORMAL:
710 if( p->vcolours )
711 fprintf( stdout, "\t\tVertex Flag : COLOURNORMAL\n" );
712 else
713 fprintf( stdout, "\t\tVertex Flag : NORMAL\n" );
714 break;
715 }
716 fprintf( stdout, "\t\tFacet Normal : %g %g %g\n", p->fnormal.xyz[0],
717 p->fnormal.xyz[1],
718 p->fnormal.xyz[2] );
719 if( p->fcolour )
720 fprintf( stdout, "\t\tFacet Colour : %g %g %g\n", p->fcolour->rgb[0],
721 p->fcolour->rgb[1],
722 p->fcolour->rgb[2] );
723 else
724 fprintf( stdout, "\n\t\tFacet Colour not specified\n" );
725
726 if( p->edgevis )
727 {
728 fprintf( stdout, "\t\tEdge Visibility Data :\n" );
729 for( i = 0; i < p->num_vertices; i++ )
730 fprintf( stdout, "\t\t%d ", p->edgevis[i] );
731 fprintf( stdout, "\n" );
732 }
733
734 if( p->bounds )
735 {
736 fprintf( stdout, "\t\tBounds array :\n" );
737 for( i = 0; i < p->num_bounds; i++ )
738 fprintf( stdout, "\t\tb[%d] %d \n", i, p->bounds[i] );
739 }
740
741 if( p->vertices )
742 {
743 fprintf( stdout, "\n\t\tVertices : " );
744 for( i = 0; i < p->num_vertices; i++ )
745 fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
746 p->vertices[i].xyz[0],
747 p->vertices[i].xyz[1],
748 p->vertices[i].xyz[2] );
749 }
750
751 fprintf( stdout, "\n" );
752 if( p->vcolours )
753 {
754 fprintf( stdout, "\n\t\tVertex Colours : " );
755 for( i = 0; i < p->num_vertices; i++ )
756 fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
757 p->vcolours[i].rgb[0],
758 p->vcolours[i].rgb[1],
759 p->vcolours[i].rgb[2] );
760 }
761 else
762 fprintf( stdout, "\n\t\tVertex Colours not specified\n" );
763
764 if( p->vnormals )
765 {
766 fprintf( stdout, "\n\t\tVertex Normals : " );
767 for( i = 0; i < p->num_vertices; i++ )
768 fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
769 p->vnormals[i].xyz[0],
770 p->vnormals[i].xyz[1],
771 p->vnormals[i].xyz[2] );
772 }
773 else
774 fprintf( stdout, "\n\t\tVertex Normals not specified\n" );
775 fprintf( stdout, "\n" );
776 return TSuccess;
777}
778
779
780static TStatus
781PolygonHolesInquire( TSM_ELEM_DATA data, Tint n, cmn_key *k )
782{
783 Tint i, j;
784 Tint size_reqd=0;
785 TStatus status = TSuccess;
786 Tchar *cur_ptr = 0;
787 tel_polygon_holes_data d = (tel_polygon_holes_data)data.pdata;
788
789 if( d->fcolour )
790 size_reqd += sizeof( TEL_COLOUR );
791
792 if( d->facet_flag == TEL_FA_NORMAL )
793 size_reqd += sizeof( TEL_POINT );
794
795 if( d->edgevis )
796 size_reqd += ( d->num_vertices * sizeof( Tint ) );
797
798 size_reqd += ( d->num_bounds * sizeof( Tint ) );
799
800 size_reqd += ( d->num_vertices * sizeof( TEL_POINT ) );
801
802 if( d->vcolours )
803 size_reqd += ( d->num_vertices * sizeof( TEL_COLOUR ) );
804
805 if( d->vertex_flag == TEL_VT_NORMAL )
806 size_reqd += ( d->num_vertices * sizeof( TEL_POINT ) );
807
808 for( i = 0; i < n; i++ )
809 {
810 switch( k[i]->id )
811 {
812 case INQ_GET_SIZE_ID:
813 {
814 k[i]->data.ldata = size_reqd;
815 break;
816 }
817
818 case INQ_GET_CONTENT_ID:
819 {
820 TEL_INQ_CONTENT *c;
821 Teldata *w;
822
823 c = (tel_inq_content)k[i]->data.pdata;
824 c->act_size = size_reqd;
825 w = c->data;
826
827 cur_ptr = c->buf;
828 w->fillareaset3data.num_bounds = d->num_bounds;
829 w->fillareaset3data.shpflag = d->shape_flag;
830
831 if( d->edgevis )
832 w->fillareaset3data.edgflag = TOn;
833 else
834 w->fillareaset3data.edgflag = TOff;
835
836 if( c->size >= size_reqd )
837 {
838 if( d->facet_flag == TEL_FA_NORMAL )
839 {
840 if( d->fcolour )
841 {
842 w->fillareaset3data.faflag = TEL_FAFLAG_COLOURNORMAL;
843 w->fillareaset3data.gnormal = (tel_point)(c->buf);
844 *(w->fillareaset3data.gnormal) = d->fnormal;
845 w->fillareaset3data.facet_colour_val =
846 (tel_colour)(c->buf + sizeof( TEL_POINT ) );
847 *(w->fillareaset3data.facet_colour_val) = *(d->fcolour);
848 cur_ptr = c->buf + sizeof( TEL_POINT ) +
849 sizeof( TEL_COLOUR );
850 }
851 else
852 {
853 w->fillareaset3data.faflag = TEL_FAFLAG_NORMAL;
854 w->fillareaset3data.facet_colour_val = 0;
855 w->fillareaset3data.gnormal = (tel_point)(c->buf);
856 *(w->fillareaset3data.gnormal) = d->fnormal;
857 cur_ptr = c->buf + sizeof( TEL_POINT );
858 }
859 }
860 else
861 {
862 w->fillareaset3data.gnormal = 0;
863 if( d->fcolour )
864 {
865 w->fillareaset3data.faflag = TEL_FAFLAG_COLOUR;
866 w->fillareaset3data.facet_colour_val = (tel_colour)(c->buf );
867 *(w->fillareaset3data.facet_colour_val) = *(d->fcolour);
868 cur_ptr = c->buf + sizeof( TEL_COLOUR );
869 }
870 else
871 {
872 w->fillareaset3data.faflag = TEL_FAFLAG_NONE;
873 w->fillareaset3data.facet_colour_val = 0;
874 }
875 }
876
877 w->fillareaset3data.points = (tel_point)cur_ptr;
878 for( j = 0; j < d->num_vertices; j++ )
879 {
880 w->fillareaset3data.points[j] = d->vertices[j];
881 }
882 cur_ptr += ( d->num_vertices * sizeof( TEL_POINT ) );
883
884 if( d->edgevis )
885 {
886 w->fillareaset3data.edgvis = (Tint *)(cur_ptr);
887 memcpy( w->fillareaset3data.edgvis, d->edgevis,
888 d->num_vertices*sizeof(Tint) );
889 cur_ptr += (d->num_vertices * sizeof( Tint ) );
890 }
891
892 w->fillareaset3data.bounds = (Tint *)cur_ptr;
893 memcpy( w->fillareaset3data.bounds, d->bounds,
894 d->num_bounds*sizeof(Tint) );
895 cur_ptr += ( d->num_bounds * sizeof( Tint ) );
896
897 if( d->vertex_flag == TEL_VT_NORMAL )
898 {
899 if( d->vcolours )
900 {
901 w->fillareaset3data.vrtflag = TEL_VTFLAG_COLOURNORMAL;
902 w->fillareaset3data.vnormals = (tel_point)(cur_ptr);
903 for( j = 0; j < d->num_vertices; j++ )
904 {
905 w->fillareaset3data.vnormals[j] = d->vnormals[i];
906 }
907 cur_ptr += ( d->num_vertices * sizeof( TEL_POINT ) );
908
909 w->fillareaset3data.colours = (tel_colour)(cur_ptr);
910
911 for( j = 0; j < d->num_vertices; j++ )
912 {
913 w->fillareaset3data.colours[j] = d->vcolours[i];
914 }
915 }
916 else
917 {
918 w->fillareaset3data.vrtflag = TEL_VTFLAG_NORMAL;
919 w->fillareaset3data.colours = 0;
920 w->fillareaset3data.vnormals = (tel_point)(cur_ptr);
921
922 for( j = 0; j < d->num_vertices; j++ )
923 {
924 w->fillareaset3data.vnormals[j] = d->vnormals[i];
925 }
926 }
927 }
928 else
929 {
930 w->fillareaset3data.vnormals = 0;
931 if( d->vcolours )
932 {
933 w->fillareaset3data.vrtflag = TEL_VTFLAG_COLOUR;
934 w->fillareaset3data.colours = (tel_colour)(cur_ptr);
935 for( j = 0; j < d->num_vertices; j++ )
936 {
937 w->fillareaset3data.colours[j] = d->vcolours[i];
938 }
939 }
940 else
941 {
942 w->fillareaset3data.vrtflag = TEL_VTFLAG_NONE;
943 w->fillareaset3data.colours = 0;
944 }
945 }
946
947 status = TSuccess;
948 }
949 else
950 status = TFailure;
951 break;
952 }
953 }
954 }
955 return status;
956}
957
958
959
960#define INCREMENT 64
961static tel_polygon_holes_data DaTa;
962
963STATIC void APIENTRY
964out_bgntmesh_1 ( GLenum triangle_type )
965{
966
967 DISPLAY_ *dis;
968 dis = DaTa->display;
969
970 dis->num_of_seq++;
971 if( dis->num_alloc < dis->num_of_seq )
972 {
973 dis->num_alloc += INCREMENT;
974
975 if( dis->seq == 0 )
976 {
977 dis->seq = new SEQ_[dis->num_alloc];
978 }
979 else
980 {
981#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
982 dis->seq = (SEQ_*)realloc( dis->seq, dis->num_alloc*sizeof(SEQ_) );
983#else
984 dis->seq = cmn_resizemem<SEQ_>( dis->seq, dis->num_alloc );
985#endif
986 }
987 }
988 dis->seq[ dis->num_of_seq - 1 ].ts_num = 0;
989 dis->seq[ dis->num_of_seq - 1 ].ts_alloc = 0;
990 dis->seq[ dis->num_of_seq - 1 ].tmesh_sequence = 0;
991 dis->seq[ dis->num_of_seq - 1 ].triangle_type = triangle_type;
992 glBegin(triangle_type);
993}
994
995
996STATIC void APIENTRY
997out_vertex1( void *data )
998{
999 SEQ_ *s;
1000
1001 s = &( DaTa->display->seq[ DaTa->display->num_of_seq - 1 ] );
1002
1003 s->ts_num++;
1004 if( s->ts_alloc < s->ts_num )
1005 {
1006 s->ts_alloc += INCREMENT;
1007
1008 if( s->tmesh_sequence == 0 )
1009 {
1010 s->tmesh_sequence = new void*[s->ts_alloc];
1011 }
1012 else
1013 {
1014#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
1015 s->tmesh_sequence = (void**)realloc( s->tmesh_sequence,
1016 s->ts_alloc*sizeof(void*));
1017#else
1018 s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence,
1019 s->ts_alloc);
1020#endif
1021 }
1022 }
1023 s->tmesh_sequence[ s->ts_num - 1 ] = data;
1024
1025 if ( data < (void *)0xffff ) {
1026 long int a = (long int)data;
1027
1028 glVertex3fv( DaTa->vertices[a].xyz );
1029 }
1030 else {
1031 extra_vertex b = (extra_vertex)data;
1032
1033 glVertex3fv(b->vert);
1034 }
1035}
1036
1037STATIC void APIENTRY
1038out_vertex2( void *data )
1039{
1040 SEQ_ *s;
1041
1042 s = &( DaTa->display->seq[ DaTa->display->num_of_seq - 1 ] );
1043
1044 s->ts_num++;
1045 if( s->ts_alloc < s->ts_num )
1046 {
1047 s->ts_alloc += INCREMENT;
1048
1049 if( s->tmesh_sequence == 0 )
1050 {
1051 s->tmesh_sequence = new void*[s->ts_alloc];
1052 }
1053 else
1054 {
1055#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
1056 s->tmesh_sequence = (void**)realloc( s->tmesh_sequence,
1057 s->ts_alloc*sizeof(void*) );
1058#else
1059 s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence,
1060 s->ts_alloc );
1061#endif
1062 }
1063 }
1064 s->tmesh_sequence[ s->ts_num - 1 ] = data;
1065
1066 if ( data < (void *)0xffff ){
1067 long int a = (long int)data;
1068
1069 glColor3fv( DaTa->vcolours[a].rgb );
1070 glVertex3fv( DaTa->vertices[a].xyz );
1071 }
1072 else {
1073 extra_vertex b = (extra_vertex)data;
1074
1075 glColor3fv(DaTa->vcolours[b->ind].rgb );
1076 glVertex3fv(b->vert);
1077 }
1078}
1079
1080STATIC void APIENTRY
1081out_vertex3( void *data )
1082{
1083 SEQ_ *s;
1084
1085 s = &( DaTa->display->seq[ DaTa->display->num_of_seq - 1 ] );
1086
1087 s->ts_num++;
1088 if( s->ts_alloc < s->ts_num )
1089 {
1090 s->ts_alloc += INCREMENT;
1091
1092 if( s->tmesh_sequence == 0 )
1093 {
1094 s->tmesh_sequence = new void*[s->ts_alloc];
1095 }
1096 else
1097 {
1098#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
1099 s->tmesh_sequence = (void**)realloc( s->tmesh_sequence,
1100 s->ts_alloc*sizeof(void*) );
1101#else
1102 s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence,
1103 s->ts_alloc );
1104#endif
1105 }
1106 }
1107 s->tmesh_sequence[ s->ts_num - 1 ] = data;
1108
1109 if ( data < (void *)0xffff ) {
1110 long int a = (long int)data;
1111
1112 glNormal3fv( DaTa->vnormals[a].xyz );
1113 glVertex3fv( DaTa->vertices[a].xyz );
1114 }
1115 else {
1116 extra_vertex b = (extra_vertex) data;
1117
1118 glNormal3fv( DaTa->vnormals[b->ind].xyz );
1119 glVertex3fv(b->vert);
1120 }
1121
1122}
1123
1124STATIC void APIENTRY
1125out_combine( GLdouble coords[3], int *data,
1126 GLfloat w[4], void **dataout )
1127{
1128 extra_vertex new_vertex;
1129
1130 new_vertex = (extra_vertex) malloc(sizeof(EXTRA_VERTEX));
1131
1132 new_vertex->vert[0] = ( float )coords[0];
1133 new_vertex->vert[1] = ( float )coords[1];
1134 new_vertex->vert[2] = ( float )coords[2];
1135 new_vertex->ind = *data;
1136 *dataout = new_vertex;
1137
1138#ifdef TRACE
1139 printf("mycombine3 %e %e %e\n",
1140 new_vertex->vert[0],
1141 new_vertex->vert[1],
1142 new_vertex->vert[2],
1143 new_vertex->ind);
1144#endif
1145
1146
1147}
1148
1149
1150
1151STATIC void APIENTRY
1152out_endtmesh_1( void )
1153{
1154 glEnd();
1155}
1156
1157STATIC void APIENTRY
1158out_error_1( GLenum error )
1159{
1160 printf( "%s\n", (char *) gluErrorString(error) );
1161}
1162
1163static void
1164bgntriangulate( tel_polygon_holes_data d, void (APIENTRY*out_ver)() )
1165{
1166 DaTa = d;
1167 if( !DaTa->display )
1168 DaTa->display = new DISPLAY_();
1169
1170 tripak = gluNewTess();
1171#if defined(linux) && !defined(NOGLUfuncptr)
1172 gluTessCallback(tripak, GLU_TESS_BEGIN, (_GLUfuncptr)(out_bgntmesh_1));
1173 gluTessCallback(tripak, GLU_TESS_VERTEX, out_ver);
1174 gluTessCallback(tripak, GLU_TESS_END, out_endtmesh_1);
1175 gluTessCallback(tripak, GLU_TESS_ERROR, (_GLUfuncptr)(out_error_1));
1176 gluTessCallback(tripak, GLU_TESS_COMBINE, (_GLUfuncptr)(out_combine));
1177#else
1178 gluTessCallback(tripak, GLU_TESS_BEGIN, (void (APIENTRY*)())out_bgntmesh_1);
1179 gluTessCallback(tripak, GLU_TESS_VERTEX, (void (APIENTRY*)())out_ver);
1180 gluTessCallback(tripak, GLU_TESS_END, (void (APIENTRY*)())out_endtmesh_1);
1181 gluTessCallback(tripak, GLU_TESS_ERROR, (void (APIENTRY*)())out_error_1);
1182 gluTessCallback(tripak, GLU_TESS_COMBINE, (void (APIENTRY*)())out_combine);
1183#endif
1184
1185}
1186
1187static void
1188endtriangulate(void)
1189{
1190 DaTa = 0;
1191 gluDeleteTess(tripak);
1192}
1193
1194static void
1195draw_edges( tel_polygon_holes_data p, Tmatrix3 mat, tel_colour edge_colour,
1196 Tint face_distinguishing_mode, TelCullMode face_culling_mode,
1197 Tint interior_style, Tint back_interior_style )
1198{
1199 CMN_KEY k, k1, k2, k3, k4;
1200 Tint i, j, a, clos;
1201 Tint edge_type, line_type_preserve;
1202 Tfloat edge_width, line_width_preserve;
1203 /* Following pointers have been provided for performance improvement */
1204 Tint *bounds;
1205 tel_point pv;
1206
1207 /* OCC11904 -- Temporarily disable environment mapping */
1208 glPushAttrib(GL_ENABLE_BIT);
1209 glDisable(GL_TEXTURE_1D);
1210 glDisable(GL_TEXTURE_2D);
1211
1212
1213 bounds = p->bounds;
1214 pv = p->vertices;
1215
1216 k.id = TelEdgeFlag;
1217 TsmGetAttri( 1, &k );
1218
1219 if( !p->edgevis )
1220 if( k.data.ldata == TOff )
1221 {
1222 glPopAttrib();
1223 return;
1224 }
1225
1226 k1.id = TelPolylineWidth;
1227 k2.id = TelPolylineType;
1228 k3.id = TelEdgeType;
1229 k4.id = TelEdgeWidth;
1230
1231 TsmGetAttri( 4, &k1, &k2, &k3, &k4 );
1232
1233 line_width_preserve = k1.data.fdata;
1234 line_type_preserve = k2.data.ldata;
1235 edge_type = k3.data.ldata;
1236 edge_width = k4.data.fdata;
1237
1238 if( p->edgevis == 0 )
1239 {
1240 if( face_distinguishing_mode == TOff )
1241 {
1242 if( interior_style == TSM_SOLID || interior_style == TSM_HATCH )
1243 {
1244 if( line_width_preserve != edge_width )
1245 {
1246 k.id = TelPolylineWidth;
1247 k.data.fdata = edge_width;
1248 TsmSetAttri( 1, &k );
1249 }
1250 if( line_type_preserve != edge_type )
1251 {
1252 k.id = TelPolylineType;
1253 k.data.ldata = edge_type;
1254 TsmSetAttri( 1, &k );
1255 }
1256
1257 glColor3fv( edge_colour->rgb );
1258 if( face_culling_mode == TelCullBack )
1259 {
1260 for( i = 0, a = 0; i < p->num_bounds; i++ )
1261 {
1262 glBegin(GL_LINE_STRIP);
1263 for( clos=a, j = 0; j < bounds[i]; j++ )
1264 {
1265 glVertex3fv( pv[ a++ ].xyz );
1266 }
1267 glVertex3fv( pv[ clos ].xyz );
1268 glEnd();
1269 }
1270 }
1271 else if( face_culling_mode == TelCullFront )
1272 {
1273 for( i = 0, a = 0; i < p->num_bounds; i++ )
1274 {
1275 glBegin(GL_LINE_STRIP);
1276 for( clos=a, j = 0; j < bounds[i]; j++ )
1277 {
1278 glVertex3fv( pv[ a++ ].xyz );
1279 }
1280 glVertex3fv( pv[ clos ].xyz );
1281 glEnd();
1282 }
1283 }
1284 else
1285 {
1286 for( i = 0, a = 0; i < p->num_bounds; i++ )
1287 {
1288 glBegin(GL_LINE_STRIP);
1289 for( clos=a, j = 0; j < bounds[i]; j++ )
1290 {
1291 glVertex3fv( pv[ a++ ].xyz );
1292 }
1293 glVertex3fv( pv[ clos ].xyz );
1294 glEnd();
1295 }
1296 }
1297 if( line_width_preserve != edge_width )
1298 {
1299 k.id = TelPolylineWidth;
1300 k.data.fdata = line_width_preserve;
1301 TsmSetAttri( 1, &k );
1302 }
1303 if( line_type_preserve != edge_type )
1304 {
1305 k.id = TelPolylineType;
1306 k.data.ldata = line_type_preserve;
1307 TsmSetAttri( 1, &k );
1308 }
1309 }
1310 }
1311 else
1312 {
1313 if( ( interior_style == TSM_SOLID ||
1314 interior_style == TSM_HATCH ) ||
1315 ( back_interior_style == TSM_SOLID ||
1316 back_interior_style == TSM_HATCH ) )
1317 {
1318 if( face_culling_mode == TelCullBack )
1319 {
1320 if( interior_style == TSM_SOLID || interior_style == TSM_HATCH )
1321 {
1322 if( line_width_preserve != edge_width )
1323 {
1324 k.id = TelPolylineWidth;
1325 k.data.fdata = edge_width;
1326 TsmSetAttri( 1, &k );
1327 }
1328 if( line_type_preserve != edge_type )
1329 {
1330 k.id = TelPolylineType;
1331 k.data.ldata = edge_type;
1332 TsmSetAttri( 1, &k );
1333 }
1334 glColor3fv( edge_colour->rgb );
1335 for( i = 0, a = 0; i < p->num_bounds; i++ )
1336 {
1337 glBegin(GL_LINE_STRIP);
1338 for( clos=a, j = 0; j < bounds[i]; j++ )
1339 {
1340 glVertex3fv( pv[ a++ ].xyz );
1341 }
1342 glVertex3fv( pv[ clos ].xyz );
1343 glEnd();
1344 }
1345 if( line_width_preserve != edge_width )
1346 {
1347 k.id = TelPolylineWidth;
1348 k.data.fdata = line_width_preserve;
1349 TsmSetAttri( 1, &k );
1350 }
1351 if( line_type_preserve != edge_type )
1352 {
1353 k.id = TelPolylineType;
1354 k.data.ldata = line_type_preserve;
1355 TsmSetAttri( 1, &k );
1356 }
1357 }
1358 }
1359 else if( face_culling_mode == TelCullFront )
1360 {
1361 if( back_interior_style == TSM_SOLID ||
1362 back_interior_style == TSM_HATCH )
1363 {
1364 if( line_width_preserve != edge_width )
1365 {
1366 k.id = TelPolylineWidth;
1367 k.data.fdata = edge_width;
1368 TsmSetAttri( 1, &k );
1369 }
1370 if( line_type_preserve != edge_type )
1371 {
1372 k.id = TelPolylineType;
1373 k.data.ldata = edge_type;
1374 TsmSetAttri( 1, &k );
1375 }
1376 glColor3fv( edge_colour->rgb );
1377 for( i = 0, a = 0; i < p->num_bounds; i++ )
1378 {
1379 glBegin(GL_LINE_STRIP);
1380 for( clos=a, j = 0; j < bounds[i]; j++ )
1381 {
1382 glVertex3fv( pv[ a++ ].xyz );
1383 }
1384 glVertex3fv( pv[ clos ].xyz );
1385 glEnd();
1386 }
1387 if( line_width_preserve != edge_width )
1388 {
1389 k.id = TelPolylineWidth;
1390 k.data.fdata = line_width_preserve;
1391 TsmSetAttri( 1, &k );
1392 }
1393 if( line_type_preserve != edge_type )
1394 {
1395 k.id = TelPolylineType;
1396 k.data.ldata = line_type_preserve;
1397 TsmSetAttri( 1, &k );
1398 }
1399 }
1400 }
1401 else
1402 {
1403 if( line_width_preserve != edge_width )
1404 {
1405 k.id = TelPolylineWidth;
1406 k.data.fdata = edge_width;
1407 TsmSetAttri( 1, &k );
1408 }
1409 if( line_type_preserve != edge_type )
1410 {
1411 k.id = TelPolylineType;
1412 k.data.ldata = edge_type;
1413 TsmSetAttri( 1, &k );
1414 }
1415 glColor3fv( edge_colour->rgb );
1416 for( i = 0, a = 0; i < p->num_bounds; i++ )
1417 {
1418 glBegin(GL_LINE_STRIP);
1419 for( clos=a, j = 0; j < bounds[i]; j++ )
1420 {
1421 glVertex3fv( pv[ a++ ].xyz );
1422 }
1423 glVertex3fv( pv[ clos ].xyz );
1424 glEnd();
1425 }
1426 if( line_width_preserve != edge_width )
1427 {
1428 k.id = TelPolylineWidth;
1429 k.data.fdata = line_width_preserve;
1430 TsmSetAttri( 1, &k );
1431 }
1432 if( line_type_preserve != edge_type )
1433 {
1434 k.id = TelPolylineType;
1435 k.data.ldata = line_type_preserve;
1436 TsmSetAttri( 1, &k );
1437 }
1438 }
1439 }
1440 }
1441 }
1442 else
1443 {
1444 if( face_distinguishing_mode == TOff )
1445 {
1446 if( interior_style == TSM_SOLID || interior_style == TSM_HATCH )
1447 {
1448 if( line_width_preserve != edge_width )
1449 {
1450 k.id = TelPolylineWidth;
1451 k.data.fdata = edge_width;
1452 TsmSetAttri( 1, &k );
1453 }
1454 if( line_type_preserve != edge_type )
1455 {
1456 k.id = TelPolylineType;
1457 k.data.ldata = edge_type;
1458 TsmSetAttri( 1, &k );
1459 }
1460
1461 glColor3fv( edge_colour->rgb );
1462 if( face_culling_mode == TelCullBack )
1463 {
1464 glBegin(GL_LINES);
1465 for( i = 0, j = 0; i < p->num_bounds; i++ )
1466 {
1467 for( a = 0; a < bounds[i]-1; a++ )
1468 {
1469 if( p->edgevis[j+a] )
1470 {
1471 glVertex3fv( pv[j+a].xyz );
1472 glVertex3fv( pv[j+a+1].xyz );
1473 }
1474 }
1475 if( p->edgevis[j+a] )
1476 {
1477 glVertex3fv( pv[j+a].xyz );
1478 glVertex3fv( pv[j].xyz );
1479 }
1480 j += p->bounds[i];
1481 }
1482 glEnd();
1483 }
1484 else if( face_culling_mode == TelCullFront )
1485 {
1486 glBegin(GL_LINES);
1487 for( i = 0, j = 0; i < p->num_bounds; i++ )
1488 {
1489 for( a = 0; a < bounds[i]-1; a++ )
1490 {
1491 if( p->edgevis[j+a] )
1492 {
1493 glVertex3fv( pv[j+a].xyz );
1494 glVertex3fv( pv[j+a+1].xyz );
1495 }
1496 }
1497 if( p->edgevis[j+a] )
1498 {
1499 glVertex3fv( pv[j+a].xyz );
1500 glVertex3fv( pv[j].xyz );
1501 }
1502 j += p->bounds[i];
1503 }
1504 glEnd();
1505 }
1506 else
1507 {
1508 glBegin(GL_LINES);
1509 for( i = 0, j = 0; i < p->num_bounds; i++ )
1510 {
1511 for( a = 0; a < bounds[i]-1; a++ )
1512 {
1513 if( p->edgevis[j+a] )
1514 {
1515 glVertex3fv( pv[j+a].xyz );
1516 glVertex3fv( pv[j+a+1].xyz );
1517 }
1518 }
1519 if( p->edgevis[j+a] )
1520 {
1521 glVertex3fv( pv[j+a].xyz );
1522 glVertex3fv( pv[j].xyz );
1523 }
1524 j += p->bounds[i];
1525 }
1526 glEnd();
1527 }
1528 if( line_width_preserve != edge_width )
1529 {
1530 k.id = TelPolylineWidth;
1531 k.data.fdata = line_width_preserve;
1532 TsmSetAttri( 1, &k );
1533 }
1534 if( line_type_preserve != edge_type )
1535 {
1536 k.id = TelPolylineType;
1537 k.data.ldata = line_type_preserve;
1538 TsmSetAttri( 1, &k );
1539 }
1540 }
1541 }
1542 else
1543 {
1544 if( ( interior_style == TSM_SOLID ||
1545 interior_style == TSM_HATCH ) ||
1546 ( back_interior_style == TSM_SOLID ||
1547 back_interior_style == TSM_HATCH ) )
1548 {
1549 if( face_culling_mode == TelCullBack )
1550 {
1551 if( interior_style == TSM_SOLID || interior_style == TSM_HATCH )
1552 {
1553 if( line_width_preserve != edge_width )
1554 {
1555 k.id = TelPolylineWidth;
1556 k.data.fdata = edge_width;
1557 TsmSetAttri( 1, &k );
1558 }
1559 if( line_type_preserve != edge_type )
1560 {
1561 k.id = TelPolylineType;
1562 k.data.ldata = edge_type;
1563 TsmSetAttri( 1, &k );
1564 }
1565 glColor3fv( edge_colour->rgb );
1566 glBegin(GL_LINES);
1567 for( i = 0, j = 0; i < p->num_bounds; i++ )
1568 {
1569 for( a = 0; a < bounds[i]-1; a++ )
1570 {
1571 if( p->edgevis[j+a] )
1572 {
1573 glVertex3fv( pv[j+a].xyz );
1574 glVertex3fv( pv[j+a+1].xyz );
1575 }
1576 }
1577 if( p->edgevis[j+a] )
1578 {
1579 glVertex3fv( pv[j+a].xyz );
1580 glVertex3fv( pv[j].xyz );
1581 }
1582 j += p->bounds[i];
1583 }
1584 glEnd();
1585 if( line_width_preserve != edge_width )
1586 {
1587 k.id = TelPolylineWidth;
1588 k.data.fdata = line_width_preserve;
1589 TsmSetAttri( 1, &k );
1590 }
1591 if( line_type_preserve != edge_type )
1592 {
1593 k.id = TelPolylineType;
1594 k.data.ldata = line_type_preserve;
1595 TsmSetAttri( 1, &k );
1596 }
1597 }
1598 }
1599 else if( face_culling_mode == TelCullFront )
1600 {
1601 if( back_interior_style == TSM_SOLID ||
1602 back_interior_style == TSM_HATCH )
1603 {
1604 if( line_width_preserve != edge_width )
1605 {
1606 k.id = TelPolylineWidth;
1607 k.data.fdata = edge_width;
1608 TsmSetAttri( 1, &k );
1609 }
1610 if( line_type_preserve != edge_type )
1611 {
1612 k.id = TelPolylineType;
1613 k.data.ldata = edge_type;
1614 TsmSetAttri( 1, &k );
1615 }
1616 glColor3fv( edge_colour->rgb );
1617 glBegin(GL_LINES);
1618 for( i = 0, j = 0; i < p->num_bounds; i++ )
1619 {
1620 for( a = 0; a < bounds[i]-1; a++ )
1621 {
1622 if( p->edgevis[j+a] )
1623 {
1624 glVertex3fv( pv[j+a].xyz );
1625 glVertex3fv( pv[j+a+1].xyz );
1626 }
1627 }
1628 if( p->edgevis[j+a] )
1629 {
1630 glVertex3fv( pv[j+a].xyz );
1631 glVertex3fv( pv[j].xyz );
1632 }
1633 j += p->bounds[i];
1634 }
1635 glEnd();
1636 if( line_width_preserve != edge_width )
1637 {
1638 k.id = TelPolylineWidth;
1639 k.data.fdata = line_width_preserve;
1640 TsmSetAttri( 1, &k );
1641 }
1642 if( line_type_preserve != edge_type )
1643 {
1644 k.id = TelPolylineType;
1645 k.data.ldata = line_type_preserve;
1646 TsmSetAttri( 1, &k );
1647 }
1648 }
1649 }
1650 else
1651 {
1652 if( line_width_preserve != edge_width )
1653 {
1654 k.id = TelPolylineWidth;
1655 k.data.fdata = edge_width;
1656 TsmSetAttri( 1, &k );
1657 }
1658 if( line_type_preserve != edge_type )
1659 {
1660 k.id = TelPolylineType;
1661 k.data.ldata = edge_type;
1662 TsmSetAttri( 1, &k );
1663 }
1664 glColor3fv( edge_colour->rgb );
1665 for( i = 0, j = 0; i < p->num_bounds; i++ )
1666 {
1667 glBegin(GL_LINES);
1668 for( a = 0; a < bounds[i]-1; a++ )
1669 {
1670 if( p->edgevis[j+a] )
1671 {
1672 glVertex3fv( pv[j+a].xyz );
1673 glVertex3fv( pv[j+a+1].xyz );
1674 }
1675 }
1676 if( p->edgevis[j+a] )
1677 {
1678 glVertex3fv( pv[j+a].xyz );
1679 glVertex3fv( pv[j].xyz );
1680 }
1681 glEnd();
1682 j += p->bounds[i];
1683 }
1684
1685 if( line_width_preserve != edge_width )
1686 {
1687 k.id = TelPolylineWidth;
1688 k.data.fdata = line_width_preserve;
1689 TsmSetAttri( 1, &k );
1690 }
1691 if( line_type_preserve != edge_type )
1692 {
1693 k.id = TelPolylineType;
1694 k.data.ldata = line_type_preserve;
1695 TsmSetAttri( 1, &k );
1696 }
1697 }
1698 }
1699 }
1700 }
1701 glPopAttrib();
1702}
Open CASCADE Technology repository