58a0be673a32d8dd6fe820fc9d84f4df6c12deba
[occt.git] / src / OpenGl / OpenGl_Workspace.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_Workspace.hxx>
17
18 #include <InterfaceGraphic.hxx>
19
20 #include <OpenGl_ArbFBO.hxx>
21 #include <OpenGl_AspectLine.hxx>
22 #include <OpenGl_AspectFace.hxx>
23 #include <OpenGl_AspectMarker.hxx>
24 #include <OpenGl_AspectText.hxx>
25 #include <OpenGl_Context.hxx>
26 #include <OpenGl_Element.hxx>
27 #include <OpenGl_FrameBuffer.hxx>
28 #include <OpenGl_GlCore15.hxx>
29 #include <OpenGl_SceneGeometry.hxx>
30 #include <OpenGl_Structure.hxx>
31 #include <OpenGl_Sampler.hxx>
32 #include <OpenGl_Texture.hxx>
33 #include <OpenGl_View.hxx>
34 #include <OpenGl_Window.hxx>
35
36 #include <Graphic3d_TextureParams.hxx>
37 #include <Graphic3d_TransformUtils.hxx>
38
39 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,Standard_Transient)
40 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_RaytraceFilter,OpenGl_RenderFilter)
41
42 #ifdef HAVE_GL2PS
43   #include <gl2ps.h>
44   /* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
45      Pragma comment for gl2ps.lib is defined only here. */
46   #ifdef _MSC_VER
47   #pragma comment( lib, "gl2ps.lib" )
48   #endif
49 #endif
50
51 namespace
52 {
53   static const TEL_COLOUR  THE_WHITE_COLOR = { { 1.0f, 1.0f, 1.0f, 1.0f } };
54   static const OpenGl_Vec4 THE_BLACK_COLOR      (0.0f, 0.0f, 0.0f, 1.0f);
55
56   static const OpenGl_AspectLine myDefaultAspectLine;
57   static const OpenGl_AspectFace myDefaultAspectFace;
58   static const OpenGl_AspectMarker myDefaultAspectMarker;
59   static const OpenGl_AspectText myDefaultAspectText;
60
61   static const OpenGl_Matrix myDefaultMatrix =
62   {
63     {{ 1.0F, 0.0F, 0.0F, 0.0F },
64      { 0.0F, 1.0F, 0.0F, 0.0F },
65      { 0.0F, 0.0F, 1.0F, 0.0F },
66      { 0.0F, 0.0F, 0.0F, 1.0F }}
67   };
68
69 }
70
71 // =======================================================================
72 // function : Init
73 // purpose  :
74 // =======================================================================
75 void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
76 {
77   // ambient component
78   if (theProp.color_mask & OPENGL_AMBIENT_MASK)
79   {
80     const float* aSrcAmb = theProp.isphysic ? theProp.ambcol.rgb : theProp.matcol.rgb;
81     Ambient = OpenGl_Vec4 (aSrcAmb[0] * theProp.amb,
82                            aSrcAmb[1] * theProp.amb,
83                            aSrcAmb[2] * theProp.amb,
84                            1.0f);
85   }
86   else
87   {
88     Ambient = THE_BLACK_COLOR;
89   }
90
91   // diffusion component
92   if (theProp.color_mask & OPENGL_DIFFUSE_MASK)
93   {
94     const float* aSrcDif = theProp.isphysic ? theProp.difcol.rgb : theProp.matcol.rgb;
95     Diffuse = OpenGl_Vec4 (aSrcDif[0] * theProp.diff,
96                            aSrcDif[1] * theProp.diff,
97                            aSrcDif[2] * theProp.diff,
98                            1.0f);
99   }
100   else
101   {
102     Diffuse = THE_BLACK_COLOR;
103   }
104
105   // specular component
106   if (theProp.color_mask & OPENGL_SPECULAR_MASK)
107   {
108     const float* aSrcSpe = theProp.isphysic ? theProp.speccol.rgb : THE_WHITE_COLOR.rgb;
109     Specular = OpenGl_Vec4 (aSrcSpe[0] * theProp.spec,
110                             aSrcSpe[1] * theProp.spec,
111                             aSrcSpe[2] * theProp.spec,
112                             1.0f);
113   }
114   else
115   {
116     Specular = THE_BLACK_COLOR;
117   }
118
119   // emission component
120   if (theProp.color_mask & OPENGL_EMISSIVE_MASK)
121   {
122     const float* aSrcEms = theProp.isphysic ? theProp.emscol.rgb : theProp.matcol.rgb;
123     Emission = OpenGl_Vec4 (aSrcEms[0] * theProp.emsv,
124                             aSrcEms[1] * theProp.emsv,
125                             aSrcEms[2] * theProp.emsv,
126                             1.0f);
127   }
128   else
129   {
130     Emission = THE_BLACK_COLOR;
131   }
132
133   ChangeShine()        = theProp.shine;
134   ChangeTransparency() = theProp.trans;
135 }
136
137 // =======================================================================
138 // function : OpenGl_Workspace
139 // purpose  :
140 // =======================================================================
141 OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow)
142 : NamedStatus (0),
143   HighlightColor (&THE_WHITE_COLOR),
144   myView (theView),
145   myWindow (theWindow),
146   myGlContext (!theWindow.IsNull() ? theWindow->GetGlContext() : NULL),
147   myUseZBuffer    (Standard_True),
148   myUseDepthWrite (Standard_True),
149   myUseGLLight (Standard_True),
150   //
151   myAspectLineSet (&myDefaultAspectLine),
152   myAspectFaceSet (&myDefaultAspectFace),
153   myAspectFaceApplied (NULL),
154   myAspectMarkerSet (&myDefaultAspectMarker),
155   myAspectMarkerApplied (NULL),
156   myAspectTextSet (&myDefaultAspectText),
157   myAspectFaceAppliedWithHL (false),
158   //
159   ViewMatrix_applied (&myDefaultMatrix),
160   StructureMatrix_applied (&myDefaultMatrix),
161   myCullingMode (TelCullUndefined),
162   myToHighlight (false),
163   myModelViewMatrix (myDefaultMatrix),
164   PolygonOffset_applied (THE_DEFAULT_POFFSET)
165 {
166   if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
167   {
168     myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
169
170     if (!myGlContext->GetResource ("OpenGl_LineAttributes", myLineAttribs))
171     {
172       // share and register for release once the resource is no longer used
173       myLineAttribs = new OpenGl_LineAttributes();
174       myGlContext->ShareResource ("OpenGl_LineAttributes", myLineAttribs);
175       myLineAttribs->Init (myGlContext);
176     }
177
178     // General initialization of the context
179
180   #if !defined(GL_ES_VERSION_2_0)
181     if (myGlContext->core11 != NULL)
182     {
183       // Eviter d'avoir les faces mal orientees en noir.
184       // Pourrait etre utiliser pour detecter les problemes d'orientation
185       glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
186
187       // Optimisation pour le Fog et l'antialiasing
188       glHint (GL_FOG_HINT,            GL_FASTEST);
189       glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
190     }
191
192     glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
193     glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
194   #endif
195   }
196
197   myDefaultCappingAlgoFilter         = new OpenGl_CappingAlgoFilter();
198   myNoneCulling.ChangeCullingMode()  = TelCullNone;
199   myNoneCulling.ChangeEdge()         = 0;
200   myFrontCulling.ChangeCullingMode() = TelCullBack;
201   myFrontCulling.ChangeEdge()        = 0;
202 }
203
204 // =======================================================================
205 // function : ~OpenGl_Workspace
206 // purpose  :
207 // =======================================================================
208 OpenGl_Workspace::~OpenGl_Workspace()
209 {
210   if (!myLineAttribs.IsNull())
211   {
212     myLineAttribs.Nullify();
213     myGlContext->ReleaseResource ("OpenGl_LineAttributes", Standard_True);
214   }
215 }
216
217 // =======================================================================
218 // function : Activate
219 // purpose  :
220 // =======================================================================
221 Standard_Boolean OpenGl_Workspace::Activate()
222 {
223   if (myWindow.IsNull() || !myWindow->Activate())
224   {
225     return Standard_False;
226   }
227
228   ViewMatrix_applied      = &myDefaultMatrix;
229   StructureMatrix_applied = &myDefaultMatrix;
230
231   ResetAppliedAspect();
232
233   return Standard_True;
234 }
235
236 //=======================================================================
237 //function : ResetAppliedAspect
238 //purpose  : Sets default values of GL parameters in accordance with default aspects
239 //=======================================================================
240 void OpenGl_Workspace::ResetAppliedAspect()
241 {
242   myGlContext->BindDefaultVao();
243
244   NamedStatus           = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
245   HighlightColor        = &THE_WHITE_COLOR;
246   myAspectLineSet       = &myDefaultAspectLine;
247   myAspectFaceSet       = &myDefaultAspectFace;
248   myAspectFaceApplied   = NULL;
249   myAspectMarkerSet     = &myDefaultAspectMarker;
250   myAspectMarkerApplied = NULL;
251   myAspectTextSet       = &myDefaultAspectText;
252   PolygonOffset_applied = THE_DEFAULT_POFFSET;
253   myCullingMode         = TelCullUndefined;
254
255   ApplyAspectLine();
256   ApplyAspectFace();
257   ApplyAspectMarker();
258   ApplyAspectText();
259
260   myGlContext->SetTypeOfLine (myDefaultAspectLine.Type());
261   myGlContext->SetLineWidth  (myDefaultAspectLine.Width());
262 }
263
264 // =======================================================================
265 // function : DisableTexture
266 // purpose  :
267 // =======================================================================
268 Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
269 {
270   if (myTextureBound.IsNull())
271   {
272     return myTextureBound;
273   }
274
275   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
276   if (!aSampler.IsNull())
277   {
278     aSampler->Unbind (*myGlContext);
279   }
280
281 #if !defined(GL_ES_VERSION_2_0)
282   // reset texture matrix because some code may expect it is identity
283   if (myGlContext->core11 != NULL)
284   {
285     GLint aMatrixMode = GL_TEXTURE;
286     glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
287     glMatrixMode (GL_TEXTURE);
288     glLoadIdentity();
289     glMatrixMode (aMatrixMode);
290   }
291 #endif
292
293   myTextureBound->Unbind (myGlContext);
294   switch (myTextureBound->GetTarget())
295   {
296   #if !defined(GL_ES_VERSION_2_0)
297     case GL_TEXTURE_1D:
298     {
299       if (myGlContext->core11 != NULL)
300       {
301         if (myTextureBound->GetParams()->GenMode() != GL_NONE)
302         {
303           glDisable (GL_TEXTURE_GEN_S);
304         }
305         glDisable (GL_TEXTURE_1D);
306       }
307       break;
308     }
309   #endif
310     case GL_TEXTURE_2D:
311     {
312     #if !defined(GL_ES_VERSION_2_0)
313       if (myGlContext->core11 != NULL)
314       {
315         if (myTextureBound->GetParams()->GenMode() != GL_NONE)
316         {
317           glDisable (GL_TEXTURE_GEN_S);
318           glDisable (GL_TEXTURE_GEN_T);
319           if (myTextureBound->GetParams()->GenMode() == Graphic3d_TOTM_SPRITE)
320           {
321             glDisable (GL_POINT_SPRITE);
322           }
323         }
324         glDisable (GL_TEXTURE_2D);
325       }
326     #endif
327       break;
328     }
329     default: break;
330   }
331
332   Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
333   myTextureBound.Nullify();
334   return aPrevTexture;
335 }
336
337 // =======================================================================
338 // function : setTextureParams
339 // purpose  :
340 // =======================================================================
341 void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&                theTexture,
342                                          const Handle(Graphic3d_TextureParams)& theParams)
343 {
344   const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
345   if (aParams.IsNull())
346   {
347     return;
348   }
349
350 #if !defined(GL_ES_VERSION_2_0)
351   if (myGlContext->core11 != NULL)
352   {
353     GLint anEnvMode = GL_MODULATE; // lighting mode
354     if (!aParams->IsModulate())
355     {
356       anEnvMode = GL_DECAL;
357       if (theTexture->GetFormat() == GL_ALPHA
358        || theTexture->GetFormat() == GL_LUMINANCE)
359       {
360         anEnvMode = GL_REPLACE;
361       }
362     }
363
364     // setup generation of texture coordinates
365     switch (aParams->GenMode())
366     {
367       case Graphic3d_TOTM_OBJECT:
368       {
369         glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
370         glTexGenfv (GL_S, GL_OBJECT_PLANE,     aParams->GenPlaneS().GetData());
371         if (theTexture->GetTarget() != GL_TEXTURE_1D)
372         {
373           glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
374           glTexGenfv (GL_T, GL_OBJECT_PLANE,     aParams->GenPlaneT().GetData());
375         }
376         break;
377       }
378       case Graphic3d_TOTM_SPHERE:
379       {
380         glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
381         if (theTexture->GetTarget() != GL_TEXTURE_1D)
382         {
383           glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
384         }
385         break;
386       }
387       case Graphic3d_TOTM_EYE:
388       {
389         myGlContext->WorldViewState.Push();
390
391         myGlContext->WorldViewState.SetIdentity();
392         myGlContext->ApplyWorldViewMatrix();
393
394         glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
395         glTexGenfv (GL_S, GL_EYE_PLANE,        aParams->GenPlaneS().GetData());
396
397         if (theTexture->GetTarget() != GL_TEXTURE_1D)
398         {
399           glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
400           glTexGenfv (GL_T, GL_EYE_PLANE,        aParams->GenPlaneT().GetData());
401         }
402
403         myGlContext->WorldViewState.Pop();
404
405         break;
406       }
407       case Graphic3d_TOTM_SPRITE:
408       {
409         if (myGlContext->core20fwd != NULL)
410         {
411           glEnable  (GL_POINT_SPRITE);
412           glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
413           anEnvMode = GL_REPLACE;
414           myGlContext->core15->glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
415         }
416         break;
417       }
418       case Graphic3d_TOTM_MANUAL:
419       default: break;
420     }
421
422     // setup lighting
423     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, anEnvMode);
424   }
425 #endif
426
427   // get active sampler object to override default texture parameters
428   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
429
430   // setup texture filtering and wrapping
431   //if (theTexture->GetParams() != theParams)
432   const GLenum aFilter   = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
433   const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : myGlContext->TextureWrapClamp();
434   switch (theTexture->GetTarget())
435   {
436   #if !defined(GL_ES_VERSION_2_0)
437     case GL_TEXTURE_1D:
438     {
439       if (aSampler.IsNull() || !aSampler->IsValid())
440       {
441         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
442         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
443         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
444       }
445       else
446       {
447         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
448         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilter);
449         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
450       }
451
452       break;
453     }
454   #endif
455     case GL_TEXTURE_2D:
456     {
457       GLenum aFilterMin = aFilter;
458       if (theTexture->HasMipmaps())
459       {
460         aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
461         if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
462         {
463           aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
464         }
465         else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
466         {
467           aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
468         }
469
470         if (myGlContext->extAnis)
471         {
472           // setup degree of anisotropy filter
473           const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
474           GLint aDegree;
475           switch (aParams->AnisoFilter())
476           {
477             case Graphic3d_LOTA_QUALITY:
478             {
479               aDegree = aMaxDegree;
480               break;
481             }
482             case Graphic3d_LOTA_MIDDLE:
483             {
484               aDegree = (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2);
485               break;
486             }
487             case Graphic3d_LOTA_FAST:
488             {
489               aDegree = 2;
490               break;
491             }
492             case Graphic3d_LOTA_OFF:
493             default:
494             {
495               aDegree = 1;
496               break;
497             }
498           }
499
500           if (aSampler.IsNull() || !aSampler->IsValid())
501           {
502             glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
503           }
504           else
505           {
506             aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
507           }
508         }
509       }
510
511       if (aSampler.IsNull() || !aSampler->IsValid())
512       {
513         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
514         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
515         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
516         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
517       }
518       else
519       {
520         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilterMin);
521         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
522         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
523         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_T,     aWrapMode);
524       }
525
526       break;
527     }
528     default: break;
529   }
530
531   switch (theTexture->GetTarget())
532   {
533   #if !defined(GL_ES_VERSION_2_0)
534     case GL_TEXTURE_1D:
535     {
536       if (myGlContext->core11 != NULL)
537       {
538         if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
539         {
540           glEnable (GL_TEXTURE_GEN_S);
541         }
542         glEnable (GL_TEXTURE_1D);
543       }
544       break;
545     }
546   #endif
547     case GL_TEXTURE_2D:
548     {
549     #if !defined(GL_ES_VERSION_2_0)
550       if (myGlContext->core11 != NULL)
551       {
552         if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
553         {
554           glEnable (GL_TEXTURE_GEN_S);
555           glEnable (GL_TEXTURE_GEN_T);
556         }
557         glEnable (GL_TEXTURE_2D);
558       }
559     #endif
560       break;
561     }
562     default: break;
563   }
564
565   theTexture->SetParams (aParams);
566 }
567
568 // =======================================================================
569 // function : EnableTexture
570 // purpose  :
571 // =======================================================================
572 Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
573                                                         const Handle(Graphic3d_TextureParams)& theParams)
574 {
575   if (theTexture.IsNull() || !theTexture->IsValid())
576   {
577     return DisableTexture();
578   }
579
580   if (myTextureBound == theTexture
581    && (theParams.IsNull() || theParams == theTexture->GetParams()))
582   {
583     // already bound
584     return myTextureBound;
585   }
586
587   Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
588   myTextureBound = theTexture;
589   myTextureBound->Bind (myGlContext);
590   setTextureParams (myTextureBound, theParams);
591
592   // If custom sampler object is available it will be
593   // used for overriding default texture parameters
594   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
595
596   if (!aSampler.IsNull() && aSampler->IsValid())
597   {
598     aSampler->Bind (*myGlContext);
599   }
600
601   return aPrevTexture;
602 }
603
604 // =======================================================================
605 // function : TelUpdatePolygonOffsets
606 // purpose  :
607 // =======================================================================
608 static void TelUpdatePolygonOffsets (const TEL_POFFSET_PARAM& theOffsetData)
609 {
610   if ((theOffsetData.mode & Aspect_POM_Fill) == Aspect_POM_Fill)
611   {
612     glEnable (GL_POLYGON_OFFSET_FILL);
613   }
614   else
615   {
616     glDisable (GL_POLYGON_OFFSET_FILL);
617   }
618
619 #if !defined(GL_ES_VERSION_2_0)
620   if ((theOffsetData.mode & Aspect_POM_Line) == Aspect_POM_Line)
621   {
622     glEnable (GL_POLYGON_OFFSET_LINE);
623   }
624   else
625   {
626     glDisable (GL_POLYGON_OFFSET_LINE);
627   }
628
629   if ((theOffsetData.mode & Aspect_POM_Point) == Aspect_POM_Point)
630   {
631     glEnable (GL_POLYGON_OFFSET_POINT);
632   }
633   else
634   {
635     glDisable (GL_POLYGON_OFFSET_POINT);
636   }
637 #endif
638
639   glPolygonOffset (theOffsetData.factor, theOffsetData.units);
640 }
641
642 // =======================================================================
643 // function : updateMaterial
644 // purpose  :
645 // =======================================================================
646 void OpenGl_Workspace::updateMaterial (const int theFlag)
647 {
648   // Case of hidden line
649   if (myAspectFaceSet->InteriorStyle() == Aspect_IS_HIDDENLINE)
650   {
651     myAspectFaceHl = *myAspectFaceSet; // copy all values including line edge aspect
652     myAspectFaceHl.ChangeIntFront().matcol     = myView->BackgroundColor();
653     myAspectFaceHl.ChangeIntFront().color_mask = 0;
654     myAspectFaceHl.ChangeIntFront().color_mask = 0;
655
656     myAspectFaceSet = &myAspectFaceHl;
657     return;
658   }
659
660   const OPENGL_SURF_PROP* aProps = &myAspectFaceSet->IntFront();
661   GLenum aFace = GL_FRONT_AND_BACK;
662   if (theFlag == TEL_BACK_MATERIAL)
663   {
664     aFace  = GL_BACK;
665     aProps = &myAspectFaceSet->IntBack();
666   }
667   else if (myAspectFaceSet->DistinguishingMode() == TOn
668         && !(NamedStatus & OPENGL_NS_RESMAT))
669   {
670     aFace = GL_FRONT;
671   }
672
673   myMatTmp.Init (*aProps);
674   if (myToHighlight)
675   {
676     myMatTmp.SetColor (*(const OpenGl_Vec4* )HighlightColor);
677   }
678
679   // handling transparency
680   if (NamedStatus & OPENGL_NS_2NDPASSDO)
681   {
682     // second pass
683     myMatTmp.Diffuse.a() = aProps->env_reflexion;
684   }
685   else
686   {
687     if (aProps->env_reflexion != 0.0f)
688     {
689       // if the material reflects the environment scene, the second pass is needed
690       NamedStatus |= OPENGL_NS_2NDPASSNEED;
691     }
692
693     if (aProps->trans != 1.0f)
694     {
695       // render transparent
696       myMatTmp.Diffuse.a() = aProps->trans;
697       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
698       glEnable    (GL_BLEND);
699       if (myUseDepthWrite)
700       {
701         glDepthMask (GL_FALSE);
702       }
703     }
704     else
705     {
706       // render opaque
707       if ((NamedStatus & OPENGL_NS_ANTIALIASING) == 0)
708       {
709         glBlendFunc (GL_ONE, GL_ZERO);
710         glDisable   (GL_BLEND);
711       }
712       if (myUseDepthWrite)
713       {
714         glDepthMask (GL_TRUE);
715       }
716     }
717   }
718
719   // do not update material properties in case of zero reflection mode,
720   // because GL lighting will be disabled by OpenGl_PrimitiveArray::DrawArray() anyway.
721   if (aProps->color_mask == 0)
722   {
723     return;
724   }
725
726   // reset material
727   if (NamedStatus & OPENGL_NS_RESMAT)
728   {
729   #if !defined(GL_ES_VERSION_2_0)
730     if (myGlContext->core11 != NULL)
731     {
732       myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT,   myMatTmp.Ambient.GetData());
733       myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE,   myMatTmp.Diffuse.GetData());
734       myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR,  myMatTmp.Specular.GetData());
735       myGlContext->core11->glMaterialfv (aFace, GL_EMISSION,  myMatTmp.Emission.GetData());
736       myGlContext->core11->glMaterialf  (aFace, GL_SHININESS, myMatTmp.Shine());
737     }
738   #endif
739
740     if (theFlag == TEL_FRONT_MATERIAL)
741     {
742       myMatFront = myMatTmp;
743       myMatBack  = myMatTmp;
744     }
745     else
746     {
747       myMatBack = myMatTmp;
748     }
749
750     NamedStatus &= ~OPENGL_NS_RESMAT;
751     return;
752   }
753
754   // reduce updates
755   OpenGl_Material& anOld = (theFlag == TEL_FRONT_MATERIAL)
756                          ? myMatFront
757                          : myMatBack;
758 #if !defined(GL_ES_VERSION_2_0)
759   if (myGlContext->core11 != NULL)
760   {
761     if (myMatTmp.Ambient.r() != anOld.Ambient.r()
762      || myMatTmp.Ambient.g() != anOld.Ambient.g()
763      || myMatTmp.Ambient.b() != anOld.Ambient.b())
764     {
765       myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT, myMatTmp.Ambient.GetData());
766     }
767     if (myMatTmp.Diffuse.r() != anOld.Diffuse.r()
768      || myMatTmp.Diffuse.g() != anOld.Diffuse.g()
769      || myMatTmp.Diffuse.b() != anOld.Diffuse.b()
770      || fabs (myMatTmp.Diffuse.a() - anOld.Diffuse.a()) > 0.01f)
771     {
772       myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE, myMatTmp.Diffuse.GetData());
773     }
774     if (myMatTmp.Specular.r() != anOld.Specular.r()
775      || myMatTmp.Specular.g() != anOld.Specular.g()
776      || myMatTmp.Specular.b() != anOld.Specular.b())
777     {
778       myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR, myMatTmp.Specular.GetData());
779     }
780     if (myMatTmp.Emission.r() != anOld.Emission.r()
781      || myMatTmp.Emission.g() != anOld.Emission.g()
782      || myMatTmp.Emission.b() != anOld.Emission.b())
783     {
784       myGlContext->core11->glMaterialfv (aFace, GL_EMISSION, myMatTmp.Emission.GetData());
785     }
786     if (myMatTmp.Shine() != anOld.Shine())
787     {
788       myGlContext->core11->glMaterialf (aFace, GL_SHININESS, myMatTmp.Shine());
789     }
790   }
791 #endif
792   anOld = myMatTmp;
793   if (aFace == GL_FRONT_AND_BACK)
794   {
795     myMatBack = myMatTmp;
796   }
797 }
798
799 // =======================================================================
800 // function : SetAspectLine
801 // purpose  :
802 // =======================================================================
803 const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
804 {
805   const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
806   myAspectLineSet = theAspect;
807   return aPrevAspectLine;
808 }
809
810 // =======================================================================
811 // function : SetAspectFace
812 // purpose  :
813 // =======================================================================
814 const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
815 {
816   const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
817   myAspectFaceSet = theAspect;
818   return aPrevAspectFace;
819 }
820
821 // =======================================================================
822 // function : SetAspectMarker
823 // purpose  :
824 // =======================================================================
825 const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
826 {
827   const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
828   myAspectMarkerSet = theAspect;
829   return aPrevAspectMarker;
830 }
831
832 // =======================================================================
833 // function : SetAspectText
834 // purpose  :
835 // =======================================================================
836 const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
837 {
838   const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
839   myAspectTextSet = theAspect;
840   return aPrevAspectText;
841 }
842
843 // =======================================================================
844 // function : ApplyAspectFace
845 // purpose  :
846 // =======================================================================
847 const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
848 {
849   if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
850   {
851     // manage back face culling mode, disable culling when clipping is enabled
852     TelCullMode aCullingMode = (myGlContext->Clipping().IsClippingOrCappingOn()
853                              || myAspectFaceSet->InteriorStyle() == Aspect_IS_HATCH)
854                              ? TelCullNone
855                              : (TelCullMode )myAspectFaceSet->CullingMode();
856     if (aCullingMode != TelCullNone
857      && !(NamedStatus & OPENGL_NS_2NDPASSDO))
858     {
859       // disable culling in case of translucent shading aspect
860       if (myAspectFaceSet->IntFront().trans != 1.0f)
861       {
862         aCullingMode = TelCullNone;
863       }
864     }
865     if (myCullingMode != aCullingMode)
866     {
867       myCullingMode = aCullingMode;
868       switch (myCullingMode)
869       {
870         case TelCullNone:
871         case TelCullUndefined:
872         {
873           glDisable (GL_CULL_FACE);
874           break;
875         }
876         case TelCullFront:
877         {
878           glCullFace (GL_FRONT);
879           glEnable (GL_CULL_FACE);
880           break;
881         }
882         case TelCullBack:
883         {
884           glCullFace (GL_BACK);
885           glEnable (GL_CULL_FACE);
886           break;
887         }
888       }
889     }
890   }
891
892   if (myAspectFaceSet == myAspectFaceApplied
893    && myToHighlight == myAspectFaceAppliedWithHL)
894   {
895     return myAspectFaceSet;
896   }
897   myAspectFaceAppliedWithHL = myToHighlight;
898
899 #if !defined(GL_ES_VERSION_2_0)
900   const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->InteriorStyle();
901   if (myAspectFaceApplied == NULL
902    || myAspectFaceApplied->InteriorStyle() != anIntstyle)
903   {
904     switch (anIntstyle)
905     {
906       case Aspect_IS_EMPTY:
907       case Aspect_IS_HOLLOW:
908       {
909         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
910         break;
911       }
912       case Aspect_IS_HATCH:
913       {
914         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
915         myLineAttribs->SetTypeOfHatch (myAspectFaceApplied != NULL ? myAspectFaceApplied->Hatch() : TEL_HS_SOLID);
916         break;
917       }
918       case Aspect_IS_SOLID:
919       case Aspect_IS_HIDDENLINE:
920       {
921         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
922         if (myGlContext->core11 != NULL)
923         {
924           glDisable (GL_POLYGON_STIPPLE);
925         }
926         break;
927       }
928       case Aspect_IS_POINT:
929       {
930         glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);
931         break;
932       }
933     }
934   }
935
936   if (anIntstyle == Aspect_IS_HATCH)
937   {
938     const Tint hatchstyle = myAspectFaceSet->Hatch();
939     if (myAspectFaceApplied == NULL
940      || myAspectFaceApplied->Hatch() != hatchstyle)
941     {
942       myLineAttribs->SetTypeOfHatch (hatchstyle);
943     }
944   }
945 #endif
946
947   // Aspect_POM_None means: do not change current settings
948   if ((myAspectFaceSet->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
949   {
950     if (PolygonOffset_applied.mode   != myAspectFaceSet->PolygonOffset().mode
951      || PolygonOffset_applied.factor != myAspectFaceSet->PolygonOffset().factor
952      || PolygonOffset_applied.units  != myAspectFaceSet->PolygonOffset().units)
953     {
954       SetPolygonOffset (myAspectFaceSet->PolygonOffset().mode,
955                         myAspectFaceSet->PolygonOffset().factor,
956                         myAspectFaceSet->PolygonOffset().units);
957     }
958   }
959
960   updateMaterial (TEL_FRONT_MATERIAL);
961   if (myAspectFaceSet->DistinguishingMode() == TOn)
962   {
963     updateMaterial (TEL_BACK_MATERIAL);
964   }
965
966   if (myAspectFaceSet->DoTextureMap())
967   {
968     EnableTexture (myAspectFaceSet->TextureRes (myGlContext),
969                    myAspectFaceSet->TextureParams());
970   }
971   else
972   {
973     if (!myEnvironmentTexture.IsNull())
974     {
975       EnableTexture (myEnvironmentTexture,
976                      myEnvironmentTexture->GetParams());
977     }
978     else
979     {
980       DisableTexture();
981     }
982   }
983
984   myAspectFaceApplied = myAspectFaceSet;
985   return myAspectFaceSet;
986 }
987
988 //=======================================================================
989 //function : SetPolygonOffset
990 //purpose  :
991 //=======================================================================
992 void OpenGl_Workspace::SetPolygonOffset (int theMode,
993                                          Standard_ShortReal theFactor,
994                                          Standard_ShortReal theUnits)
995 {
996   PolygonOffset_applied.mode   = theMode;
997   PolygonOffset_applied.factor = theFactor;
998   PolygonOffset_applied.units  = theUnits;
999
1000   TelUpdatePolygonOffsets (PolygonOffset_applied);
1001 }
1002
1003 // =======================================================================
1004 // function : ApplyAspectMarker
1005 // purpose  :
1006 // =======================================================================
1007 const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
1008 {
1009   if (myAspectMarkerSet != myAspectMarkerApplied)
1010   {
1011     if (myAspectMarkerApplied == NULL
1012     || (myAspectMarkerSet->Scale() != myAspectMarkerApplied->Scale()))
1013     {
1014     #if !defined(GL_ES_VERSION_2_0)
1015       glPointSize (myAspectMarkerSet->Scale());
1016     #ifdef HAVE_GL2PS
1017       gl2psPointSize (myAspectMarkerSet->Scale());
1018     #endif
1019     #endif
1020     }
1021     myAspectMarkerApplied = myAspectMarkerSet;
1022   }
1023   return myAspectMarkerSet;
1024 }
1025
1026 // =======================================================================
1027 // function : Width
1028 // purpose  :
1029 // =======================================================================
1030 Standard_Integer OpenGl_Workspace::Width()  const
1031 {
1032   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Width() : 0;
1033 }
1034
1035 // =======================================================================
1036 // function : Height
1037 // purpose  :
1038 // =======================================================================
1039 Standard_Integer OpenGl_Workspace::Height() const
1040 {
1041   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Height() : 0;
1042 }
1043
1044 // =======================================================================
1045 // function : UseGLLight
1046 // purpose  :
1047 // =======================================================================
1048 Standard_Boolean OpenGl_Workspace::UseGLLight() const
1049 {
1050   return myView->IsGLLightEnabled();
1051 }
1052
1053 // =======================================================================
1054 // function : AntiAliasingMode
1055 // purpose  :
1056 // =======================================================================
1057 Standard_Integer OpenGl_Workspace::AntiAliasingMode() const
1058 {
1059   return myView->IsAntialiasingEnabled();
1060 }
1061
1062 // =======================================================================
1063 // function : IsCullingEnabled
1064 // purpose  :
1065 // =======================================================================
1066 Standard_Boolean OpenGl_Workspace::IsCullingEnabled() const
1067 {
1068   return myView->IsCullingEnabled();
1069 }
1070
1071 // =======================================================================
1072 // function : FBOCreate
1073 // purpose  :
1074 // =======================================================================
1075 Handle(OpenGl_FrameBuffer) OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
1076                                                         const Standard_Integer theHeight)
1077 {
1078   // activate OpenGL context
1079   if (!Activate())
1080     return Handle(OpenGl_FrameBuffer)();
1081
1082   DisableTexture();
1083
1084   // create the FBO
1085   const Handle(OpenGl_Context)& aCtx = GetGlContext();
1086   Handle(OpenGl_FrameBuffer) aFrameBuffer = new OpenGl_FrameBuffer();
1087   if (!aFrameBuffer->Init (aCtx, theWidth, theHeight, GL_RGBA8, GL_DEPTH24_STENCIL8, 0))
1088   {
1089     aFrameBuffer->Release (aCtx.operator->());
1090     return Handle(OpenGl_FrameBuffer)();
1091   }
1092   return aFrameBuffer;
1093 }
1094
1095 // =======================================================================
1096 // function : FBORelease
1097 // purpose  :
1098 // =======================================================================
1099 void OpenGl_Workspace::FBORelease (Handle(OpenGl_FrameBuffer)& theFbo)
1100 {
1101   // activate OpenGL context
1102   if (!Activate()
1103    || theFbo.IsNull())
1104   {
1105     return;
1106   }
1107
1108   theFbo->Release (GetGlContext().operator->());
1109   theFbo.Nullify();
1110 }
1111
1112 inline bool getDataFormat (const Image_PixMap& theData,
1113                            GLenum&             thePixelFormat,
1114                            GLenum&             theDataType)
1115 {
1116   thePixelFormat = GL_RGB;
1117   theDataType    = GL_UNSIGNED_BYTE;
1118   switch (theData.Format())
1119   {
1120   #if !defined(GL_ES_VERSION_2_0)
1121     case Image_PixMap::ImgGray:
1122       thePixelFormat = GL_DEPTH_COMPONENT;
1123       theDataType    = GL_UNSIGNED_BYTE;
1124       return true;
1125     case Image_PixMap::ImgGrayF:
1126       thePixelFormat = GL_DEPTH_COMPONENT;
1127       theDataType    = GL_FLOAT;
1128       return true;
1129     case Image_PixMap::ImgBGR:
1130       thePixelFormat = GL_BGR;
1131       theDataType    = GL_UNSIGNED_BYTE;
1132       return true;
1133     case Image_PixMap::ImgBGRA:
1134     case Image_PixMap::ImgBGR32:
1135       thePixelFormat = GL_BGRA;
1136       theDataType    = GL_UNSIGNED_BYTE;
1137       return true;
1138     case Image_PixMap::ImgBGRF:
1139       thePixelFormat = GL_BGR;
1140       theDataType    = GL_FLOAT;
1141       return true;
1142     case Image_PixMap::ImgBGRAF:
1143       thePixelFormat = GL_BGRA;
1144       theDataType    = GL_FLOAT;
1145       return true;
1146   #else
1147     case Image_PixMap::ImgGray:
1148     case Image_PixMap::ImgGrayF:
1149     case Image_PixMap::ImgBGR:
1150     case Image_PixMap::ImgBGRA:
1151     case Image_PixMap::ImgBGR32:
1152     case Image_PixMap::ImgBGRF:
1153     case Image_PixMap::ImgBGRAF:
1154       return false;
1155   #endif
1156     case Image_PixMap::ImgRGB:
1157       thePixelFormat = GL_RGB;
1158       theDataType    = GL_UNSIGNED_BYTE;
1159       return true;
1160     case Image_PixMap::ImgRGBA:
1161     case Image_PixMap::ImgRGB32:
1162       thePixelFormat = GL_RGBA;
1163       theDataType    = GL_UNSIGNED_BYTE;
1164       return true;
1165     case Image_PixMap::ImgRGBF:
1166       thePixelFormat = GL_RGB;
1167       theDataType    = GL_FLOAT;
1168       return true;
1169     case Image_PixMap::ImgRGBAF:
1170       thePixelFormat = GL_RGBA;
1171       theDataType    = GL_FLOAT;
1172       return true;
1173     case Image_PixMap::ImgAlpha:
1174     case Image_PixMap::ImgAlphaF:
1175       return false; // GL_ALPHA is no more supported in core context
1176     case Image_PixMap::ImgUNKNOWN:
1177       return false;
1178   }
1179   return false;
1180 }
1181
1182 // =======================================================================
1183 // function : getAligned
1184 // purpose  :
1185 // =======================================================================
1186 inline Standard_Size getAligned (const Standard_Size theNumber,
1187                                  const Standard_Size theAlignment)
1188 {
1189   return theNumber + theAlignment - 1 - (theNumber - 1) % theAlignment;
1190 }
1191
1192 // =======================================================================
1193 // function : BufferDump
1194 // purpose  :
1195 // =======================================================================
1196 Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
1197                                                Image_PixMap&                     theImage,
1198                                                const Graphic3d_BufferType&       theBufferType)
1199 {
1200   GLenum aFormat, aType;
1201   if (theImage.IsEmpty()
1202    || !getDataFormat (theImage, aFormat, aType)
1203    || !Activate())
1204   {
1205     return Standard_False;
1206   }
1207 #if !defined(GL_ES_VERSION_2_0)
1208   GLint aReadBufferPrev = GL_BACK;
1209   if (theBufferType == Graphic3d_BT_Depth
1210    && aFormat != GL_DEPTH_COMPONENT)
1211   {
1212     return Standard_False;
1213   }
1214 #else
1215   (void )theBufferType;
1216 #endif
1217
1218   // bind FBO if used
1219   if (!theFbo.IsNull() && theFbo->IsValid())
1220   {
1221     theFbo->BindBuffer (GetGlContext());
1222   }
1223   else
1224   {
1225   #if !defined(GL_ES_VERSION_2_0)
1226     glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
1227     GLint aDrawBufferPrev = GL_BACK;
1228     glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
1229     glReadBuffer (aDrawBufferPrev);
1230   #endif
1231   }
1232
1233   // setup alignment
1234   const GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
1235   glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
1236   bool isBatchCopy = !theImage.IsTopDown();
1237
1238   const GLint   anExtraBytes       = GLint(theImage.RowExtraBytes());
1239   GLint         aPixelsWidth       = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
1240   Standard_Size aSizeRowBytesEstim = getAligned (theImage.SizePixelBytes() * aPixelsWidth, anAligment);
1241   if (anExtraBytes < anAligment)
1242   {
1243     aPixelsWidth = 0;
1244   }
1245   else if (aSizeRowBytesEstim != theImage.SizeRowBytes())
1246   {
1247     aPixelsWidth = 0;
1248     isBatchCopy  = false;
1249   }
1250 #if !defined(GL_ES_VERSION_2_0)
1251   glPixelStorei (GL_PACK_ROW_LENGTH, aPixelsWidth);
1252 #else
1253   if (aPixelsWidth != 0)
1254   {
1255     isBatchCopy = false;
1256   }
1257 #endif
1258
1259   if (!isBatchCopy)
1260   {
1261     // copy row by row
1262     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
1263     {
1264       // Image_PixMap rows indexation always starts from the upper corner
1265       // while order in memory depends on the flag and processed by ChangeRow() method
1266       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
1267     }
1268   }
1269   else
1270   {
1271     glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
1272   }
1273
1274   glPixelStorei (GL_PACK_ALIGNMENT,  1);
1275 #if !defined(GL_ES_VERSION_2_0)
1276   glPixelStorei (GL_PACK_ROW_LENGTH, 0);
1277 #endif
1278
1279   if (!theFbo.IsNull() && theFbo->IsValid())
1280   {
1281     theFbo->UnbindBuffer (GetGlContext());
1282   }
1283   else
1284   {
1285   #if !defined(GL_ES_VERSION_2_0)
1286     glReadBuffer (aReadBufferPrev);
1287   #endif
1288   }
1289   return Standard_True;
1290 }
1291
1292 // =======================================================================
1293 // function : CanRender
1294 // purpose  :
1295 // =======================================================================
1296 Standard_Boolean OpenGl_RaytraceFilter::CanRender (const OpenGl_Element* theElement)
1297 {
1298   Standard_Boolean aPrevFilterResult = Standard_True;
1299   if (!myPrevRenderFilter.IsNull())
1300   {
1301     aPrevFilterResult = myPrevRenderFilter->CanRender (theElement);
1302   }
1303   return aPrevFilterResult &&
1304     !OpenGl_Raytrace::IsRaytracedElement (theElement);
1305 }