0022815: Missing delete operator for placement new
[occt.git] / src / OpenGl / OpenGl_Polygon.cxx
1 // File:      OpenGl_Polygon.cxx
2 // Created:   13 July 2011
3 // Author:    Sergey ZERCHANINOV
4 // Copyright: OPEN CASCADE 2011
5
6 #include <OpenGl_Context.hxx>
7
8 #include <OpenGl_Polygon.hxx>
9
10 #include <OpenGl_tgl_all.hxx>
11 #include <OpenGl_telem_util.hxx>
12 #include <OpenGl_TextureBox.hxx>
13 #include <OpenGl_Memory.hxx>
14
15 #include <OpenGl_AspectFace.hxx>
16 #include <OpenGl_Structure.hxx>
17
18 #include <GL/glu.h>
19
20 #if (defined(_WIN32) || defined(__WIN32__))
21   #define STATIC
22 #else
23   #define STATIC static
24 #endif
25
26 struct EXTRA_VERTEX
27 {
28   GLfloat vert[3];
29   int ind;
30   DEFINE_STANDARD_ALLOC
31 };
32 typedef EXTRA_VERTEX* extra_vertex;
33
34 struct SEQ_
35 {
36   Tint ts_num, ts_alloc;
37   void **tmesh_sequence;
38   GLenum triangle_type; /* FSXXX OPTI */
39   DEFINE_STANDARD_ALLOC
40 };
41
42 struct OPENGL_DISPLAY_PGN
43 {
44   Tint num_of_seq;
45   Tint num_alloc;
46   SEQ_ *seq;
47   DEFINE_STANDARD_ALLOC
48 };
49
50 static void bgntriangulate( const TEL_POLYGON_DATA *, void (APIENTRY*)() );
51 static void endtriangulate(void);
52
53 #ifndef GLU_VERSION_1_2
54   #define GLUtesselator GLUtriangulatorObj
55   void gluTessBeginContour();
56   void gluTessBeginPolygon();
57   void gluTessEndPolygon();
58   void gluTessEndContour();
59   #define GLU_TESS_BEGIN   100100
60   #define GLU_TESS_VERTEX  100101
61   #define GLU_TESS_END     100102
62   #define GLU_TESS_ERROR   100103
63   #define GLU_TESS_COMBINE 100105
64 #endif
65
66 /*----------------------------------------------------------------------*/
67
68 void OpenGl_Polygon::draw_polygon (const Handle(OpenGl_Workspace) &AWorkspace, Tint front_lighting_model) const
69 {
70   Tint      i;
71
72   tel_point ptr;
73   tel_point  pvn;
74   tel_colour pfc, pvc;
75   tel_texture_coord pvt;
76
77   pfc = myData.fcolour;
78   pvc = myData.vcolours;
79   pvn = myData.vnormals;
80   pvt = myData.vtexturecoord;
81
82   if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
83     pvc = pfc = NULL;
84
85   ptr = myData.vertices;
86   if ( pfc )
87     glColor3fv( pfc->rgb );
88   if ( front_lighting_model )
89     glNormal3fv( myData.fnormal.xyz );
90
91   if( myData.reverse_order ) glFrontFace( GL_CW );
92
93   if (myData.num_vertices == 3) glBegin(GL_TRIANGLES);
94   else if(myData.num_vertices == 4) glBegin(GL_QUADS);
95   else glBegin(GL_POLYGON);
96   if( front_lighting_model )
97   {
98     if( pvn )
99     {
100       if (pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
101         for( i=0; i<myData.num_vertices; i++, ptr++ )
102         {
103           glNormal3fv( pvn[i].xyz );
104           glTexCoord2fv( pvt[i].xy );
105           glVertex3fv( ptr->xyz );
106         }
107       else
108         for( i=0; i<myData.num_vertices; i++, ptr++ )
109         {
110           glNormal3fv( pvn[i].xyz );
111           glVertex3fv( ptr->xyz );
112         }      
113     }
114     else
115     {
116       for( i=0; i<myData.num_vertices; i++, ptr++ )
117       {
118         glVertex3fv( ptr->xyz );
119       }
120     }
121   }
122   else
123   {
124     if( pvc )
125     {
126       for( i=0; i<myData.num_vertices; i++, ptr++ )
127       {
128         glColor3fv( pvc[i].rgb );
129         glVertex3fv( ptr->xyz );
130       }
131     }
132     else
133     {
134       for( i=0; i<myData.num_vertices; i++, ptr++ )
135       {
136         glVertex3fv( ptr->xyz );
137       }
138     }
139   } 
140   glEnd();
141   if( myData.reverse_order ) glFrontFace( GL_CCW );
142
143 }
144
145 /*----------------------------------------------------------------------*/
146
147 /* JWR - allow varying the size */
148
149 #define INCREMENT    8
150
151 static int seq_increment = INCREMENT;
152
153 static const TEL_POLYGON_DATA *DaTa;
154 static GLUtesselator *tripak = 0;
155
156 STATIC void APIENTRY
157 out_bgntmesh( GLenum triangle_type )
158 {
159   OPENGL_DISPLAY_PGN *dis = DaTa->dsply;
160
161   dis->num_of_seq++;
162   if( dis->num_alloc < dis->num_of_seq )
163   {
164     dis->num_alloc += seq_increment;
165
166     if( dis->seq == 0 )
167     {
168       dis->seq = new SEQ_[dis->num_alloc];
169     }
170     else
171     {
172 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
173       dis->seq = (SEQ_*)realloc( dis->seq, dis->num_alloc*sizeof(SEQ_) );
174 #else
175       dis->seq = cmn_resizemem<SEQ_>( dis->seq, dis->num_alloc );
176 #endif
177     }
178   }
179   dis->seq[ dis->num_of_seq - 1 ].ts_num = 0;
180   dis->seq[ dis->num_of_seq - 1 ].ts_alloc = 0;
181   dis->seq[ dis->num_of_seq - 1 ].tmesh_sequence = 0;
182
183 #ifdef JWR_DEC_TRIFAN_BUG
184   dis->seq[ dis->num_of_seq - 1 ].triangle_type = GL_POLYGON;
185   glBegin(GL_POLYGON);
186 #else
187   dis->seq[ dis->num_of_seq - 1 ].triangle_type = triangle_type;
188   glBegin(triangle_type);
189 #endif
190 }
191
192 /*----------------------------------------------------------------------*/
193
194 STATIC void APIENTRY
195 out_vert1( void *data )
196 {
197   SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
198
199   s->ts_num++;
200   if( s->ts_alloc < s->ts_num )
201   {
202     s->ts_alloc += seq_increment;
203
204     if( s->tmesh_sequence == 0 )
205     {
206       s->tmesh_sequence = new void*[s->ts_alloc];
207     }
208     else
209     {
210 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
211       s->tmesh_sequence = (void**)realloc( s->tmesh_sequence, s->ts_alloc*sizeof(void*));
212 #else
213       s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc);
214 #endif
215     }
216   }
217   s->tmesh_sequence[ s->ts_num - 1 ] = data;
218
219
220   if ( data < (void *)0xffff ) {
221     long a = (long)data;
222
223     glVertex3fv( DaTa->vertices[a].xyz );
224   }
225   else {
226     extra_vertex b = (extra_vertex) data;
227
228     glVertex3fv( b->vert );
229   }
230
231 }
232
233 /*----------------------------------------------------------------------*/
234
235 STATIC void APIENTRY
236 out_vert2( void *data )
237 {
238   SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
239
240   s->ts_num++;
241   if( s->ts_alloc < s->ts_num )
242   {
243     s->ts_alloc += seq_increment;
244
245     if( s->tmesh_sequence == 0 )
246     {
247       s->tmesh_sequence = new void*[s->ts_alloc];
248     }
249     else
250     {
251 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
252       s->tmesh_sequence = (void**)( s->tmesh_sequence, s->ts_alloc*sizeof(void*) );
253 #else
254       s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc );
255 #endif
256     }
257   }
258   s->tmesh_sequence[ s->ts_num - 1 ] = data;
259
260   if ( data < (void *)0xffff ) {
261     long a = (long)data;
262
263     glColor3fv( DaTa->vcolours[a].rgb );
264     glVertex3fv(  DaTa->vertices[a].xyz );
265   }
266   else {
267     extra_vertex b = (extra_vertex) data;
268
269     glColor3fv( DaTa->vcolours[(b->ind)].rgb );
270     glVertex3fv( b->vert );
271   }
272 }
273
274 /*----------------------------------------------------------------------*/
275
276 STATIC void APIENTRY
277 out_vert3( void *data )
278 {
279   SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
280
281   s->ts_num++;
282   if( s->ts_alloc < s->ts_num )
283   {
284     s->ts_alloc += seq_increment;
285
286     if( s->tmesh_sequence == 0 )
287     {
288       s->tmesh_sequence = new void*[s->ts_alloc];
289     }
290     else
291     {
292 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
293       s->tmesh_sequence = (void**)realloc( s->tmesh_sequence, s->ts_alloc*sizeof(void*) );
294 #else
295       s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc );
296 #endif
297     }
298   }
299   s->tmesh_sequence[ s->ts_num - 1 ] = data;
300
301   if ( data <= (void *)0xffff ) {
302     long a = (long)data;
303
304     glNormal3fv(  DaTa->vnormals[a].xyz );
305     glVertex3fv(  DaTa->vertices[a].xyz);
306   }
307   else {
308     extra_vertex b = (extra_vertex) data;
309
310     glNormal3fv(  DaTa->vnormals[(b->ind)].xyz );
311     glVertex3fv( b->vert );
312   }
313 }
314
315 /*----------------------------------------------------------------------*/
316
317 STATIC void APIENTRY
318 mycombine( GLdouble coords[3], int *data, GLfloat w[4], void **dataout)
319 {
320   extra_vertex new_vertex =  (extra_vertex) malloc(sizeof(EXTRA_VERTEX));
321
322   new_vertex->vert[0] = ( float )coords[0];
323   new_vertex->vert[1] = ( float )coords[1];
324   new_vertex->vert[2] = ( float )coords[2];
325   new_vertex->ind =   *data;
326   *dataout = new_vertex;
327 }
328
329 /*----------------------------------------------------------------------*/
330
331 STATIC void APIENTRY
332 out_endtmesh( void )
333 {
334   glEnd();
335 }
336
337 /*----------------------------------------------------------------------*/
338
339 STATIC void APIENTRY
340 out_error( GLenum error )
341 {
342   printf( "POLYGON : %s\n", (char *) gluErrorString(error) );
343 }
344
345 /*----------------------------------------------------------------------*/
346
347 static void
348 bgntriangulate(const TEL_POLYGON_DATA *d, void ( APIENTRY * out_ver)() )
349 {
350   DaTa = d;
351
352   tripak = gluNewTess();
353
354 #if defined(linux) && !defined(NOGLUfuncptr)
355   gluTessCallback( tripak, GLU_TESS_BEGIN, (_GLUfuncptr)(out_bgntmesh) );
356   gluTessCallback( tripak, GLU_TESS_VERTEX, out_ver );
357   gluTessCallback( tripak, GLU_TESS_END, out_endtmesh );
358   gluTessCallback( tripak, GLU_TESS_ERROR, (_GLUfuncptr)(out_error) );
359   gluTessCallback( tripak, GLU_TESS_COMBINE, (_GLUfuncptr)(mycombine) );
360 #else 
361   gluTessCallback( tripak, GLU_TESS_BEGIN, (void (APIENTRY*)())out_bgntmesh );
362   gluTessCallback( tripak, GLU_TESS_VERTEX, (void (APIENTRY*)())out_ver );
363   gluTessCallback( tripak, GLU_TESS_END, (void (APIENTRY*)())out_endtmesh );
364   gluTessCallback( tripak, GLU_TESS_ERROR, (void (APIENTRY*)())out_error );
365   gluTessCallback( tripak, GLU_TESS_COMBINE, (void (APIENTRY*)())mycombine );
366 #endif
367 }
368
369 /*----------------------------------------------------------------------*/
370
371 static void
372 endtriangulate()
373 {
374   DaTa = 0;
375   gluDeleteTess(tripak);
376 }
377
378 /*----------------------------------------------------------------------*/
379
380 void OpenGl_Polygon::draw_polygon_concav (const Handle(OpenGl_Workspace) &AWorkspace, Tint front_lighting_model) const
381 {
382   long       i;
383
384   tel_point  pvn;
385   tel_point  ptr;
386   tel_colour pfc, pvc;
387   GLdouble  xyz[3];
388
389   pfc = myData.fcolour;
390   pvc = myData.vcolours;
391   pvn = myData.vnormals;
392
393   if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
394     pvc = pfc = NULL;
395
396   ptr = myData.vertices;
397   DaTa = &myData;
398
399   if ( pfc )
400     glColor3fv( pfc->rgb );
401   if ( front_lighting_model )
402     glNormal3fv( myData.fnormal.xyz );
403
404   if( myData.reverse_order ) glFrontFace( GL_CW );
405
406   if( !myData.dsply )
407   {
408     if( front_lighting_model )
409     {
410       if( pvn )
411       {
412         bgntriangulate(&myData, (void (APIENTRY*)())out_vert3);
413       }
414       else
415       {
416         bgntriangulate(&myData, (void (APIENTRY*)())out_vert1);
417       }
418     }
419     else
420     {
421       if( pvc )
422       {
423         bgntriangulate(&myData, (void (APIENTRY*)())out_vert2);
424       }
425       else
426       {
427         bgntriangulate(&myData, (void (APIENTRY*)())out_vert1);
428       }
429     }
430     gluTessBeginPolygon( tripak, NULL );
431     gluTessBeginContour( tripak);
432
433     for( i=0; i<myData.num_vertices; i++, ptr++ )
434     {
435       xyz[0] = ptr->xyz[0];
436       xyz[1] = ptr->xyz[1];
437       xyz[2] = ptr->xyz[2];    
438 #ifndef WNT
439       gluTessVertex( tripak, xyz,(void * ) i );
440 #else
441       {
442         double v[ 3 ] = {ptr -> xyz[ 0 ], ptr -> xyz[ 1 ], ptr -> xyz[ 2 ]};
443         gluTessVertex (  tripak,  v, ( void* )i  );
444       }
445 #endif  /* WNT */
446     }
447     gluTessEndContour( tripak );
448     gluTessEndPolygon( tripak );
449     endtriangulate();
450   } 
451   else 
452   {
453     if( front_lighting_model )
454     {
455       draw_tmesh( pvn? 3 : 1 );
456     }
457     else
458     {
459       draw_tmesh( pvc? 2 : 1 );
460     }
461   }
462
463   if( myData.reverse_order ) glFrontFace( GL_CCW );
464 }
465
466 /*----------------------------------------------------------------------*/
467
468 void OpenGl_Polygon::draw_edges (const TEL_COLOUR *edge_colour, const Aspect_InteriorStyle interior_style, const Handle(OpenGl_Workspace) &AWorkspace) const
469 {
470   const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
471
472   if ( interior_style != Aspect_IS_HIDDENLINE && aspect_face->Context().Edge == TOff )
473     return;
474
475   glDisable(GL_LIGHTING);
476   const GLboolean texture_on = IsTextureEnabled();
477   if (texture_on) DisableTexture();
478
479   // Setup line aspect
480   const OpenGl_AspectLine *aspect_line_old = AWorkspace->SetAspectLine( aspect_face->AspectEdge() );
481   AWorkspace->AspectLine( Standard_True );
482
483   Tint i;
484   tel_point ptr = myData.vertices;
485
486   glColor3fv( edge_colour->rgb );
487
488   glBegin(GL_LINE_LOOP);
489   for( i=0; i<myData.num_vertices; i++, ptr++ )
490   {
491     glVertex3fv( ptr->xyz );
492   }
493   glEnd();
494
495   // Restore line context
496   AWorkspace->SetAspectLine( aspect_line_old );
497
498   if (texture_on) EnableTexture();
499 }
500
501 /*----------------------------------------------------------------------*/
502
503 void OpenGl_Polygon::draw_tmesh ( Tint v ) const
504 {
505   Tint      i, j, k;
506   SEQ_     *s;
507   extra_vertex b;
508
509   OPENGL_DISPLAY_PGN *dis = myData.dsply;
510   for( i = 0; i < dis->num_of_seq; i++ )
511   {
512     s = &(dis->seq[i]);
513
514     glBegin(s->triangle_type);
515     switch( v )
516     {
517     case 1:
518       {
519         for( j = 0, k = 0; j < s->ts_num; j++ )
520         {
521           if ( s->tmesh_sequence[j] < (void *)0xffff )
522             glVertex3fv( myData.vertices[ (long)s->tmesh_sequence[ j ] ].xyz );
523           else {
524             extra_vertex b = (extra_vertex)s->tmesh_sequence[j];
525             glVertex3fv( b->vert );
526           }
527
528         }
529         break;
530       }
531     case 2:
532       {
533         for( j = 0, k = 0; j < s->ts_num; j++ )
534         {
535           if ( s->tmesh_sequence[j] < (void *)0xffff ) {
536             glColor3fv( myData.vcolours[ (long) s->tmesh_sequence[ j ] ].rgb );
537             glVertex3fv( myData.vertices[ (long) s->tmesh_sequence[ j ] ].xyz );
538           } else {
539             b = (extra_vertex) s->tmesh_sequence[j];
540             glColor3fv( myData.vcolours[(b->ind)].rgb);
541             glVertex3fv( b->vert );
542           }
543         }
544         break;
545       }
546     case 3:
547       {
548         for( j = 0, k = 0; j < s->ts_num; j++ )
549         {
550           if ( s->tmesh_sequence[j] < (void *)0xffff ) {
551             glNormal3fv( myData.vnormals[ (long) s->tmesh_sequence[ j ] ].xyz);
552             glVertex3fv( myData.vertices[ (long) s->tmesh_sequence[ j ] ].xyz);
553           } else {
554             b = (extra_vertex) s->tmesh_sequence[j];
555             glNormal3fv( myData.vnormals[(b->ind)].xyz);
556             glVertex3fv( b->vert );
557           }
558         }
559         break;
560       }
561     }
562     glEnd();
563   }
564 }
565
566 /*----------------------------------------------------------------------*/
567
568 OpenGl_Polygon::OpenGl_Polygon (const Graphic3d_Array1OfVertex& AListVertex,
569                               const Graphic3d_TypeOfPolygon AType)
570 {
571   const Standard_Integer nv = AListVertex.Length();
572
573   myData.num_vertices = nv;
574
575   myData.vertices = new TEL_POINT[nv];
576   memcpy( myData.vertices, &AListVertex(AListVertex.Lower()), nv*sizeof(TEL_POINT) );
577
578   myData.vertex_flag = TEL_VT_NONE;
579   myData.vnormals = NULL;
580
581   myData.vcolours = NULL;
582
583   myData.vtexturecoord = NULL;
584
585   myData.reverse_order = 0;
586
587   myData.facet_flag = TEL_FA_NONE;
588   TelGetPolygonNormal( myData.vertices, NULL, nv, myData.fnormal.xyz );
589
590   myData.fcolour = NULL;
591
592 #if defined(__sgi) || defined(IRIX)
593   // Pb with tesselator on sgi
594   myData.shape_flag = TEL_SHAPE_CONVEX;
595 #else
596   switch (AType)
597   {
598     case Graphic3d_TOP_UNKNOWN :
599       myData.shape_flag = TEL_SHAPE_UNKNOWN;
600       break;
601     case Graphic3d_TOP_COMPLEX :
602       myData.shape_flag = TEL_SHAPE_COMPLEX;
603       break;
604     case Graphic3d_TOP_CONCAVE :
605       myData.shape_flag = TEL_SHAPE_CONCAVE;
606       break;
607     //case Graphic3d_TOP_CONVEX :
608     default :
609       myData.shape_flag = TEL_SHAPE_CONVEX;
610       break;
611   }
612 #endif
613
614   myData.dsply = new OPENGL_DISPLAY_PGN();
615   myData.dsply->num_of_seq = 0;
616   myData.dsply->num_alloc = 0;
617   myData.dsply->seq = NULL;
618 }
619
620 /*----------------------------------------------------------------------*/
621
622 OpenGl_Polygon::~OpenGl_Polygon ()
623 {
624   if( myData.fcolour )
625     delete myData.fcolour;
626   if( myData.vertices )
627     delete[] myData.vertices;
628   if( myData.vcolours )
629     delete[] myData.vcolours;
630   if( myData.vnormals )
631     delete[] myData.vnormals;
632   if ( myData.vtexturecoord )
633     delete myData.vtexturecoord;
634
635   if ( myData.dsply )
636   {
637     Tint i, j;
638
639     for( i = 0; i <  myData.dsply->num_of_seq; i++ )
640     {
641       if(myData.dsply->seq[i].tmesh_sequence) {
642         for ( j = 0; j < myData.dsply->seq[i].ts_num ; j++ ) {
643           if ( myData.dsply->seq[i].tmesh_sequence[j] >= (void *)0xffff )
644             free(myData.dsply->seq[i].tmesh_sequence[j]);
645         }
646       }
647       delete[] myData.dsply->seq[i].tmesh_sequence;
648     }
649     delete[] myData.dsply->seq;
650     delete myData.dsply;
651   }
652 }
653
654 /*----------------------------------------------------------------------*/
655
656 void OpenGl_Polygon::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
657 {
658   const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
659
660   Tint front_lighting_model = aspect_face->Context().IntFront.color_mask;
661   const Aspect_InteriorStyle interior_style = aspect_face->Context().InteriorStyle;
662   const TEL_COLOUR *interior_colour = &aspect_face->Context().IntFront.matcol;
663   const TEL_COLOUR *edge_colour = &aspect_face->AspectEdge()->Color();
664
665   // Use highlight colous
666   if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
667   {                         
668     edge_colour = interior_colour = AWorkspace->HighlightColor;
669     front_lighting_model = 0;
670   }
671
672   if( interior_style != Aspect_IS_EMPTY && AWorkspace->DegenerateModel < 2 )
673   {          
674     if ( front_lighting_model )
675       glEnable(GL_LIGHTING);
676     else
677       glDisable(GL_LIGHTING);
678
679     glColor3fv( interior_colour->rgb );
680
681     if( myData.shape_flag != TEL_SHAPE_CONVEX )
682       draw_polygon_concav( AWorkspace, front_lighting_model );
683     else
684       draw_polygon( AWorkspace, front_lighting_model );
685   }
686
687   /* OCC11904 -- Temporarily disable environment mapping */
688   glPushAttrib(GL_ENABLE_BIT);
689   glDisable(GL_TEXTURE_1D);
690   glDisable(GL_TEXTURE_2D);
691
692   switch ( AWorkspace->DegenerateModel )
693   {
694     default:
695       draw_edges ( edge_colour, interior_style, AWorkspace );
696       break;
697     case 3:  /* marker degeneration */
698       break;
699   }
700
701   glPopAttrib(); /* skt: GL_ENABLE_BIT*/
702 }
703
704 /*----------------------------------------------------------------------*/