Commit | Line | Data |
---|---|---|
b311480e | 1 | // Created on: 2011-08-05 |
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 | 20 | |
5f8b738e | 21 | #include <OpenGl_GlCore11.hxx> |
22 | ||
2166f0fa SK |
23 | #include <OpenGl_Workspace.hxx> |
24 | ||
25 | #include <OpenGl_AspectLine.hxx> | |
26 | #include <OpenGl_AspectFace.hxx> | |
27 | #include <OpenGl_AspectMarker.hxx> | |
28 | #include <OpenGl_AspectText.hxx> | |
29 | ||
498ce577 | 30 | #ifdef HAVE_CONFIG_H |
31 | # include <config.h> | |
32 | #endif | |
33 | ||
2166f0fa SK |
34 | /* OCC22218 NOTE: project dependency on gl2ps is specified by macro */ |
35 | #ifdef HAVE_GL2PS | |
36 | #include <gl2ps.h> | |
bf75be98 | 37 | /* OCC22216 NOTE: linker dependency can be switched off by undefining macro. |
38 | Pragma comment for gl2ps.lib is defined only here. */ | |
39 | #ifdef _MSC_VER | |
2166f0fa SK |
40 | #pragma comment( lib, "gl2ps.lib" ) |
41 | #endif | |
42 | #endif | |
43 | ||
2166f0fa | 44 | #include <Aspect_PolygonOffsetMode.hxx> |
2166f0fa SK |
45 | #include <OpenGl_View.hxx> |
46 | ||
47 | /*----------------------------------------------------------------------*/ | |
48 | ||
49 | static void TelUpdatePolygonOffsets( const TEL_POFFSET_PARAM *pdata ) | |
50 | { | |
51 | if ( ( pdata->mode & Aspect_POM_Fill ) == Aspect_POM_Fill ) | |
52 | glEnable ( GL_POLYGON_OFFSET_FILL ); | |
bf75be98 | 53 | else |
2166f0fa SK |
54 | glDisable ( GL_POLYGON_OFFSET_FILL ); |
55 | ||
56 | if ( ( pdata->mode & Aspect_POM_Line ) == Aspect_POM_Line ) | |
57 | glEnable ( GL_POLYGON_OFFSET_LINE ); | |
58 | else | |
59 | glDisable( GL_POLYGON_OFFSET_LINE ); | |
60 | ||
61 | if ( ( pdata->mode & Aspect_POM_Point ) == Aspect_POM_Point ) | |
62 | glEnable ( GL_POLYGON_OFFSET_POINT ); | |
63 | else | |
64 | glDisable( GL_POLYGON_OFFSET_POINT ); | |
65 | ||
66 | glPolygonOffset( pdata->factor, pdata->units ); | |
67 | } | |
68 | ||
69 | /*----------------------------------------------------------------------*/ | |
70 | ||
71 | void OpenGl_Workspace::UpdateMaterial( const int flag ) | |
72 | { | |
73 | // Case of Hiddenline | |
bf75be98 | 74 | if (AspectFace_set->InteriorStyle == Aspect_IS_HIDDENLINE) |
2166f0fa | 75 | { |
bf75be98 | 76 | myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect |
77 | myAspectFaceHl.IntFront.matcol = BackgroundColor(); | |
78 | myAspectFaceHl.IntFront.color_mask = 0; | |
79 | myAspectFaceHl.IntBack.color_mask = 0; | |
2166f0fa | 80 | |
bf75be98 | 81 | AspectFace_set = &myAspectFaceHl; |
2166f0fa SK |
82 | return; |
83 | } | |
84 | ||
85 | const OPENGL_SURF_PROP *prop = NULL; | |
86 | GLenum face = 0; | |
87 | if ( flag == TEL_FRONT_MATERIAL ) | |
88 | { | |
bf75be98 | 89 | prop = &AspectFace_set->IntFront; |
2166f0fa SK |
90 | face = GL_FRONT_AND_BACK; |
91 | } | |
92 | else | |
93 | { | |
bf75be98 | 94 | prop = &AspectFace_set->IntBack; |
2166f0fa SK |
95 | face = GL_BACK; |
96 | } | |
97 | ||
98 | const unsigned int rm = prop->color_mask; | |
99 | ||
100 | if ( !rm ) return; | |
101 | ||
102 | // Handling transparency | |
103 | if ( (NamedStatus & OPENGL_NS_2NDPASSDO) == 0 ) | |
104 | { | |
105 | if ( myUseTransparency && prop->trans != 1.0F ) | |
106 | { | |
107 | // Render transparent | |
bf75be98 | 108 | glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
2166f0fa SK |
109 | glEnable (GL_BLEND); |
110 | glDepthMask (GL_FALSE); | |
111 | } | |
bf75be98 | 112 | else |
2166f0fa SK |
113 | { |
114 | // Render opaque | |
115 | if ( (NamedStatus & OPENGL_NS_ANTIALIASING) == 0 ) | |
116 | { | |
117 | glBlendFunc (GL_ONE, GL_ZERO); | |
118 | glDisable (GL_BLEND); | |
119 | } | |
120 | glDepthMask (GL_TRUE); | |
bf75be98 | 121 | } |
2166f0fa SK |
122 | } |
123 | ||
124 | static float mAmb[4]; | |
125 | static float mDiff[4]; | |
126 | static float mSpec[4]; | |
127 | static float mEmsv[4]; | |
128 | static float mShin; | |
129 | ||
130 | static const float defspeccol[4] = { 1.F, 1.F, 1.F, 1.F }; | |
131 | ||
132 | // Reset material | |
133 | if ( NamedStatus & OPENGL_NS_RESMAT ) | |
bf75be98 | 134 | { |
2166f0fa SK |
135 | // Ambient component |
136 | if( rm & OPENGL_AMBIENT_MASK ) | |
137 | { | |
138 | const float *c = prop->isphysic? prop->ambcol.rgb : prop->matcol.rgb; | |
139 | ||
140 | mAmb[0] = prop->amb * c[0]; | |
141 | mAmb[1] = prop->amb * c[1]; | |
142 | mAmb[2] = prop->amb * c[2]; | |
143 | } | |
144 | else | |
145 | { | |
146 | mAmb[0] = 0.F; | |
147 | mAmb[1] = 0.F; | |
148 | mAmb[2] = 0.F; | |
149 | } | |
150 | mAmb[3] = 1.F; | |
151 | ||
152 | // Diffusion component | |
153 | if( rm & OPENGL_DIFFUSE_MASK ) | |
154 | { | |
155 | const float *c = prop->isphysic? prop->difcol.rgb : prop->matcol.rgb; | |
156 | ||
157 | mDiff[0] = prop->diff * c[0]; | |
158 | mDiff[1] = prop->diff * c[1]; | |
159 | mDiff[2] = prop->diff * c[2]; | |
160 | } | |
161 | else | |
162 | { | |
163 | mDiff[0] = 0.F; | |
164 | mDiff[1] = 0.F; | |
165 | mDiff[2] = 0.F; | |
166 | } | |
167 | mDiff[3] = 1.F; | |
168 | ||
169 | if (NamedStatus & OPENGL_NS_2NDPASSDO) | |
170 | { | |
bf75be98 | 171 | mDiff[3] = prop->env_reflexion; |
2166f0fa SK |
172 | } |
173 | else | |
174 | { | |
175 | if (myUseTransparency) mDiff[3] = prop->trans; | |
176 | // If the material reflects the environment scene, the second pass is needed | |
177 | if (prop->env_reflexion != 0.0) NamedStatus |= OPENGL_NS_2NDPASSNEED; | |
178 | } | |
179 | ||
180 | // Specular component | |
181 | if( rm & OPENGL_SPECULAR_MASK ) | |
182 | { | |
183 | const float *c = prop->isphysic? prop->speccol.rgb : defspeccol; | |
184 | ||
185 | mSpec[0] = prop->spec * c[0]; | |
186 | mSpec[1] = prop->spec * c[1]; | |
187 | mSpec[2] = prop->spec * c[2]; | |
bf75be98 | 188 | } |
2166f0fa SK |
189 | else { |
190 | mSpec[0] = 0.F; | |
191 | mSpec[1] = 0.F; | |
192 | mSpec[2] = 0.F; | |
193 | } | |
194 | mSpec[3] = 1.F; | |
195 | ||
196 | // Emissive component | |
197 | if( rm & OPENGL_EMISSIVE_MASK ) | |
bf75be98 | 198 | { |
2166f0fa SK |
199 | const float *c = prop->isphysic? prop->emscol.rgb : prop->matcol.rgb; |
200 | ||
201 | mEmsv[0] = prop->emsv * c[0]; | |
202 | mEmsv[1] = prop->emsv * c[1]; | |
203 | mEmsv[2] = prop->emsv * c[2]; | |
204 | } | |
205 | else { | |
206 | mEmsv[0] = 0.F; | |
207 | mEmsv[1] = 0.F; | |
208 | mEmsv[2] = 0.F; | |
209 | } | |
210 | mEmsv[3] = 1.F; | |
211 | ||
212 | /* Coeficient de brillance */ | |
213 | mShin = prop->shine; | |
214 | ||
215 | glMaterialfv(face, GL_AMBIENT, mAmb ); | |
216 | glMaterialfv(face, GL_DIFFUSE, mDiff ); | |
217 | glMaterialfv(face, GL_SPECULAR, mSpec); | |
218 | glMaterialfv(face, GL_EMISSION, mEmsv); | |
219 | glMaterialf(face, GL_SHININESS, mShin); | |
220 | ||
221 | NamedStatus &= ~OPENGL_NS_RESMAT; | |
bf75be98 | 222 | } |
2166f0fa SK |
223 | |
224 | // Set Material Optimize | |
bf75be98 | 225 | else |
2166f0fa SK |
226 | { |
227 | // Ambient component | |
228 | if( rm & OPENGL_AMBIENT_MASK ) | |
229 | { | |
230 | const float *c = prop->isphysic? prop->ambcol.rgb : prop->matcol.rgb; | |
231 | ||
232 | if (mAmb[0] != prop->amb * c[0] || | |
233 | mAmb[1] != prop->amb * c[1] || | |
234 | mAmb[2] != prop->amb * c[2] ) | |
235 | { | |
236 | mAmb[0] = prop->amb * c[0]; | |
237 | mAmb[1] = prop->amb * c[1]; | |
238 | mAmb[2] = prop->amb * c[2]; | |
239 | mAmb[3] = 1.F; | |
240 | ||
241 | glMaterialfv(face, GL_AMBIENT, mAmb); | |
242 | } | |
243 | } | |
244 | else | |
245 | { | |
246 | if ( mAmb[0] != 0.F || mAmb[1] != 0.F || mAmb[2] != 0.F ) | |
247 | { | |
248 | mAmb[0] = 0.F; | |
249 | mAmb[1] = 0.F; | |
250 | mAmb[2] = 0.F; | |
251 | mAmb[3] = 1.F; | |
252 | ||
253 | glMaterialfv(face, GL_AMBIENT, mAmb); | |
254 | } | |
255 | } | |
256 | ||
257 | // Diffusion component | |
258 | if( rm & OPENGL_DIFFUSE_MASK ) | |
259 | { | |
260 | const float *c = prop->isphysic? prop->difcol.rgb : prop->matcol.rgb; | |
261 | ||
262 | if (mDiff[0] != prop->diff * c[0] || | |
263 | mDiff[1] != prop->diff * c[1] || | |
264 | mDiff[2] != prop->diff * c[2] || | |
265 | mDiff[3] != ((NamedStatus & OPENGL_NS_2NDPASSDO)? prop->env_reflexion : (myUseTransparency? prop->trans : 1.0F))) | |
266 | { | |
267 | mDiff[0] = prop->diff * c[0]; | |
268 | mDiff[1] = prop->diff * c[1]; | |
269 | mDiff[2] = prop->diff * c[2]; | |
270 | mDiff[3] = 1.F; | |
271 | ||
272 | if (NamedStatus & OPENGL_NS_2NDPASSDO) | |
273 | { | |
bf75be98 | 274 | mDiff[3] = prop->env_reflexion; |
2166f0fa SK |
275 | } |
276 | else | |
277 | { | |
278 | if (myUseTransparency) mDiff[3] = prop->trans; | |
279 | // If the material reflects the environment scene, the second pass is needed | |
280 | if (prop->env_reflexion != 0.0) NamedStatus |= OPENGL_NS_2NDPASSNEED; | |
281 | } | |
282 | ||
283 | glMaterialfv(face, GL_DIFFUSE, mDiff ); | |
284 | } | |
285 | } | |
286 | else | |
287 | { | |
288 | Tfloat newDiff3 = 1.F; | |
289 | ||
290 | if (NamedStatus & OPENGL_NS_2NDPASSDO) | |
291 | { | |
bf75be98 | 292 | newDiff3 = prop->env_reflexion; |
2166f0fa SK |
293 | } |
294 | else | |
295 | { | |
296 | if (myUseTransparency) newDiff3 = prop->trans; | |
297 | // If the material reflects the environment scene, the second pass is needed | |
298 | if (prop->env_reflexion != 0.0) NamedStatus |= OPENGL_NS_2NDPASSNEED; | |
299 | } | |
300 | ||
301 | /* OCC19915: Even if diffuse reflectance is disabled, | |
302 | still trying to update the current transparency if it | |
303 | differs from the previous value */ | |
304 | if ( mDiff[0] != 0.F || mDiff[1] != 0.F || mDiff[2] != 0.F || fabs(mDiff[3] - newDiff3) > 0.01F ) | |
305 | { | |
306 | mDiff[0] = 0.F; | |
307 | mDiff[1] = 0.F; | |
308 | mDiff[2] = 0.F; | |
309 | mDiff[3] = newDiff3; | |
310 | ||
311 | glMaterialfv(face, GL_DIFFUSE, mDiff); | |
312 | } | |
313 | } | |
314 | ||
315 | // Specular component | |
316 | if( rm & OPENGL_SPECULAR_MASK ) | |
bf75be98 | 317 | { |
2166f0fa SK |
318 | const float *c = prop->isphysic? prop->speccol.rgb : defspeccol; |
319 | ||
320 | if (mSpec[0] != prop->spec * c[0] || | |
321 | mSpec[1] != prop->spec * c[1] || | |
322 | mSpec[2] != prop->spec * c[2]) | |
323 | { | |
324 | mSpec[0] = prop->spec * c[0]; | |
325 | mSpec[1] = prop->spec * c[1]; | |
326 | mSpec[2] = prop->spec * c[2]; | |
327 | mSpec[3] = 1.F; | |
328 | ||
329 | glMaterialfv(face, GL_SPECULAR, mSpec); | |
330 | } | |
331 | } | |
332 | else | |
333 | { | |
334 | if ( mSpec[0] != 0.F || mSpec[1] != 0.F || mSpec[2] != 0.F ) | |
335 | { | |
336 | mSpec[0] = 0.F; | |
337 | mSpec[1] = 0.F; | |
338 | mSpec[2] = 0.F; | |
339 | mSpec[3] = 1.F; | |
340 | ||
341 | glMaterialfv(face, GL_SPECULAR, mSpec); | |
342 | } | |
343 | } | |
344 | ||
345 | // Emissive component | |
346 | if( rm & OPENGL_EMISSIVE_MASK ) | |
347 | { | |
348 | const float *c = prop->isphysic? prop->emscol.rgb : prop->matcol.rgb; | |
349 | ||
350 | if (mEmsv[0] != prop->emsv * c[0] || | |
351 | mEmsv[1] != prop->emsv * c[1] || | |
352 | mEmsv[2] != prop->emsv * c[2]) | |
353 | { | |
354 | mEmsv[0] = prop->emsv * c[0]; | |
355 | mEmsv[1] = prop->emsv * c[1]; | |
356 | mEmsv[2] = prop->emsv * c[2]; | |
357 | mEmsv[3] = 1.F; | |
358 | ||
359 | glMaterialfv(face, GL_EMISSION, mEmsv); | |
360 | } | |
361 | } | |
bf75be98 | 362 | else |
363 | { | |
2166f0fa SK |
364 | if ( mEmsv[0] != 0.F || mEmsv[1] != 0.F || mEmsv[2] != 0.F ) |
365 | { | |
366 | mEmsv[0] = 0.F; | |
367 | mEmsv[1] = 0.F; | |
368 | mEmsv[2] = 0.F; | |
369 | mEmsv[3] = 1.F; | |
370 | ||
371 | glMaterialfv(face, GL_EMISSION, mEmsv); | |
372 | } | |
373 | } | |
374 | ||
375 | // Shining coefficient | |
376 | if( mShin != prop->shine ) | |
377 | { | |
378 | mShin = prop->shine; | |
379 | glMaterialf(face, GL_SHININESS, mShin); | |
380 | } | |
381 | } | |
382 | } | |
383 | ||
384 | /*----------------------------------------------------------------------*/ | |
385 | ||
386 | const OpenGl_AspectLine * OpenGl_Workspace::SetAspectLine(const OpenGl_AspectLine *AnAspect) | |
387 | { | |
388 | const OpenGl_AspectLine *AspectLine_old = AspectLine_set; | |
389 | AspectLine_set = AnAspect; | |
390 | return AspectLine_old; | |
391 | } | |
392 | ||
393 | /*----------------------------------------------------------------------*/ | |
394 | ||
395 | const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace(const OpenGl_AspectFace *AnAspect) | |
396 | { | |
397 | const OpenGl_AspectFace *AspectFace_old = AspectFace_set; | |
398 | AspectFace_set = AnAspect; | |
399 | return AspectFace_old; | |
400 | } | |
401 | ||
402 | /*----------------------------------------------------------------------*/ | |
403 | ||
404 | const OpenGl_AspectMarker * OpenGl_Workspace::SetAspectMarker(const OpenGl_AspectMarker *AnAspect) | |
405 | { | |
406 | const OpenGl_AspectMarker *AspectMarker_old = AspectMarker_set; | |
407 | AspectMarker_set = AnAspect; | |
408 | return AspectMarker_old; | |
409 | } | |
410 | ||
411 | /*----------------------------------------------------------------------*/ | |
412 | ||
413 | const OpenGl_AspectText * OpenGl_Workspace::SetAspectText(const OpenGl_AspectText *AnAspect) | |
414 | { | |
415 | const OpenGl_AspectText *AspectText_old = AspectText_set; | |
416 | AspectText_set = AnAspect; | |
417 | return AspectText_old; | |
418 | } | |
419 | ||
420 | /*----------------------------------------------------------------------*/ | |
421 | ||
422 | const OpenGl_Matrix * OpenGl_Workspace::SetViewMatrix(const OpenGl_Matrix *AMatrix) | |
423 | { | |
424 | const OpenGl_Matrix *ViewMatrix_old = ViewMatrix_applied; | |
425 | ViewMatrix_applied = AMatrix; | |
426 | ||
427 | OpenGl_Matrix lmat; | |
428 | OpenGl_Transposemat3( &lmat, StructureMatrix_applied ); | |
429 | ||
430 | glMatrixMode (GL_MODELVIEW); | |
de75ed09 | 431 | OpenGl_Matrix rmat; |
432 | OpenGl_Multiplymat3 (&rmat, &lmat, ViewMatrix_applied); | |
433 | glLoadMatrixf ((const GLfloat* )rmat.mat); | |
2166f0fa SK |
434 | |
435 | return ViewMatrix_old; | |
436 | } | |
437 | ||
438 | /*----------------------------------------------------------------------*/ | |
439 | ||
440 | const OpenGl_Matrix * OpenGl_Workspace::SetStructureMatrix(const OpenGl_Matrix *AMatrix) | |
441 | { | |
442 | const OpenGl_Matrix *StructureMatrix_old = StructureMatrix_applied; | |
443 | StructureMatrix_applied = AMatrix; | |
444 | ||
445 | OpenGl_Matrix lmat; | |
446 | OpenGl_Transposemat3( &lmat, AMatrix ); | |
447 | ||
448 | glMatrixMode (GL_MODELVIEW); | |
de75ed09 | 449 | OpenGl_Matrix rmat; |
450 | OpenGl_Multiplymat3 (&rmat, &lmat, ViewMatrix_applied); | |
451 | glLoadMatrixf ((const GLfloat* )rmat.mat); | |
2166f0fa SK |
452 | |
453 | return StructureMatrix_old; | |
454 | } | |
455 | ||
456 | /*----------------------------------------------------------------------*/ | |
457 | ||
458 | const OpenGl_AspectLine * OpenGl_Workspace::AspectLine(const Standard_Boolean WithApply) | |
459 | { | |
460 | if ( WithApply && (AspectLine_set != AspectLine_applied) ) | |
461 | { | |
462 | glColor3fv(AspectLine_set->Color().rgb); | |
463 | ||
464 | if ( !AspectLine_applied || (AspectLine_set->Type() != AspectLine_applied->Type() ) ) | |
465 | { | |
466 | myDisplay->SetTypeOfLine(AspectLine_set->Type()); | |
467 | } | |
468 | ||
469 | if ( !AspectLine_applied || ( AspectLine_set->Width() != AspectLine_applied->Width() ) ) | |
470 | { | |
471 | glLineWidth( (GLfloat)AspectLine_set->Width() ); | |
472 | #ifdef HAVE_GL2PS | |
473 | gl2psLineWidth( (GLfloat)AspectLine_set->Width() ); | |
474 | #endif | |
475 | } | |
476 | ||
477 | AspectLine_applied = AspectLine_set; | |
478 | } | |
479 | return AspectLine_set; | |
480 | } | |
481 | ||
482 | /*----------------------------------------------------------------------*/ | |
483 | ||
bf75be98 | 484 | const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean theToApply) |
2166f0fa | 485 | { |
bf75be98 | 486 | if (!theToApply || (AspectFace_set == AspectFace_applied)) |
487 | { | |
488 | return AspectFace_set; | |
489 | } | |
490 | ||
491 | const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle; | |
492 | if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle != anIntstyle) | |
2166f0fa | 493 | { |
bf75be98 | 494 | switch (anIntstyle) |
2166f0fa | 495 | { |
bf75be98 | 496 | case Aspect_IS_EMPTY: |
497 | case Aspect_IS_HOLLOW: | |
2166f0fa | 498 | { |
bf75be98 | 499 | glPolygonMode (GL_FRONT_AND_BACK, GL_LINE); |
500 | break; | |
2166f0fa | 501 | } |
bf75be98 | 502 | case Aspect_IS_HATCH: |
503 | { | |
504 | glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); | |
505 | myDisplay->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch : TEL_HS_SOLID); | |
506 | break; | |
507 | } | |
508 | case Aspect_IS_SOLID: | |
509 | case Aspect_IS_HIDDENLINE: | |
510 | { | |
511 | glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); | |
512 | glDisable (GL_POLYGON_STIPPLE); | |
513 | break; | |
514 | } | |
515 | case 5: //szvgl - no corresponding enumeration item Aspect_IS_POINT | |
2166f0fa | 516 | { |
bf75be98 | 517 | glPolygonMode(GL_FRONT_AND_BACK,GL_POINT); |
518 | break; | |
2166f0fa SK |
519 | } |
520 | } | |
bf75be98 | 521 | } |
522 | ||
523 | if (anIntstyle == Aspect_IS_HATCH) | |
524 | { | |
525 | const Tint hatchstyle = AspectFace_set->Hatch; | |
526 | if (AspectFace_applied == NULL || AspectFace_applied->Hatch != hatchstyle) | |
527 | { | |
528 | myDisplay->SetTypeOfHatch(hatchstyle); | |
529 | } | |
530 | } | |
531 | ||
532 | if (!ActiveView()->Backfacing()) | |
533 | { | |
534 | const Tint aCullingMode = AspectFace_set->CullingMode; | |
535 | if (AspectFace_applied == NULL || AspectFace_applied->CullingMode != aCullingMode) | |
2166f0fa | 536 | { |
bf75be98 | 537 | switch ((TelCullMode )aCullingMode) |
2166f0fa | 538 | { |
bf75be98 | 539 | case TelCullNone: |
2166f0fa | 540 | { |
bf75be98 | 541 | glDisable (GL_CULL_FACE); |
542 | break; | |
543 | } | |
544 | case TelCullFront: | |
545 | { | |
546 | glCullFace (GL_FRONT); | |
547 | glEnable (GL_CULL_FACE); | |
548 | break; | |
549 | } | |
550 | case TelCullBack: | |
551 | { | |
552 | glCullFace (GL_BACK); | |
553 | glEnable (GL_CULL_FACE); | |
554 | break; | |
2166f0fa SK |
555 | } |
556 | } | |
557 | } | |
bf75be98 | 558 | } |
2166f0fa | 559 | |
bf75be98 | 560 | // Aspect_POM_None means: do not change current settings |
561 | if ((AspectFace_set->PolygonOffset.mode & Aspect_POM_None) != Aspect_POM_None) | |
562 | { | |
563 | if (PolygonOffset_applied == NULL | |
564 | || PolygonOffset_applied->mode != AspectFace_set->PolygonOffset.mode | |
565 | || PolygonOffset_applied->factor != AspectFace_set->PolygonOffset.factor | |
566 | || PolygonOffset_applied->units != AspectFace_set->PolygonOffset.units) | |
2166f0fa | 567 | { |
bf75be98 | 568 | PolygonOffset_applied = &AspectFace_set->PolygonOffset; |
569 | TelUpdatePolygonOffsets (PolygonOffset_applied); | |
2166f0fa | 570 | } |
bf75be98 | 571 | } |
2166f0fa | 572 | |
bf75be98 | 573 | UpdateMaterial (TEL_FRONT_MATERIAL); |
574 | if (AspectFace_set->DistinguishingMode == TOn) | |
575 | { | |
576 | UpdateMaterial (TEL_BACK_MATERIAL); | |
577 | } | |
2166f0fa | 578 | |
bf75be98 | 579 | if ((NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0) |
580 | { | |
581 | if (AspectFace_set->doTextureMap) | |
582 | { | |
583 | EnableTexture (AspectFace_set->TextureRes, | |
584 | AspectFace_set->TextureParams); | |
585 | } | |
586 | else | |
2166f0fa SK |
587 | { |
588 | DisableTexture(); | |
2166f0fa | 589 | } |
2166f0fa | 590 | } |
bf75be98 | 591 | |
592 | AspectFace_applied = AspectFace_set; | |
2166f0fa SK |
593 | return AspectFace_set; |
594 | } | |
595 | ||
596 | /*----------------------------------------------------------------------*/ | |
597 | ||
17f65eb2 | 598 | const OpenGl_AspectMarker* OpenGl_Workspace::AspectMarker (const Standard_Boolean theToApply) |
2166f0fa | 599 | { |
17f65eb2 | 600 | if (theToApply && (AspectMarker_set != AspectMarker_applied)) |
2166f0fa | 601 | { |
17f65eb2 | 602 | if (!AspectMarker_applied || (AspectMarker_set->Scale() != AspectMarker_applied->Scale())) |
603 | { | |
604 | glPointSize (AspectMarker_set->Scale()); | |
605 | #ifdef HAVE_GL2PS | |
606 | gl2psPointSize (AspectMarker_set->Scale()); | |
607 | #endif | |
608 | } | |
2166f0fa SK |
609 | AspectMarker_applied = AspectMarker_set; |
610 | } | |
611 | return AspectMarker_set; | |
612 | } | |
613 | ||
614 | /*----------------------------------------------------------------------*/ | |
615 | ||
a174a3c5 | 616 | const OpenGl_AspectText* OpenGl_Workspace::AspectText (const Standard_Boolean theWithApply) |
2166f0fa | 617 | { |
a174a3c5 | 618 | if (theWithApply) |
2166f0fa | 619 | { |
a174a3c5 | 620 | AspectText_applied = AspectText_set; |
621 | TextParam_applied = TextParam_set; | |
2166f0fa | 622 | } |
a174a3c5 | 623 | |
2166f0fa SK |
624 | return AspectText_set; |
625 | } |