projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0022734: Memory allocation error in OpenGl
[occt.git] / src / OpenGl / OpenGl_Mesh.cxx
CommitLineData
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
2166f0fa
SK		 20
21#define OCC749 /* SAV 19/09/02 added processing of colored vertices */
22#define OCC7824 /* ASL 26/01/05 transparency of polygon with colors assigned to vertices */
23
24/*----------------------------------------------------------------------*/
25/*
26* Includes
27*/
28
5f8b738e 29#include <OpenGl_GlCore11.hxx>
2166f0fa
SK		 30
31#include <OpenGl_Mesh.hxx>
32
33#include <OpenGl_telem_util.hxx>
34#include <OpenGl_TextureBox.hxx>
35
36#include <OpenGl_AspectFace.hxx>
37#include <OpenGl_Structure.hxx>
38
39#include <float.h>
40
41static long s_Rand = 1L;
42# define OPENGL_RAND() ( ( unsigned )( s_Rand = s_Rand * 214013L + 2531011L ) )
43
44/*----------------------------------------------------------------------*/
45/*
46* Prototypes
47*/
48
49typedef TEL_INDEXPOLY_DATA* tel_indexpoly_data;
50
51void set_drawable_items ( GLboolean*, int, const float );
52
53/*----------------------------------------------------------------------*/
54
55void OpenGl_Mesh::draw_indexpoly (const Tint front_lighting_model,
56 const Aspect_InteriorStyle interior_style,
57 const TEL_COLOUR *edge_colour,
58 const OPENGL_SURF_PROP *prop,
59 const Handle(OpenGl_Workspace) &AWorkspace) const
60{
61 Tint i, j, k, a, newList = 0;
62 Tint lighting_model;
63
64 /* Following pointers have been provided for performance improvement */
65 Tint *ind;
66 tel_point pfn, pvn, pv;
67 tel_colour pvc, pfc;
68 tel_texture_coord pvt;
69
70 ind = myData.indices;
71 pfn = myData.fnormals;
72 pvn = myData.vnormals;
73 pvc = myData.vcolours;
74 pfc = myData.fcolours;
75 pv = myData.vertices;
76 pvt = myData.vtexturecoord;
77 if ( AWorkspace->DegenerateModel < 2 && interior_style != Aspect_IS_EMPTY )
78 {
79 if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
80 {
81 pvc = 0;
82 pfc = 0;
83 }
84
85 if ( interior_style == Aspect_IS_HIDDENLINE)
86 {
87 pvc = 0;
88 pfc = 0;
89 }
90
91 if ( front_lighting_model )
92 glEnable(GL_LIGHTING);
93 else
94 glDisable(GL_LIGHTING);
95
96 lighting_model = front_lighting_model;
97
98 if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) == 0 )
99 goto doDraw; /* Disable object display list out of animation */
100 /* window's context and bitmap's one */
101
102 if ( myDS->model != lighting_model || !myDS->list ||
103 myDS->model == -1 || ( AWorkspace->DegenerateModel && myDS->skipRatio != AWorkspace->SkipRatio ))
104 {
105 myDS->skipRatio = AWorkspace->SkipRatio;
106 myDS->model = lighting_model;
107 myDS->degMode = AWorkspace->DegenerateModel;
108 if ( AWorkspace->SkipRatio <= 0.f ) {
109 if ( !myDS->list ) myDS->list = glGenLists ( 1 );
110
111 glNewList ( myDS->list, GL_COMPILE_AND_EXECUTE );
112 newList = 1;
113doDraw:
114 if ( !lighting_model )
115 {
116 if ( myData.num_bounds == 3 )
117 glBegin ( GL_TRIANGLES );
118 else if ( myData.num_bounds == 4 )
119 glBegin ( GL_QUADS );
120 else glBegin ( GL_POLYGON );
121
122 if ( pvc )
123 {
124 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
125 {
126 a = j + myData.num_bounds;
127 for ( ; j < a; ++j )
128 {
129 glColor3fv ( pvc[ ind[ j ] ].rgb );
130 glVertex3fv ( pv[ ind[ j ] ].xyz );
131 }
132 }
133 }
134 else if ( pfc )
135 {
136 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
137 {
138 a = j + myData.num_bounds;
139 glColor3fv ( pfc[ i ].rgb );
140 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
141 }
142 }
143 else
144 {
145 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
146 {
147 a = j + myData.num_bounds;
148 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
149 }
150 }
151 glEnd ();
152 }
153 else
154 {
155 /* lighting_model != TelLModelNone */
156 if ( myData.num_bounds == 3 )
157 glBegin ( GL_TRIANGLES );
158 else if ( myData.num_bounds == 4 )
159 glBegin ( GL_QUADS );
160 else glBegin ( GL_POLYGON );
161
162#ifdef OCC749
163 for ( i = a = 0; i < myData.num_facets; ++i ) {
164 j = a; a += myData.num_bounds;
165 if( pfn ) glNormal3fv ( pfn[ i ].xyz );
166 if( pfc && !prop->isphysic ) {
167 GLfloat diff[4], ambi[4], emsv[4], r, g, b;
168
169 ambi[3] = diff[3] = emsv[3] = prop->trans;
170
171 r = pfc[ i ].rgb[0]; g = pfc[ i ].rgb[1]; b = pfc[ i ].rgb[2];
172
173 if( prop->color_mask & OPENGL_AMBIENT_MASK ) {
174 ambi[0] = prop->amb * r;
175 ambi[1] = prop->amb * g;
176 ambi[2] = prop->amb * b;
177 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambi);
178 }
179 if( prop->color_mask & OPENGL_DIFFUSE_MASK ) {
180 diff[0] = prop->diff * r;
181 diff[1] = prop->diff * g;
182 diff[2] = prop->diff * b;
183 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diff);
184 }
185 if( prop->color_mask & OPENGL_EMISSIVE_MASK ) {
186 emsv[0] = prop->emsv * r;
187 emsv[1] = prop->emsv * g;
188 emsv[2] = prop->emsv * b;
189 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emsv);
190 }
191 }
192 for ( ; j < a; ++j ) {
193 k = ind[ j ];
194 if( pvn ) glNormal3fv ( pvn[ k ].xyz );
195 if( pvc && !prop->isphysic ) {
196 GLfloat diff[4], ambi[4], emsv[4], r, g, b;
197
198 ambi[3] = diff[3] = emsv[3] = prop->trans;
199
200 r = pvc[ k ].rgb[0]; g = pvc[ k ].rgb[1]; b = pvc[ k ].rgb[2];
201
202 if( prop->color_mask & OPENGL_AMBIENT_MASK ) {
203 ambi[0] = prop->amb * r;
204 ambi[1] = prop->amb * g;
205 ambi[2] = prop->amb * b;
206 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambi);
207 }
208 if( prop->color_mask & OPENGL_DIFFUSE_MASK ) {
209 diff[0] = prop->diff * r;
210 diff[1] = prop->diff * g;
211 diff[2] = prop->diff * b;
212 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diff);
213 }
214 if( prop->color_mask & OPENGL_EMISSIVE_MASK ) {
215 emsv[0] = prop->emsv * r;
216 emsv[1] = prop->emsv * g;
217 emsv[2] = prop->emsv * b;
218 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emsv);
219 }
220 }
221 if( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 ) glTexCoord2fv ( pvt[ k ].xy );
222 glVertex3fv ( pv[ k ].xyz );
223 } /* end for ( j . . . ) */
224 } /* end for ( i . . . ) */
225 glEnd ();
226#else
227 if ( pvn ) {
228 if ( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 )
229 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
230 a = j + myData.num_bounds;
231 for ( ; j < a; ++j ) {
232 glNormal3fv ( pvn[ ind[ j ] ].xyz );
233 glTexCoord2fv ( pvt[ ind[ j ] ].xy );
234 glVertex3fv ( pv[ ind[ j ] ].xyz );
235 } /* end for ( j . . . ) */
236 } /* end for ( i . . . ) */
237 else
238 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
239 a = j + myData.num_bounds;
240 for ( ; j < a; ++j ) {
241 glNormal3fv ( pvn[ ind[ j ] ].xyz );
242 glVertex3fv ( pv[ ind[ j ] ].xyz );
243 } /* end for ( j . . . ) */
244 } /* end for ( i . . . ) */
245 } else { /* !pvn */
246 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
247 a = j + myData.num_bounds;
248 glNormal3fv ( pfn[ i ].xyz );
249 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
250 } /* end for */
251 } /* end else */
252 glEnd ();
253#endif /* OCC749 */
254
255 } /* end else */
256 } else if ( AWorkspace->SkipRatio < 1.f ) {
257 if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
258 glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
259 newList = 1;
260 set_drawable_items ( myDS->bDraw, myData.num_facets, AWorkspace->SkipRatio );
261 if ( !lighting_model ) {
262 if ( myData.num_bounds == 3 )
263 glBegin ( GL_TRIANGLES );
264 else if ( myData.num_bounds == 4 )
265 glBegin ( GL_QUADS );
266 else glBegin ( GL_POLYGON );
267
268 if ( pvc ) {
269 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
270 a = j + myData.num_bounds;
271 if ( myDS->bDraw[ i ] )
272 for ( ; j < a; ++j ) {
273 glColor3fv ( pvc[ ind[ j ] ].rgb );
274 glVertex3fv ( pv[ ind[ j ] ].xyz );
275 } /* end for ( j . . . ) */
276 else j = a;
277 } /* end for ( i . . . ) */
278 } else if ( pfc ) {
279 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
280 a = j + myData.num_bounds;
281 if ( myDS->bDraw[ i ] ) {
282 glColor3fv ( pfc[ i ].rgb );
283 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
284 } else j = a;
285 } /* end for */
286 } else {
287 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
288 a = j + myData.num_bounds;
289 if ( myDS->bDraw[ i ] )
290 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
291 else j = a;
292 } /* end for */
293 } /* end else */
294 glEnd ();
295 } else { /* lighting_model != TelLModelNone */
296 if ( myData.num_bounds == 3 )
297 glBegin ( GL_TRIANGLES );
298 else if ( myData.num_bounds == 4 )
299 glBegin ( GL_QUADS );
300 else glBegin ( GL_POLYGON );
301
302 if ( pvn ) {
303 if ( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 )
304 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
305 a = j + myData.num_bounds;
306 if ( myDS->bDraw[ i ] )
307 for ( ; j < a; ++j ) {
308 glNormal3fv ( pvn[ ind[ j ] ].xyz );
309 glTexCoord2fv ( pvt[ ind[ j ] ].xy );
310 glVertex3fv ( pv[ ind[ j ] ].xyz );
311 } /* end for ( j . . . ) */
312 else j = a;
313 } /* end for ( i . . . ) */
314 else
315 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
316 a = j + myData.num_bounds;
317 if ( myDS->bDraw[ i ] )
318 for ( ; j < a; ++j ) {
319 glNormal3fv ( pvn[ ind[ j ] ].xyz );
320 glVertex3fv ( pv[ ind[ j ] ].xyz );
321 } /* end for ( j . . . ) */
322 else j = a;
323 } /* end for ( i . . . ) */
324 } else { /* !pvn */
325 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
326 a = j + myData.num_bounds;
327 if ( myDS->bDraw[ i ] ) {
328 glNormal3fv ( pfn[ i ].xyz );
329 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
330 } else j = a;
331 } /* end for */
332 } /* end else */
333 glEnd ();
334 } /* end else */
335 } else {
336 if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
337 glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
338 newList = 1;
339 } /* end else */
340 if ( newList ) glEndList ();
341 if ( AWorkspace->DegenerateModel ) return;
342 } else {
343 glCallList ( AWorkspace->SkipRatio <= 0.f ? myDS->list : myDS->dlist );
344 if ( AWorkspace->DegenerateModel ) return;
345 } /* end else */
346 }
347
348 i = 0;
349
350 switch ( AWorkspace->DegenerateModel )
351 {
352 default:
353 break;
354
355 case 2: /* XXX_TDM_WIREFRAME */
356 i = 1;
357 break;
358
359 case 3: /* XXX_TDM_MARKER */
360 draw_degenerates_as_points ( AWorkspace->SkipRatio );
361 return;
362
363 case 4: /* XXX_TDM_BBOX */
364 draw_degenerates_as_bboxs ();
365 return;
366 }
367
368 draw_edges ( edge_colour, interior_style, i, AWorkspace );
369}
370
371/*----------------------------------------------------------------------*/
372
373void OpenGl_Mesh::draw_edges (const TEL_COLOUR *edge_colour, const Aspect_InteriorStyle interior_style,
374 Tint forceDraw, const Handle(OpenGl_Workspace) &AWorkspace) const
375{
376 const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
377
378 if ( interior_style != Aspect_IS_HIDDENLINE && !forceDraw && aspect_face->Context().Edge == TOff )
379 return;
380
381 glDisable(GL_LIGHTING);
382 const GLboolean texture_on = IsTextureEnabled();
383 if (texture_on) DisableTexture();
384
385 // Setup line aspect
386 const OpenGl_AspectLine *aspect_line_old = AWorkspace->SetAspectLine( aspect_face->AspectEdge() );
387 AWorkspace->AspectLine( Standard_True );
388
389 tel_point pv = myData.vertices;
390 Tint *ind = myData.indices;
391 Tint *vis = myData.edge_vis;
392
393 Tint i, j, a, newList = 0;
394
395 if ( !forceDraw ) {
396
397 glColor3fv ( edge_colour -> rgb );
398 glPushAttrib ( GL_POLYGON_BIT );
399 glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
400
401 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
402
403 a = j + myData.num_bounds;
404
405 glBegin ( GL_POLYGON );
406
407 for ( ; j < a; ++j ) {
408
409 glEdgeFlag ( ( GLboolean )( vis[ j ] == 1 ? GL_TRUE : GL_FALSE ) );
410 glVertex3fv ( pv[ ind[ j ] ].xyz );
411
412 } /* end for */
413
414 glEnd();
415
416 glEdgeFlag ( GL_TRUE );
417
418 } /* end for */
419
420 glPopAttrib ();
421
422 } else {
423
424 if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) == 0 )
425 goto doDraw; /* Disable object display list out of animation */
426
427 if ( myDS->degMode != 2 || myDS->skipRatio != AWorkspace->SkipRatio || !myDS->dlist ) {
428
429 if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
430
431 myDS->degMode = 2;
432 myDS->skipRatio = AWorkspace->SkipRatio;
433 glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
434 newList = 1;
435
436doDraw:
437 glPushAttrib ( GL_POLYGON_BIT | GL_DEPTH_BUFFER_BIT );
438
439 glEdgeFlag ( GL_TRUE );
440 glDisable ( GL_DEPTH_TEST );
441 glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
442
443 if ( AWorkspace->SkipRatio <= 0.f )
444
445 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
446
447 a = j + myData.num_bounds;
448
449 glBegin ( GL_POLYGON );
450
451 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
452
453 glEnd();
454
455 } /* end for */
456
457 else if ( AWorkspace->SkipRatio < 1.f ) {
458
459 set_drawable_items ( myDS->bDraw, myData.num_facets, AWorkspace->SkipRatio );
460
461 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
462
463 a = j + myData.num_bounds;
464
465 if ( myDS->bDraw[ i ] ) {
466
467 glBegin ( GL_POLYGON );
468
469 for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
470
471 glEnd();
472
473 } else j = a;
474
475 } /* end for */
476
477 } /* end if */
478
479 glPopAttrib ();
480 if ( newList ) glEndList ();
481
482 } else glCallList ( myDS->dlist );
483
484 } /* end else */
485
486 // Restore line context
487 AWorkspace->SetAspectLine( aspect_line_old );
488
489 if (texture_on) EnableTexture();
490}
491
492/*----------------------------------------------------------------------*/
493
494void OpenGl_Mesh::draw_degenerates_as_points (const float aSkipRatio) const
495{
496 Tint* ind, *vis;
497 Tint i, j, n, a, newList = 0;
498 GLfloat pt[ 3 ];
499 tel_point pv;
500
501 pv = myData.vertices;
502 ind = myData.indices;
503 vis = myData.edge_vis;
504
505 glDisable(GL_LIGHTING);
506
507 if ( myDS->degMode != 3 || myDS->skipRatio != aSkipRatio || !myDS->dlist ) {
508
509 if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
510
511 myDS->degMode = 3;
512 myDS->skipRatio = aSkipRatio;
513 glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
514 newList = 1;
515
516 if ( aSkipRatio <= 0.f ) {
517
518 glBegin ( GL_POINTS );
519
520 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
521
522 n = myData.num_bounds;
523 a = j + n;
524
525 for ( pt [ 0 ] = pt[ 1 ] = pt[ 2 ] = 0.; j < a; ++j ) {
526
527 pt[ 0 ] += pv[ ind[ j ] ].xyz[ 0 ];
528 pt[ 1 ] += pv[ ind[ j ] ].xyz[ 1 ];
529 pt[ 2 ] += pv[ ind[ j ] ].xyz[ 2 ];
530
531 } /* end for ( j ) */
532
533 pt[ 0 ] /= n;
534 pt[ 1 ] /= n;
535 pt[ 2 ] /= n;
536
537 glVertex3fv ( pt );
538
539 } /* end for ( i ) */
540
541 glEnd ();
542
543 } else if ( aSkipRatio < 1.f ) {
544
545 set_drawable_items ( myDS->bDraw, myData.num_facets, aSkipRatio );
546
547 glBegin ( GL_POINTS );
548
549 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
550
551 n = myData.num_bounds;
552 a = j + n;
553
554 if ( myDS->bDraw[ i ] ) {
555
556 for ( pt [ 0 ] = pt[ 1 ] = pt[ 2 ] = 0.; j < a; ++j ) {
557
558 pt[ 0 ] += pv[ ind[ j ] ].xyz[ 0 ];
559 pt[ 1 ] += pv[ ind[ j ] ].xyz[ 1 ];
560 pt[ 2 ] += pv[ ind[ j ] ].xyz[ 2 ];
561
562 } /* end for ( j ) */
563
564 pt[ 0 ] /= n;
565 pt[ 1 ] /= n;
566 pt[ 2 ] /= n;
567
568 glVertex3fv ( pt );
569
570 } else j = a;
571
572 } /* end for ( i ) */
573
574 glEnd ();
575
576 } /* end if */
577
578 glEndList ();
579
580 } else glCallList ( myDS->dlist );
581
582}
583
584void OpenGl_Mesh::draw_degenerates_as_bboxs () const
585{
586 Tint* ind, *vis;
587 Tint i, j, n, a, newList = 0;
588 GLfloat minp[ 3 ] = { FLT_MAX, FLT_MAX, FLT_MAX };
589 GLfloat maxp[ 3 ] = { FLT_MIN, FLT_MIN, FLT_MIN };
590 tel_point pv;
591
592 pv = myData.vertices;
593 ind = myData.indices;
594 vis = myData.edge_vis;
595
596 glDisable(GL_LIGHTING);
597
598 if ( myDS->degMode != 4 || !myDS->dlist ) {
599
600 if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
601
602 myDS->degMode = 4;
603
604 glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
605 newList = 1;
606
607 for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
608
609 n = myData.num_bounds;
610 a = j + n;
611
612 for ( ; j < a; ++j ) {
613
614 if ( pv[ ind[ j ] ].xyz[ 0 ] < minp[ 0 ] )
615 minp[ 0 ] = pv[ ind[ j ] ].xyz[ 0 ] ;
616 if ( pv[ ind[ j ] ].xyz[ 1 ] < minp[ 1 ] )
617 minp[ 1 ] = pv[ ind[ j ] ].xyz[ 1 ] ;
618 if ( pv[ ind[ j ] ].xyz[ 2 ] < minp[ 2 ] )
619 minp[ 2 ] = pv[ ind[ j ] ].xyz[ 2 ] ;
620
621 if ( pv[ ind[ j ] ].xyz[ 0 ] > maxp[ 0 ] )
622 maxp[ 0 ] = pv[ ind[ j ] ].xyz[ 0 ] ;
623 if ( pv[ ind[ j ] ].xyz[ 1 ] > maxp[ 1 ] )
624 maxp[ 1 ] = pv[ ind[ j ] ].xyz[ 1 ] ;
625 if ( pv[ ind[ j ] ].xyz[ 2 ] > maxp[ 2 ] )
626 maxp[ 2 ] = pv[ ind[ j ] ].xyz[ 2 ] ;
627
628 } /* end for ( j ) */
629
630 } /* end for ( i ) */
631
632 /* OCC11904 -- Temporarily disable environment mapping */
633 glPushAttrib(GL_ENABLE_BIT);
634 glDisable(GL_TEXTURE_1D);
635 glDisable(GL_TEXTURE_2D);
636
637 glBegin ( GL_LINE_STRIP );
638
639 glVertex3fv ( minp );
640 glVertex3f ( minp[ 0 ], maxp[ 1 ], minp[ 2 ] );
641 glVertex3f ( minp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
642 glVertex3f ( minp[ 0 ], minp[ 1 ], maxp[ 2 ] );
643 glVertex3f ( minp[ 0 ], minp[ 1 ], minp[ 2 ] );
644
645 glVertex3f ( maxp[ 0 ], minp[ 1 ], minp[ 2 ] );
646 glVertex3f ( maxp[ 0 ], maxp[ 1 ], minp[ 2 ] );
647 glVertex3f ( maxp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
648 glVertex3f ( maxp[ 0 ], minp[ 1 ], maxp[ 2 ] );
649 glVertex3f ( maxp[ 0 ], minp[ 1 ], minp[ 2 ] );
650
651 glVertex3f ( maxp[ 0 ], minp[ 1 ], maxp[ 2 ] );
652 glVertex3f ( minp[ 0 ], minp[ 1 ], maxp[ 2 ] );
653 glVertex3f ( minp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
654 glVertex3fv ( maxp );
655 glVertex3f ( maxp[ 0 ], maxp[ 1 ], minp[ 2 ] );
656 glVertex3f ( minp[ 0 ], maxp[ 1 ], minp[ 2 ] );
657
658 glEnd();
659 glPopAttrib();
660 glEndList ();
661
662 } else glCallList ( myDS->dlist );
663}
664
665/*----------------------------------------------------------------------*/
666
667void set_drawable_items ( GLboolean* pbDraw, int n, const float aSkipRatio )
668{
669 memset ( pbDraw, 0, sizeof ( GLboolean ) * n );
670
671 int i = ( int )( ( 1.0F - aSkipRatio ) * n );
672
673 while ( i-- ) pbDraw[ OPENGL_RAND() % n ] = 1;
674}
675
676/*----------------------------------------------------------------------*/
677
678OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertex& AListVertex, const Aspect_Array1OfEdge& AListEdge)
679{
680 const Standard_Integer nv = AListVertex.Length();
681
682 // Dynamic allocation
683 TEL_POINT *points = new TEL_POINT[nv];
684 memcpy( points, &AListVertex(AListVertex.Lower()), nv*sizeof(TEL_POINT) );
685
686 Init (nv,points,NULL,NULL,NULL,AListEdge,3);
687}
688
689/*----------------------------------------------------------------------*/
690
691OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexN& AListVertex, const Aspect_Array1OfEdge& AListEdge)
692{
693 const Standard_Integer nv = AListVertex.Length ();
694
695 // Dynamic allocation
696 TEL_POINT *points = new TEL_POINT[nv];
697 TEL_POINT *normals = new TEL_POINT[nv];
698
699 Standard_Integer i = 0, j = AListVertex.Lower();
700 Standard_Real X, Y, Z;
701 for ( ; i < nv; i++, j++)
702 {
703 AListVertex(j).Coord(X, Y, Z);
704 points[i].xyz[0] = float (X);
705 points[i].xyz[1] = float (Y);
706 points[i].xyz[2] = float (Z);
707 AListVertex(j).Normal(X, Y, Z);
708 normals[i].xyz[0] = float (X);
709 normals[i].xyz[1] = float (Y);
710 normals[i].xyz[2] = float (Z);
711 }
712
713 Init (nv,points,normals,NULL,NULL,AListEdge,3);
714}
715
716/*----------------------------------------------------------------------*/
717
718OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexC& AListVertex, const Aspect_Array1OfEdge& AListEdge)
719{
720 const Standard_Integer nv = AListVertex.Length ();
721
722 // Dynamic allocation
723 TEL_POINT *points = new TEL_POINT[nv];
724 TEL_COLOUR *colors = new TEL_COLOUR[nv];
725
726 Standard_Integer i = 0, j = AListVertex.Lower();
727 Standard_Real X, Y, Z;
728 for ( ; i < nv; i++, j++)
729 {
730 AListVertex(j).Coord(X, Y, Z);
731 points[i].xyz[0] = float (X);
732 points[i].xyz[1] = float (Y);
733 points[i].xyz[2] = float (Z);
734 AListVertex(j).Color().Values (X, Y, Z, Quantity_TOC_RGB);
735 colors[i].rgb[0] = float (X);
736 colors[i].rgb[1] = float (Y);
737 colors[i].rgb[2] = float (Z);
738 colors[i].rgb[3] = 1.0F;
739 }
740
741 Init (nv,points,NULL,colors,NULL,AListEdge,3);
742}
743
744/*----------------------------------------------------------------------*/
745
746OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexNC& AListVertex, const Aspect_Array1OfEdge& AListEdge)
747{
748 const Standard_Integer nv = AListVertex.Length ();
749
750 // Dynamic allocation
751 TEL_POINT *points = new TEL_POINT[nv];
752 TEL_POINT *normals = new TEL_POINT[nv];
753 TEL_COLOUR *colors = new TEL_COLOUR[nv];
754
755 Standard_Integer i = 0, j = AListVertex.Lower();
756 Standard_Real X, Y, Z;
757 for ( ; i < nv; i++, j++)
758 {
759 AListVertex(j).Coord(X, Y, Z);
760 points[i].xyz[0] = float (X);
761 points[i].xyz[1] = float (Y);
762 points[i].xyz[2] = float (Z);
763 AListVertex(j).Normal(X, Y, Z);
764 normals[i].xyz[0] = float (X);
765 normals[i].xyz[1] = float (Y);
766 normals[i].xyz[2] = float (Z);
767 AListVertex(j).Color().Values (X, Y, Z, Quantity_TOC_RGB);
768 colors[i].rgb[0] = float (X);
769 colors[i].rgb[1] = float (Y);
770 colors[i].rgb[2] = float (Z);
771 colors[i].rgb[3] = 1.0F;
772 }
773
774 Init (nv,points,normals,colors,NULL,AListEdge,3);
775}
776
777/*----------------------------------------------------------------------*/
778
779OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexNT& AListVertex, const Aspect_Array1OfEdge& AListEdge)
780{
781 const Standard_Integer nv = AListVertex.Length ();
782
783 // Dynamic allocation
784 TEL_POINT *points = new TEL_POINT[nv];
785 TEL_POINT *normals = new TEL_POINT[nv];
786 TEL_TEXTURE_COORD *tcoords = new TEL_TEXTURE_COORD[nv];
787
788 Standard_Integer i = 0, j = AListVertex.Lower();
789 Standard_Real X, Y, Z;
790 for ( ; i < nv; i++, j++)
791 {
792 AListVertex(j).Coord(X, Y, Z);
793 points[i].xyz[0] = float (X);
794 points[i].xyz[1] = float (Y);
795 points[i].xyz[2] = float (Z);
796 AListVertex(j).Normal(X, Y, Z);
797 normals[i].xyz[0] = float (X);
798 normals[i].xyz[1] = float (Y);
799 normals[i].xyz[2] = float (Z);
800 AListVertex(j).TextureCoordinate(X, Y);
801 tcoords[i].xy[0] = float(X);
802 tcoords[i].xy[1] = float(Y);
803 }
804
805 Init (nv,points,normals,NULL,tcoords,AListEdge,3);
806}
807
808/*----------------------------------------------------------------------*/
809
810void OpenGl_Mesh::Init (const Tint ANbVertices, tel_point AVertices,
811 tel_point AVNormals, tel_colour AVColors, tel_texture_coord ATCoords,
812 const Aspect_Array1OfEdge& AListEdge, const Tint ANbBounds)
813{
814 // Get number of bounds in a facet
815 myData.num_bounds = ANbBounds;
816
817 // Get number of vertices
818 myData.num_vertices = ANbVertices;
819
820 // Get vertices
821 myData.vertices = AVertices;
822
823 // Get number of edges
824 const Standard_Integer nb_edges = AListEdge.Length ();
825
826 myData.indices = new Tint[nb_edges];
827 myData.edge_vis = new Tint[nb_edges];
828
829 const Standard_Integer LowerE = AListEdge.Lower ();
830 const Standard_Integer UpperE = AListEdge.Upper ();
831
832 // Loop on edges
833 Standard_Integer i, j;
834 for (j=0, i=LowerE; i<=UpperE; i++, j++)
835 {
836 myData.indices[j] = AListEdge(i).FirstIndex() - LowerE; //LastIndex unused
837 myData.edge_vis[j] = AListEdge(i).Type() ? TOff : TOn;
838 }
839
840 // Get number of facets
841 myData.num_facets = nb_edges / ANbBounds;
842
843 myData.vnormals = AVNormals;
844 if (AVNormals)
845 {
846 myData.vertex_flag = TEL_VT_NORMAL;
847 for( i = 0; i < ANbVertices; i++ )
848 vecnrm( myData.vnormals[i].xyz );
849 }
850 else
851 {
852 myData.vertex_flag = TEL_VT_NONE;
853 }
854
855 myData.vcolours = AVColors;
856 myData.vtexturecoord = ATCoords;
857
858 myData.facet_flag = TEL_FA_NONE;
859 myData.fnormals = new TEL_POINT[myData.num_facets];
860 for( i = 0, j = 0; i < myData.num_facets; i++ )
861 {
862 TelGetPolygonNormal( myData.vertices, &myData.indices[j], myData.num_bounds, myData.fnormals[i].xyz );
863 j += myData.num_bounds;
864 }
865
866 myData.fcolours = NULL;
867
868 myDS = new DS_INTERNAL();
869 myDS->list = 0;
870 myDS->dlist = 0;
871 myDS->degMode = 0;
872 myDS->model = -1;
873 myDS->skipRatio = 0.0F;
874 myDS->bDraw = new unsigned char[myData.num_facets];
875}
876
877/*----------------------------------------------------------------------*/
878
879OpenGl_Mesh::~OpenGl_Mesh ()
880{
881 if( myData.edge_vis )
882 delete[] myData.edge_vis;
883 if( myData.indices )
884 delete[] myData.indices;
885 if( myData.fcolours )
886 delete[] myData.fcolours;
887 if( myData.fnormals )
888 delete[] myData.fnormals;
889 if( myData.vertices )
890 delete[] myData.vertices;
891 if( myData.vcolours )
892 delete[] myData.vcolours;
893 if( myData.vnormals )
894 delete[] myData.vnormals;
895 if( myData.vtexturecoord )
896 delete[] myData.vtexturecoord;
897
898 if ( myDS )
899 {
900 if ( GET_GL_CONTEXT() != NULL )
901 {
902 if ( myDS->list ) glDeleteLists ( myDS->list, 1 );
903 if ( myDS->dlist ) glDeleteLists ( myDS->dlist, 1 );
904 }
905
906 if ( myDS->bDraw )
907 delete[] myDS->bDraw;
908
909 delete myDS;
910 }
911}
912
913/*----------------------------------------------------------------------*/
914
915void OpenGl_Mesh::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
916{
917 const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
918
919 Tint front_lighting_model = aspect_face->Context().IntFront.color_mask;
920 const TEL_COLOUR *interior_colour = &aspect_face->Context().IntFront.matcol;
921 const TEL_COLOUR *edge_colour = &aspect_face->AspectEdge()->Color();
922
923 // Use highlight colors
924 if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
925 {
926 edge_colour = interior_colour = AWorkspace->HighlightColor;
927 front_lighting_model = 0;
928 }
929
930 glColor3fv( interior_colour->rgb );
931
932 draw_indexpoly( front_lighting_model,
933 aspect_face->Context().InteriorStyle,
934 edge_colour,
935 &aspect_face->Context().IntFront,
936 AWorkspace );
937}
938
939/*----------------------------------------------------------------------*/
Open CASCADE Technology repository