0028738: Data Exchange, XCAFPrs_Style - add transparency property
[occt.git] / src / OpenGl / OpenGl_LayerList.cxx
1 // Created on: 2012-02-02
2 // Created by: Anton POLETAEV
3 // Copyright (c) 2012-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_GlCore15.hxx>
17
18 #include <OpenGl_FrameBuffer.hxx>
19 #include <OpenGl_LayerList.hxx>
20 #include <OpenGl_ShaderManager.hxx>
21 #include <OpenGl_Structure.hxx>
22 #include <OpenGl_VertexBuffer.hxx>
23 #include <OpenGl_View.hxx>
24 #include <OpenGl_Workspace.hxx>
25
26 #include <Graphic3d_GraphicDriver.hxx>
27
28 //=======================================================================
29 //function : OpenGl_LayerList
30 //purpose  : Constructor
31 //=======================================================================
32
33 OpenGl_LayerList::OpenGl_LayerList (const Standard_Integer theNbPriorities)
34 : myDefaultLayerIndex (0),
35   myNbPriorities (theNbPriorities),
36   myNbStructures (0),
37   myImmediateNbStructures (0),
38   myModifStateOfRaytraceable (0),
39   myRenderOpaqueFilter (new OpenGl_OpaqueFilter()),
40   myRenderTranspFilter (new OpenGl_TransparentFilter())
41 {
42   // insert default priority layers
43   myLayers.Append (OpenGl_Layer (myNbPriorities));
44   myLayerIds.Bind (Graphic3d_ZLayerId_BotOSD,  myLayers.Upper());
45
46   myLayers.Append (OpenGl_Layer (myNbPriorities));
47   myLayerIds.Bind (Graphic3d_ZLayerId_Default, myLayers.Upper());
48
49   myLayers.Append (OpenGl_Layer (myNbPriorities));
50   myLayerIds.Bind (Graphic3d_ZLayerId_Top,     myLayers.Upper());
51
52   myLayers.Append (OpenGl_Layer (myNbPriorities));
53   myLayerIds.Bind (Graphic3d_ZLayerId_Topmost, myLayers.Upper());
54
55   myLayers.Append (OpenGl_Layer (myNbPriorities));
56   myLayerIds.Bind (Graphic3d_ZLayerId_TopOSD,  myLayers.Upper());
57
58   myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
59
60   myTransparentToProcess.Allocate (myLayers.Length());
61 }
62
63 //=======================================================================
64 //function : ~OpenGl_LayerList
65 //purpose  : Destructor
66 //=======================================================================
67
68 OpenGl_LayerList::~OpenGl_LayerList()
69 {
70 }
71
72 //=======================================================================
73 //function : AddLayer
74 //purpose  : 
75 //=======================================================================
76
77 void OpenGl_LayerList::AddLayer (const Graphic3d_ZLayerId theLayerId)
78 {
79   if (myLayerIds.IsBound (theLayerId))
80   {
81     return;
82   }
83
84   // add the new layer
85   myLayers.Append (OpenGl_Layer (myNbPriorities));
86   myLayerIds.Bind (theLayerId, myLayers.Length());
87
88   myTransparentToProcess.Allocate (myLayers.Length());
89 }
90
91 //=======================================================================
92 //function : Layer
93 //purpose  : 
94 //=======================================================================
95 OpenGl_Layer& OpenGl_LayerList::Layer (const Graphic3d_ZLayerId theLayerId)
96 {
97   return myLayers.ChangeValue (myLayerIds.Find (theLayerId));
98 }
99
100 //=======================================================================
101 //function : Layer
102 //purpose  : 
103 //=======================================================================
104 const OpenGl_Layer& OpenGl_LayerList::Layer (const Graphic3d_ZLayerId theLayerId) const
105 {
106   return myLayers.Value (myLayerIds.Find (theLayerId));
107 }
108
109 //=======================================================================
110 //function : RemoveLayer
111 //purpose  :
112 //=======================================================================
113
114 void OpenGl_LayerList::RemoveLayer (const Graphic3d_ZLayerId theLayerId)
115 {
116   if (!myLayerIds.IsBound (theLayerId)
117     || theLayerId <= 0)
118   {
119     return;
120   }
121
122   const Standard_Integer aRemovePos = myLayerIds.Find (theLayerId);
123   
124   // move all displayed structures to first layer
125   const OpenGl_Layer& aLayerToMove = myLayers.Value (aRemovePos);
126   myLayers.ChangeFirst().Append (aLayerToMove);
127
128   // remove layer
129   myLayers.Remove (aRemovePos);
130   myLayerIds.UnBind (theLayerId);
131
132   // updated sequence indexes in map
133   for (OpenGl_LayerSeqIds::Iterator aMapIt (myLayerIds); aMapIt.More(); aMapIt.Next())
134   {
135     Standard_Integer& aSeqIdx = aMapIt.ChangeValue();
136     if (aSeqIdx > aRemovePos)
137       aSeqIdx--;
138   }
139
140   myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
141
142   myTransparentToProcess.Allocate (myLayers.Length());
143 }
144
145 //=======================================================================
146 //function : AddStructure
147 //purpose  :
148 //=======================================================================
149
150 void OpenGl_LayerList::AddStructure (const OpenGl_Structure*  theStruct,
151                                      const Graphic3d_ZLayerId theLayerId,
152                                      const Standard_Integer   thePriority,
153                                      Standard_Boolean         isForChangePriority)
154 {
155   // add structure to associated layer,
156   // if layer doesn't exists, display structure in default layer
157   Standard_Integer aSeqPos = myLayers.Lower();
158   myLayerIds.Find (theLayerId, aSeqPos);
159
160   OpenGl_Layer& aLayer = myLayers.ChangeValue (aSeqPos);
161   aLayer.Add (theStruct, thePriority, isForChangePriority);
162   ++myNbStructures;
163   if (aLayer.IsImmediate())
164   {
165     ++myImmediateNbStructures;
166   }
167
168   // Note: In ray-tracing mode we don't modify modification
169   // state here. It is redundant, because the possible changes
170   // will be handled in the loop for structures
171 }
172
173 //=======================================================================
174 //function : RemoveStructure
175 //purpose  :
176 //=======================================================================
177
178 void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure* theStructure)
179 {
180   const Graphic3d_ZLayerId aLayerId = theStructure->ZLayer();
181
182   Standard_Integer aSeqPos = myLayers.Lower();
183   myLayerIds.Find (aLayerId, aSeqPos);
184
185   OpenGl_Layer&    aLayer    = myLayers.ChangeValue (aSeqPos);
186   Standard_Integer aPriority = -1;
187
188   // remove structure from associated list
189   // if the structure is not found there,
190   // scan through layers and remove it
191   if (aLayer.Remove (theStructure, aPriority))
192   {
193     --myNbStructures;
194     if (aLayer.IsImmediate())
195     {
196       --myImmediateNbStructures;
197     }
198
199     if (aLayerId == Graphic3d_ZLayerId_Default
200      && theStructure->IsRaytracable())
201     {
202       ++myModifStateOfRaytraceable;
203     }
204
205     return;
206   }
207
208   // scan through layers and remove it
209   Standard_Integer aSeqId = 1;
210   for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
211   {
212     OpenGl_Layer& aLayerEx = anIts.ChangeValue();
213     if (aSeqPos == aSeqId)
214     {
215       continue;
216     }
217
218     if (aLayerEx.Remove (theStructure, aPriority))
219     {
220       --myNbStructures;
221       if (aLayerEx.IsImmediate())
222       {
223         --myImmediateNbStructures;
224       }
225
226       if (aSeqId == myDefaultLayerIndex
227        && theStructure->IsRaytracable())
228       {
229         ++myModifStateOfRaytraceable;
230       }
231       return;
232     }
233   }
234 }
235
236 //=======================================================================
237 //function : InvalidateBVHData
238 //purpose  :
239 //=======================================================================
240 void OpenGl_LayerList::InvalidateBVHData (const Graphic3d_ZLayerId theLayerId)
241 {
242   Standard_Integer aSeqPos = myLayers.Lower();
243   myLayerIds.Find (theLayerId, aSeqPos);
244   OpenGl_Layer& aLayer = myLayers.ChangeValue (aSeqPos);
245   aLayer.InvalidateBVHData();
246 }
247
248 //=======================================================================
249 //function : ChangeLayer
250 //purpose  :
251 //=======================================================================
252
253 void OpenGl_LayerList::ChangeLayer (const OpenGl_Structure*  theStructure,
254                                     const Graphic3d_ZLayerId theOldLayerId,
255                                     const Graphic3d_ZLayerId theNewLayerId)
256 {
257   Standard_Integer aSeqPos = myLayers.Lower();
258   myLayerIds.Find (theOldLayerId, aSeqPos);
259   OpenGl_Layer&    aLayer    = myLayers.ChangeValue (aSeqPos);
260   Standard_Integer aPriority = -1;
261
262   // take priority and remove structure from list found by <theOldLayerId>
263   // if the structure is not found there, scan through all other layers
264   if (aLayer.Remove (theStructure, aPriority, Standard_False))
265   {
266     if (theOldLayerId == Graphic3d_ZLayerId_Default
267      && theStructure->IsRaytracable())
268     {
269       ++myModifStateOfRaytraceable;
270     }
271
272     --myNbStructures;
273     if (aLayer.IsImmediate())
274     {
275       --myImmediateNbStructures;
276     }
277
278     // isForChangePriority should be Standard_False below, because we want
279     // the BVH tree in the target layer to be updated with theStructure
280     AddStructure (theStructure, theNewLayerId, aPriority);
281     return;
282   }
283
284   // scan through layers and remove it
285   Standard_Integer aSeqId = 1;
286   for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
287   {
288     if (aSeqPos == aSeqId)
289     {
290       continue;
291     }
292   
293     // try to remove structure and get priority value from this layer
294     OpenGl_Layer& aLayerEx = anIts.ChangeValue();
295     if (aLayerEx.Remove (theStructure, aPriority, Standard_True))
296     {
297       if (aSeqId == myDefaultLayerIndex
298        && theStructure->IsRaytracable())
299       {
300         ++myModifStateOfRaytraceable;
301       }
302
303       --myNbStructures;
304       if (aLayerEx.IsImmediate())
305       {
306         --myImmediateNbStructures;
307       }
308
309       // isForChangePriority should be Standard_False below, because we want
310       // the BVH tree in the target layer to be updated with theStructure
311       AddStructure (theStructure, theNewLayerId, aPriority);
312       return;
313     }
314   }
315 }
316
317 //=======================================================================
318 //function : ChangePriority
319 //purpose  :
320 //=======================================================================
321 void OpenGl_LayerList::ChangePriority (const OpenGl_Structure*  theStructure,
322                                        const Graphic3d_ZLayerId theLayerId,
323                                        const Standard_Integer   theNewPriority)
324 {
325   Standard_Integer aSeqPos = myLayers.Lower();
326   myLayerIds.Find (theLayerId, aSeqPos);
327   OpenGl_Layer&    aLayer        = myLayers.ChangeValue (aSeqPos);
328   Standard_Integer anOldPriority = -1;
329
330   if (aLayer.Remove (theStructure, anOldPriority, Standard_True))
331   {
332     --myNbStructures;
333     if (aLayer.IsImmediate())
334     {
335       --myImmediateNbStructures;
336     }
337
338     AddStructure (theStructure, theLayerId, theNewPriority, Standard_True);
339     return;
340   }
341
342   Standard_Integer aSeqId = 1;
343   for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
344   {
345     if (aSeqPos == aSeqId)
346     {
347       continue;
348     }
349
350     OpenGl_Layer& aLayerEx = anIts.ChangeValue();
351     if (aLayerEx.Remove (theStructure, anOldPriority, Standard_True))
352     {
353       --myNbStructures;
354       if (aLayerEx.IsImmediate())
355       {
356         --myImmediateNbStructures;
357       }
358
359       AddStructure (theStructure, theLayerId, theNewPriority, Standard_True);
360       return;
361     }
362   }
363 }
364
365 //=======================================================================
366 //function : SetLayerSettings
367 //purpose  :
368 //=======================================================================
369 void OpenGl_LayerList::SetLayerSettings (const Graphic3d_ZLayerId        theLayerId,
370                                          const Graphic3d_ZLayerSettings& theSettings)
371 {
372   OpenGl_Layer& aLayer = Layer (theLayerId);
373   if (aLayer.LayerSettings().IsImmediate() != theSettings.IsImmediate())
374   {
375     if (theSettings.IsImmediate())
376     {
377       myImmediateNbStructures += aLayer.NbStructures();
378     }
379     else
380     {
381       myImmediateNbStructures -= aLayer.NbStructures();
382     }
383   }
384   aLayer.SetLayerSettings (theSettings);
385 }
386
387 //=======================================================================
388 //function : Render
389 //purpose  :
390 //=======================================================================
391 void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
392                                const Standard_Boolean          theToDrawImmediate,
393                                const OpenGl_LayerFilter        theLayersToProcess,
394                                OpenGl_FrameBuffer*             theReadDrawFbo,
395                                OpenGl_FrameBuffer*             theOitAccumFbo) const
396 {
397   // Remember global settings for glDepth function and write mask.
398   OpenGl_GlobalLayerSettings aDefaultSettings;
399
400   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
401   aCtx->core11fwd->glGetIntegerv (GL_DEPTH_FUNC,      &aDefaultSettings.DepthFunc);
402   aCtx->core11fwd->glGetBooleanv (GL_DEPTH_WRITEMASK, &aDefaultSettings.DepthMask);
403
404   // Two render filters are used to support transparency draw. Opaque filter accepts
405   // only non-transparent OpenGl elements of a layer and counts number of skipped
406   // transparent ones. If the counter has positive value the layer is added into
407   // transparency post-processing stack. At the end of drawing or once the depth
408   // buffer is to be cleared the layers in the stack should be drawn using
409   // blending and depth mask settings and another transparency filter which accepts
410   // only transparent OpenGl elements of a layer. The stack <myTransparentToProcess>
411   // was preallocated before going into this method and has enough space to keep
412   // maximum number of references to layers, therefore it will not increase memory
413   // fragmentation during regular rendering.
414   const Handle(OpenGl_RenderFilter) aPrevFilter = theWorkspace->GetRenderFilter();
415   myRenderOpaqueFilter->SetPreviousFilter (aPrevFilter);
416   myRenderTranspFilter->SetPreviousFilter (aPrevFilter);
417   theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
418
419   myTransparentToProcess.Clear();
420
421   OpenGl_LayerStack::iterator aStackIter (myTransparentToProcess.Origin());
422   Standard_Integer aSeqId = myLayers.Lower();
423   bool toClearDepth = false;
424   for (OpenGl_SequenceOfLayers::Iterator aLayerIter (myLayers); aLayerIter.More(); aLayerIter.Next(), ++aSeqId)
425   {
426     if (theLayersToProcess == OpenGl_LF_Bottom)
427     {
428       if (aSeqId >= myDefaultLayerIndex) continue;
429     }
430     else if (theLayersToProcess == OpenGl_LF_Upper)
431     {
432       if (aSeqId <= myDefaultLayerIndex) continue;
433     }
434     else if (theLayersToProcess == OpenGl_LF_Default)
435     {
436       if (aSeqId != myDefaultLayerIndex) continue;
437     }
438
439     const OpenGl_Layer& aLayer = aLayerIter.Value();
440     if (aLayer.IsImmediate() != theToDrawImmediate)
441     {
442       continue;
443     }
444     else if (aLayer.NbStructures() < 1)
445     {
446       // Make sure to clear depth of previous layers even if layer has no structures.
447       toClearDepth = toClearDepth || aLayer.LayerSettings().ToClearDepth();
448       continue;
449     }
450
451     // At this point the depth buffer may be set to clear by
452     // previous configuration of layers or configuration of the
453     // current layer. Additional rendering pass to handle transparent
454     // elements of recently drawn layers require use of current depth
455     // buffer so we put remaining layers for processing as one bunch before
456     // erasing the depth buffer.
457     if (toClearDepth
458      || aLayer.LayerSettings().ToClearDepth())
459     {
460       if (!myTransparentToProcess.IsEmpty())
461       {
462         renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
463       }
464
465       toClearDepth = false;
466       glDepthMask (GL_TRUE);
467       glClear (GL_DEPTH_BUFFER_BIT);
468     }
469
470     // Render opaque OpenGl elements of a layer and count the number of skipped.
471     // If a layer has skipped (e.g. transparent) elements it should be added into
472     // the transparency post-processing stack.
473     myRenderOpaqueFilter->SetSkippedCounter (0);
474
475     aLayer.Render (theWorkspace, aDefaultSettings);
476
477     if (myRenderOpaqueFilter->NbSkipped() > 0)
478     {
479       myTransparentToProcess.Push (&aLayer);
480     }
481   }
482
483   // Before finishing process the remaining collected layers with transparency.
484   if (!myTransparentToProcess.IsEmpty())
485   {
486     renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
487   }
488
489   if (toClearDepth)
490   {
491     glDepthMask (GL_TRUE);
492     glClear (GL_DEPTH_BUFFER_BIT);
493   }
494
495   aCtx->core11fwd->glDepthMask (aDefaultSettings.DepthMask);
496   aCtx->core11fwd->glDepthFunc (aDefaultSettings.DepthFunc);
497
498   theWorkspace->SetRenderFilter (aPrevFilter);
499 }
500
501 //=======================================================================
502 //function : renderTransparent
503 //purpose  : Render transparent objects using blending operator.
504 //=======================================================================
505 void OpenGl_LayerList::renderTransparent (const Handle(OpenGl_Workspace)&   theWorkspace,
506                                           OpenGl_LayerStack::iterator&      theLayerIter,
507                                           const OpenGl_GlobalLayerSettings& theGlobalSettings,
508                                           OpenGl_FrameBuffer*               theReadDrawFbo,
509                                           OpenGl_FrameBuffer*               theOitAccumFbo) const
510 {
511   // Blended order-independent transparency algorithm require several preconditions
512   // to be enabled. It should be requested by user, at least two outputs from
513   // fragment shader should be supported by GPU, so is the given framebuffer
514   // should contain two additional color buffers to handle accumulated color channels,
515   // blended alpha channel and weight factors - these accumulation buffers are required
516   // to implement commuting blend operator (at least OpenGl 2.0 should be available).
517   const bool isEnabledOit = theOitAccumFbo != NULL
518                          && theOitAccumFbo->NbColorBuffers() >= 2
519                          && theOitAccumFbo->ColorTexture (0)->IsValid()
520                          && theOitAccumFbo->ColorTexture (1)->IsValid();
521
522   // Check if current iterator has already reached the end of the stack.
523   // This should happen if no additional layers has been added to
524   // the processing stack after last transparency pass.
525   if (theLayerIter == myTransparentToProcess.Back())
526   {
527     return;
528   }
529
530   const Handle(OpenGl_Context) aCtx            = theWorkspace->GetGlContext();
531   const Handle(OpenGl_ShaderManager)& aManager = aCtx->ShaderManager();
532   OpenGl_View* aView = theWorkspace->View();
533   const float aDepthFactor =  aView != NULL ? aView->RenderingParams().OitDepthFactor : 0.0f;
534
535   theWorkspace->SetRenderFilter (myRenderTranspFilter);
536
537   aCtx->core11fwd->glEnable (GL_BLEND);
538
539   if (isEnabledOit)
540   {
541     aManager->SetOitState (true, aDepthFactor);
542
543     theOitAccumFbo->BindBuffer (aCtx);
544
545     static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT0 + 1 };
546     aCtx->SetDrawBuffers (2, aDrawBuffers);
547     aCtx->core11fwd->glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
548     aCtx->core11fwd->glClear (GL_COLOR_BUFFER_BIT);
549     aCtx->core15fwd->glBlendFuncSeparate (GL_ONE, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
550   }
551   else
552   {
553     aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
554   }
555
556   // During blended order-independent transparency pass the depth test
557   // should be enabled to discard fragments covered by opaque geometry
558   // and depth writing should be disabled, because transparent fragments
559   // overal each other with non unitary coverage factor.
560   OpenGl_GlobalLayerSettings aGlobalSettings = theGlobalSettings;
561   aGlobalSettings.DepthMask   = GL_FALSE;
562   aCtx->core11fwd->glDepthMask (GL_FALSE);
563
564   for (; theLayerIter != myTransparentToProcess.Back(); ++theLayerIter)
565   {
566     (*theLayerIter)->Render (theWorkspace, aGlobalSettings);
567   }
568
569   // Revert state of rendering.
570   if (isEnabledOit)
571   {
572     aManager->SetOitState (false, aDepthFactor);
573     theOitAccumFbo->UnbindBuffer (aCtx);
574     if (theReadDrawFbo)
575     {
576       theReadDrawFbo->BindBuffer (aCtx);
577     }
578
579     static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
580     aCtx->SetDrawBuffers (1, aDrawBuffers);
581   }
582
583   theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
584   if (isEnabledOit)
585   {
586     const Standard_Boolean isMSAA = theReadDrawFbo && theReadDrawFbo->NbSamples() > 0;
587     OpenGl_VertexBuffer*   aVerts = theWorkspace->View()->initBlitQuad (Standard_False);
588     if (aVerts->IsValid() && aManager->BindOitCompositingProgram (isMSAA))
589     {
590       aCtx->core11fwd->glDepthFunc (GL_ALWAYS);
591       aCtx->core11fwd->glDepthMask (GL_FALSE);
592
593       // Bind full screen quad buffer and framebuffer resources.
594       aVerts->BindVertexAttrib (aCtx, Graphic3d_TOA_POS);
595
596       const Handle(OpenGl_Texture) aTextureBack = theWorkspace->DisableTexture();
597
598       theOitAccumFbo->ColorTexture (0)->Bind (aCtx, GL_TEXTURE0 + 0);
599       theOitAccumFbo->ColorTexture (1)->Bind (aCtx, GL_TEXTURE0 + 1);
600
601       // Draw full screen quad with special shader to compose the buffers.
602       aCtx->core11fwd->glBlendFunc (GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
603       aCtx->core11fwd->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
604
605       // Unbind OpenGL texture objects and shader program.
606       aVerts->UnbindVertexAttrib (aCtx, Graphic3d_TOA_POS);
607       theOitAccumFbo->ColorTexture (0)->Unbind (aCtx, GL_TEXTURE0 + 0);
608       theOitAccumFbo->ColorTexture (1)->Unbind (aCtx, GL_TEXTURE0 + 1);
609       aCtx->BindProgram (NULL);
610
611       if (!aTextureBack.IsNull())
612       {
613         theWorkspace->EnableTexture (aTextureBack);
614       }
615     }
616     else
617     {
618       aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
619                          "Initialization of OIT compositing pass has failed.\n"
620                          "  Blended order-independent transparency will not be available.\n");
621       if (aView != NULL)
622       {
623         Standard_Boolean& aOITFlag = isMSAA ? aView->myToDisableOITMSAA : aView->myToDisableOIT;
624         aOITFlag = Standard_True;
625       }
626     }
627   }
628
629   aCtx->core11fwd->glDisable (GL_BLEND);
630   aCtx->core11fwd->glBlendFunc (GL_ONE, GL_ZERO);
631   aCtx->core11fwd->glDepthMask (theGlobalSettings.DepthMask);
632   aCtx->core11fwd->glDepthFunc (theGlobalSettings.DepthFunc);
633 }
634
635 //=======================================================================
636 //class    : OpenGl_OpaqueFilter
637 //function : ShouldRender
638 //purpose  : Checks whether the element should be rendered or skipped.
639 //=======================================================================
640 Standard_Boolean OpenGl_LayerList::OpenGl_OpaqueFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
641                                                                       const OpenGl_Element*           theGlElement)
642 {
643   if (!myFilter.IsNull()
644    && !myFilter->ShouldRender (theWorkspace, theGlElement))
645   {
646     return Standard_False;
647   }
648
649   const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
650   if (aPArray == NULL
651    || aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
652    || aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
653   {
654     return Standard_True;
655   }
656
657   if (OpenGl_Context::CheckIsTransparent (theWorkspace->AspectFace(),
658                                           theWorkspace->HighlightStyle()))
659   {
660     ++mySkippedCounter;
661     return Standard_False;
662   }
663
664   return Standard_True;
665 }
666
667 //=======================================================================
668 //class    : OpenGl_TransparentFilter
669 //function : ShouldRender
670 //purpose  : Checks whether the element should be rendered or skipped.
671 //=======================================================================
672 Standard_Boolean OpenGl_LayerList::OpenGl_TransparentFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
673                                                                            const OpenGl_Element*           theGlElement)
674 {
675   if (!myFilter.IsNull()
676    && !myFilter->ShouldRender (theWorkspace, theGlElement))
677   {
678     return Standard_False;
679   }
680
681   const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
682   if (aPArray == NULL
683    || aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
684    || aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
685   {
686     return dynamic_cast<const OpenGl_AspectFace*> (theGlElement) != NULL;
687   }
688
689   return OpenGl_Context::CheckIsTransparent (theWorkspace->AspectFace(),
690                                              theWorkspace->HighlightStyle());
691 }