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