0028738: Data Exchange, XCAFPrs_Style - add transparency property
[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 <OpenGl_ArbFBO.hxx>
19 #include <OpenGl_AspectLine.hxx>
20 #include <OpenGl_AspectFace.hxx>
21 #include <OpenGl_AspectMarker.hxx>
22 #include <OpenGl_AspectText.hxx>
23 #include <OpenGl_Context.hxx>
24 #include <OpenGl_Element.hxx>
25 #include <OpenGl_FrameBuffer.hxx>
26 #include <OpenGl_GlCore15.hxx>
27 #include <OpenGl_SceneGeometry.hxx>
28 #include <OpenGl_Structure.hxx>
29 #include <OpenGl_Sampler.hxx>
30 #include <OpenGl_ShaderManager.hxx>
31 #include <OpenGl_Texture.hxx>
32 #include <OpenGl_View.hxx>
33 #include <OpenGl_Window.hxx>
34
35 #include <Graphic3d_TextureParams.hxx>
36 #include <Graphic3d_TransformUtils.hxx>
37 #include <NCollection_AlignedAllocator.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 OpenGl_Vec4 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 Graphic3d_MaterialAspect& theMat,
76                             const Quantity_Color&           theInteriorColor)
77 {
78   const bool isPhysic = theMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
79   ChangeShine()        = 128.0f * theMat.Shininess();
80   ChangeTransparency() = theMat.Alpha();
81
82   // ambient component
83   if (theMat.ReflectionMode (Graphic3d_TOR_AMBIENT))
84   {
85     const OpenGl_Vec3& aSrcAmb = isPhysic ? theMat.AmbientColor() : theInteriorColor;
86     Ambient = OpenGl_Vec4 (aSrcAmb * theMat.Ambient(), 1.0f);
87   }
88   else
89   {
90     Ambient = THE_BLACK_COLOR;
91   }
92
93   // diffusion component
94   if (theMat.ReflectionMode (Graphic3d_TOR_DIFFUSE))
95   {
96     const OpenGl_Vec3& aSrcDif = isPhysic ? theMat.DiffuseColor() : theInteriorColor;
97     Diffuse = OpenGl_Vec4 (aSrcDif * theMat.Diffuse(), 1.0f);
98   }
99   else
100   {
101     Diffuse = THE_BLACK_COLOR;
102   }
103
104   // specular component
105   if (theMat.ReflectionMode (Graphic3d_TOR_SPECULAR))
106   {
107     const OpenGl_Vec3& aSrcSpe = isPhysic ? (const OpenGl_Vec3& )theMat.SpecularColor() : THE_WHITE_COLOR.rgb();
108     Specular = OpenGl_Vec4 (aSrcSpe * theMat.Specular(), 1.0f);
109   }
110   else
111   {
112     Specular = THE_BLACK_COLOR;
113   }
114
115   // emission component
116   if (theMat.ReflectionMode (Graphic3d_TOR_EMISSION))
117   {
118     const OpenGl_Vec3& aSrcEms = isPhysic ? theMat.EmissiveColor() : theInteriorColor;
119     Emission = OpenGl_Vec4 (aSrcEms * theMat.Emissive(), 1.0f);
120   }
121   else
122   {
123     Emission = THE_BLACK_COLOR;
124   }
125 }
126
127 // =======================================================================
128 // function : OpenGl_Workspace
129 // purpose  :
130 // =======================================================================
131 OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow)
132 : myView (theView),
133   myWindow (theWindow),
134   myGlContext (!theWindow.IsNull() ? theWindow->GetGlContext() : NULL),
135   myUseZBuffer    (Standard_True),
136   myUseDepthWrite (Standard_True),
137   //
138   myAspectLineSet (&myDefaultAspectLine),
139   myAspectFaceSet (&myDefaultAspectFace),
140   myAspectMarkerSet (&myDefaultAspectMarker),
141   myAspectTextSet (&myDefaultAspectText),
142   //
143   ViewMatrix_applied (&myDefaultMatrix),
144   StructureMatrix_applied (&myDefaultMatrix),
145   myToAllowFaceCulling (false),
146   myModelViewMatrix (myDefaultMatrix)
147 {
148   if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
149   {
150     myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
151
152     // General initialization of the context
153   #if !defined(GL_ES_VERSION_2_0)
154     if (myGlContext->core11 != NULL)
155     {
156       // Eviter d'avoir les faces mal orientees en noir.
157       // Pourrait etre utiliser pour detecter les problemes d'orientation
158       glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
159
160       // Optimisation pour le Fog et l'antialiasing
161       glHint (GL_FOG_HINT,            GL_FASTEST);
162       glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
163     }
164
165     glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
166     glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
167   #endif
168   }
169
170   myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter();
171
172   myNoneCulling .Aspect()->SetSuppressBackFaces (false);
173   myNoneCulling .Aspect()->SetDrawEdges (false);
174   myFrontCulling.Aspect()->SetSuppressBackFaces (true);
175   myFrontCulling.Aspect()->SetDrawEdges (false);
176 }
177
178 // =======================================================================
179 // function : Activate
180 // purpose  :
181 // =======================================================================
182 Standard_Boolean OpenGl_Workspace::Activate()
183 {
184   if (myWindow.IsNull() || !myWindow->Activate())
185   {
186     return Standard_False;
187   }
188
189   ViewMatrix_applied      = &myDefaultMatrix;
190   StructureMatrix_applied = &myDefaultMatrix;
191
192   ResetAppliedAspect();
193
194   // reset state for safety
195   myGlContext->BindProgram (Handle(OpenGl_ShaderProgram)());
196   if (myGlContext->core20fwd != NULL)
197   {
198     myGlContext->core20fwd->glUseProgram (OpenGl_ShaderProgram::NO_PROGRAM);
199   }
200   myGlContext->ShaderManager()->PushState (Handle(OpenGl_ShaderProgram)());
201   return Standard_True;
202 }
203
204 //=======================================================================
205 //function : ResetAppliedAspect
206 //purpose  : Sets default values of GL parameters in accordance with default aspects
207 //=======================================================================
208 void OpenGl_Workspace::ResetAppliedAspect()
209 {
210   myGlContext->BindDefaultVao();
211
212   myHighlightStyle.Nullify();
213   myToAllowFaceCulling  = false;
214   myAspectLineSet       = &myDefaultAspectLine;
215   myAspectFaceSet       = &myDefaultAspectFace;
216   myAspectFaceApplied.Nullify();
217   myAspectMarkerSet     = &myDefaultAspectMarker;
218   myAspectMarkerApplied.Nullify();
219   myAspectTextSet       = &myDefaultAspectText;
220   myPolygonOffsetApplied= Graphic3d_PolygonOffset();
221
222   ApplyAspectLine();
223   ApplyAspectFace();
224   ApplyAspectMarker();
225   ApplyAspectText();
226
227   myGlContext->SetTypeOfLine (myDefaultAspectLine.Aspect()->Type());
228   myGlContext->SetLineWidth  (myDefaultAspectLine.Aspect()->Width());
229 }
230
231 // =======================================================================
232 // function : DisableTexture
233 // purpose  :
234 // =======================================================================
235 Handle(OpenGl_Texture) OpenGl_Workspace::DisableTexture()
236 {
237   if (myTextureBound.IsNull())
238   {
239     return myTextureBound;
240   }
241
242   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
243   if (!aSampler.IsNull())
244   {
245     aSampler->Unbind (*myGlContext);
246   }
247
248 #if !defined(GL_ES_VERSION_2_0)
249   // reset texture matrix because some code may expect it is identity
250   if (myGlContext->core11 != NULL)
251   {
252     GLint aMatrixMode = GL_TEXTURE;
253     glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
254     glMatrixMode (GL_TEXTURE);
255     glLoadIdentity();
256     glMatrixMode (aMatrixMode);
257   }
258 #endif
259
260   myTextureBound->Unbind (myGlContext);
261   switch (myTextureBound->GetTarget())
262   {
263   #if !defined(GL_ES_VERSION_2_0)
264     case GL_TEXTURE_1D:
265     {
266       if (myGlContext->core11 != NULL)
267       {
268         if (myTextureBound->GetParams()->GenMode() != GL_NONE)
269         {
270           glDisable (GL_TEXTURE_GEN_S);
271         }
272         glDisable (GL_TEXTURE_1D);
273       }
274       break;
275     }
276   #endif
277     case GL_TEXTURE_2D:
278     {
279     #if !defined(GL_ES_VERSION_2_0)
280       if (myGlContext->core11 != NULL)
281       {
282         if (myTextureBound->GetParams()->GenMode() != GL_NONE)
283         {
284           glDisable (GL_TEXTURE_GEN_S);
285           glDisable (GL_TEXTURE_GEN_T);
286           if (myTextureBound->GetParams()->GenMode() == Graphic3d_TOTM_SPRITE)
287           {
288             glDisable (GL_POINT_SPRITE);
289           }
290         }
291         glDisable (GL_TEXTURE_2D);
292       }
293     #endif
294       break;
295     }
296     default: break;
297   }
298
299   Handle(OpenGl_Texture) aPrevTexture = myTextureBound;
300   myTextureBound.Nullify();
301   return aPrevTexture;
302 }
303
304 // =======================================================================
305 // function : setTextureParams
306 // purpose  :
307 // =======================================================================
308 void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&                theTexture,
309                                          const Handle(Graphic3d_TextureParams)& theParams)
310 {
311   const Handle(Graphic3d_TextureParams)& aParams = theParams.IsNull() ? theTexture->GetParams() : theParams;
312   if (aParams.IsNull())
313   {
314     return;
315   }
316
317 #if !defined(GL_ES_VERSION_2_0)
318   if (myGlContext->core11 != NULL)
319   {
320     GLint anEnvMode = GL_MODULATE; // lighting mode
321     if (!aParams->IsModulate())
322     {
323       anEnvMode = GL_DECAL;
324       if (theTexture->GetFormat() == GL_ALPHA
325        || theTexture->GetFormat() == GL_LUMINANCE)
326       {
327         anEnvMode = GL_REPLACE;
328       }
329     }
330
331     // setup generation of texture coordinates
332     switch (aParams->GenMode())
333     {
334       case Graphic3d_TOTM_OBJECT:
335       {
336         glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
337         glTexGenfv (GL_S, GL_OBJECT_PLANE,     aParams->GenPlaneS().GetData());
338         if (theTexture->GetTarget() != GL_TEXTURE_1D)
339         {
340           glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
341           glTexGenfv (GL_T, GL_OBJECT_PLANE,     aParams->GenPlaneT().GetData());
342         }
343         break;
344       }
345       case Graphic3d_TOTM_SPHERE:
346       {
347         glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
348         if (theTexture->GetTarget() != GL_TEXTURE_1D)
349         {
350           glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
351         }
352         break;
353       }
354       case Graphic3d_TOTM_EYE:
355       {
356         myGlContext->WorldViewState.Push();
357
358         myGlContext->WorldViewState.SetIdentity();
359         myGlContext->ApplyWorldViewMatrix();
360
361         glTexGeni  (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
362         glTexGenfv (GL_S, GL_EYE_PLANE,        aParams->GenPlaneS().GetData());
363
364         if (theTexture->GetTarget() != GL_TEXTURE_1D)
365         {
366           glTexGeni  (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
367           glTexGenfv (GL_T, GL_EYE_PLANE,        aParams->GenPlaneT().GetData());
368         }
369
370         myGlContext->WorldViewState.Pop();
371
372         break;
373       }
374       case Graphic3d_TOTM_SPRITE:
375       {
376         if (myGlContext->core20fwd != NULL)
377         {
378           glEnable  (GL_POINT_SPRITE);
379           glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
380           anEnvMode = GL_REPLACE;
381         }
382         break;
383       }
384       case Graphic3d_TOTM_MANUAL:
385       default: break;
386     }
387
388     // setup lighting
389     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, anEnvMode);
390   }
391 #endif
392
393   // get active sampler object to override default texture parameters
394   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
395
396   // setup texture filtering and wrapping
397   //if (theTexture->GetParams() != theParams)
398   const GLenum aFilter   = (aParams->Filter() == Graphic3d_TOTF_NEAREST) ? GL_NEAREST : GL_LINEAR;
399   const GLenum aWrapMode = aParams->IsRepeat() ? GL_REPEAT : myGlContext->TextureWrapClamp();
400   switch (theTexture->GetTarget())
401   {
402   #if !defined(GL_ES_VERSION_2_0)
403     case GL_TEXTURE_1D:
404     {
405       if (aSampler.IsNull() || !aSampler->IsValid())
406       {
407         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, aFilter);
408         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, aFilter);
409         glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,     aWrapMode);
410       }
411       else
412       {
413         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
414         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilter);
415         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
416       }
417
418       break;
419     }
420   #endif
421     case GL_TEXTURE_2D:
422     {
423       GLenum aFilterMin = aFilter;
424       if (theTexture->HasMipmaps())
425       {
426         aFilterMin = GL_NEAREST_MIPMAP_NEAREST;
427         if (aParams->Filter() == Graphic3d_TOTF_BILINEAR)
428         {
429           aFilterMin = GL_LINEAR_MIPMAP_NEAREST;
430         }
431         else if (aParams->Filter() == Graphic3d_TOTF_TRILINEAR)
432         {
433           aFilterMin = GL_LINEAR_MIPMAP_LINEAR;
434         }
435
436         if (myGlContext->extAnis)
437         {
438           // setup degree of anisotropy filter
439           const GLint aMaxDegree = myGlContext->MaxDegreeOfAnisotropy();
440           GLint aDegree;
441           switch (aParams->AnisoFilter())
442           {
443             case Graphic3d_LOTA_QUALITY:
444             {
445               aDegree = aMaxDegree;
446               break;
447             }
448             case Graphic3d_LOTA_MIDDLE:
449             {
450               aDegree = (aMaxDegree <= 4) ? 2 : (aMaxDegree / 2);
451               break;
452             }
453             case Graphic3d_LOTA_FAST:
454             {
455               aDegree = 2;
456               break;
457             }
458             case Graphic3d_LOTA_OFF:
459             default:
460             {
461               aDegree = 1;
462               break;
463             }
464           }
465
466           if (aSampler.IsNull() || !aSampler->IsValid())
467           {
468             glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
469           }
470           else
471           {
472             aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAX_ANISOTROPY_EXT, aDegree);
473           }
474         }
475       }
476
477       if (aSampler.IsNull() || !aSampler->IsValid())
478       {
479         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, aFilterMin);
480         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter);
481         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     aWrapMode);
482         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     aWrapMode);
483       }
484       else
485       {
486         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MIN_FILTER, aFilterMin);
487         aSampler->SetParameter (*myGlContext, GL_TEXTURE_MAG_FILTER, aFilter);
488         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_S,     aWrapMode);
489         aSampler->SetParameter (*myGlContext, GL_TEXTURE_WRAP_T,     aWrapMode);
490       }
491
492       break;
493     }
494     default: break;
495   }
496
497   switch (theTexture->GetTarget())
498   {
499   #if !defined(GL_ES_VERSION_2_0)
500     case GL_TEXTURE_1D:
501     {
502       if (myGlContext->core11 != NULL)
503       {
504         if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
505         {
506           glEnable (GL_TEXTURE_GEN_S);
507         }
508         glEnable (GL_TEXTURE_1D);
509       }
510       break;
511     }
512   #endif
513     case GL_TEXTURE_2D:
514     {
515     #if !defined(GL_ES_VERSION_2_0)
516       if (myGlContext->core11 != NULL)
517       {
518         if (aParams->GenMode() != Graphic3d_TOTM_MANUAL)
519         {
520           glEnable (GL_TEXTURE_GEN_S);
521           glEnable (GL_TEXTURE_GEN_T);
522         }
523         glEnable (GL_TEXTURE_2D);
524       }
525     #endif
526       break;
527     }
528     default: break;
529   }
530
531   theTexture->SetParams (aParams);
532 }
533
534 // =======================================================================
535 // function : EnableTexture
536 // purpose  :
537 // =======================================================================
538 Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
539                                                         const Handle(Graphic3d_TextureParams)& theParams)
540 {
541   if (theTexture.IsNull() || !theTexture->IsValid())
542   {
543     return DisableTexture();
544   }
545
546   if (myTextureBound == theTexture
547    && (theParams.IsNull() || theParams == theTexture->GetParams()))
548   {
549     // already bound
550     return myTextureBound;
551   }
552
553   Handle(OpenGl_Texture) aPrevTexture = DisableTexture();
554   myTextureBound = theTexture;
555   myTextureBound->Bind (myGlContext);
556   setTextureParams (myTextureBound, theParams);
557
558   // If custom sampler object is available it will be
559   // used for overriding default texture parameters
560   const Handle(OpenGl_Sampler)& aSampler = myGlContext->TextureSampler();
561
562   if (!aSampler.IsNull() && aSampler->IsValid())
563   {
564     aSampler->Bind (*myGlContext);
565   }
566
567   return aPrevTexture;
568 }
569
570 // =======================================================================
571 // function : SetAspectLine
572 // purpose  :
573 // =======================================================================
574 const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
575 {
576   const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
577   myAspectLineSet = theAspect;
578   return aPrevAspectLine;
579 }
580
581 // =======================================================================
582 // function : SetAspectFace
583 // purpose  :
584 // =======================================================================
585 const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
586 {
587   const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
588   myAspectFaceSet = theAspect;
589   return aPrevAspectFace;
590 }
591
592 // =======================================================================
593 // function : SetAspectMarker
594 // purpose  :
595 // =======================================================================
596 const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
597 {
598   const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
599   myAspectMarkerSet = theAspect;
600   return aPrevAspectMarker;
601 }
602
603 // =======================================================================
604 // function : SetAspectText
605 // purpose  :
606 // =======================================================================
607 const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
608 {
609   const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
610   myAspectTextSet = theAspect;
611   return aPrevAspectText;
612 }
613
614 // =======================================================================
615 // function : ApplyAspectFace
616 // purpose  :
617 // =======================================================================
618 const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
619 {
620   if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
621   {
622     // manage back face culling mode, disable culling when clipping is enabled
623     bool toSuppressBackFaces = myToAllowFaceCulling
624                             && myAspectFaceSet->Aspect()->ToSuppressBackFaces();
625     if (toSuppressBackFaces)
626     {
627       if (myGlContext->Clipping().IsClippingOrCappingOn()
628        || myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HATCH)
629       {
630         toSuppressBackFaces = false;
631       }
632     }
633     if (toSuppressBackFaces)
634     {
635       if ((float )myAspectFaceSet->Aspect()->FrontMaterial().Transparency() != 0.0f)
636       {
637         // disable culling in case of translucent shading aspect
638         toSuppressBackFaces = false;
639       }
640     }
641     myGlContext->SetCullBackFaces (toSuppressBackFaces);
642   }
643
644   if (myAspectFaceSet->Aspect() == myAspectFaceApplied
645    && myHighlightStyle == myAspectFaceAppliedWithHL)
646   {
647     return myAspectFaceSet;
648   }
649   myAspectFaceAppliedWithHL = myHighlightStyle;
650
651 #if !defined(GL_ES_VERSION_2_0)
652   const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->Aspect()->InteriorStyle();
653   if (myAspectFaceApplied.IsNull()
654    || myAspectFaceApplied->InteriorStyle() != anIntstyle)
655   {
656     switch (anIntstyle)
657     {
658       case Aspect_IS_EMPTY:
659       case Aspect_IS_HOLLOW:
660       {
661         myGlContext->SetPolygonMode (GL_LINE);
662         break;
663       }
664       case Aspect_IS_HATCH:
665       {
666         myGlContext->SetPolygonMode (GL_FILL);
667         myGlContext->SetPolygonHatchEnabled (true);
668         break;
669       }
670       case Aspect_IS_SOLID:
671       case Aspect_IS_HIDDENLINE:
672       {
673         myGlContext->SetPolygonMode (GL_FILL);
674         myGlContext->SetPolygonHatchEnabled (false);
675         break;
676       }
677       case Aspect_IS_POINT:
678       {
679         myGlContext->SetPolygonMode (GL_POINT);
680         break;
681       }
682     }
683   }
684
685   if (anIntstyle == Aspect_IS_HATCH)
686   {
687     myGlContext->SetPolygonHatchStyle (myAspectFaceSet->Aspect()->HatchStyle());
688   }
689 #endif
690
691   // Aspect_POM_None means: do not change current settings
692   if ((myAspectFaceSet->Aspect()->PolygonOffset().Mode & Aspect_POM_None) != Aspect_POM_None)
693   {
694     if (myPolygonOffsetApplied.Mode   != myAspectFaceSet->Aspect()->PolygonOffset().Mode
695      || myPolygonOffsetApplied.Factor != myAspectFaceSet->Aspect()->PolygonOffset().Factor
696      || myPolygonOffsetApplied.Units  != myAspectFaceSet->Aspect()->PolygonOffset().Units)
697     {
698       SetPolygonOffset (myAspectFaceSet->Aspect()->PolygonOffset());
699     }
700   }
701
702   // Case of hidden line
703   if (myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HIDDENLINE)
704   {
705     // copy all values including line edge aspect
706     *myAspectFaceHl.Aspect().operator->() = *myAspectFaceSet->Aspect();
707     myAspectFaceHl.SetAspectEdge (myAspectFaceSet->AspectEdge());
708     myAspectFaceHl.Aspect()->SetInteriorColor (myView->BackgroundColor().GetRGB());
709     myAspectFaceHl.SetNoLighting (true);
710     myAspectFaceSet = &myAspectFaceHl;
711   }
712   else
713   {
714     myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle);
715   }
716
717   if (myAspectFaceSet->Aspect()->ToMapTexture())
718   {
719     EnableTexture (myAspectFaceSet->TextureRes (myGlContext),
720                    myAspectFaceSet->TextureParams());
721   }
722   else
723   {
724     if (!myEnvironmentTexture.IsNull())
725     {
726       EnableTexture (myEnvironmentTexture,
727                      myEnvironmentTexture->GetParams());
728     }
729     else
730     {
731       DisableTexture();
732     }
733   }
734
735   myAspectFaceApplied = myAspectFaceSet->Aspect();
736   return myAspectFaceSet;
737 }
738
739 //=======================================================================
740 //function : SetPolygonOffset
741 //purpose  :
742 //=======================================================================
743 void OpenGl_Workspace::SetPolygonOffset (const Graphic3d_PolygonOffset& theParams)
744 {
745   myPolygonOffsetApplied = theParams;
746
747   if ((theParams.Mode & Aspect_POM_Fill) == Aspect_POM_Fill)
748   {
749     glEnable (GL_POLYGON_OFFSET_FILL);
750   }
751   else
752   {
753     glDisable (GL_POLYGON_OFFSET_FILL);
754   }
755
756 #if !defined(GL_ES_VERSION_2_0)
757   if ((theParams.Mode & Aspect_POM_Line) == Aspect_POM_Line)
758   {
759     glEnable (GL_POLYGON_OFFSET_LINE);
760   }
761   else
762   {
763     glDisable (GL_POLYGON_OFFSET_LINE);
764   }
765
766   if ((theParams.Mode & Aspect_POM_Point) == Aspect_POM_Point)
767   {
768     glEnable (GL_POLYGON_OFFSET_POINT);
769   }
770   else
771   {
772     glDisable (GL_POLYGON_OFFSET_POINT);
773   }
774 #endif
775   glPolygonOffset (theParams.Factor, theParams.Units);
776 }
777
778 // =======================================================================
779 // function : ApplyAspectMarker
780 // purpose  :
781 // =======================================================================
782 const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
783 {
784   if (myAspectMarkerSet->Aspect() != myAspectMarkerApplied)
785   {
786     if (myAspectMarkerApplied.IsNull()
787     || (myAspectMarkerSet->Aspect()->Scale() != myAspectMarkerApplied->Scale()))
788     {
789     #if !defined(GL_ES_VERSION_2_0)
790       glPointSize (myAspectMarkerSet->Aspect()->Scale());
791     #ifdef HAVE_GL2PS
792       gl2psPointSize (myAspectMarkerSet->Aspect()->Scale());
793     #endif
794     #endif
795     }
796     myAspectMarkerApplied = myAspectMarkerSet->Aspect();
797   }
798   return myAspectMarkerSet;
799 }
800
801 // =======================================================================
802 // function : Width
803 // purpose  :
804 // =======================================================================
805 Standard_Integer OpenGl_Workspace::Width()  const
806 {
807   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Width() : 0;
808 }
809
810 // =======================================================================
811 // function : Height
812 // purpose  :
813 // =======================================================================
814 Standard_Integer OpenGl_Workspace::Height() const
815 {
816   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Height() : 0;
817 }
818
819 // =======================================================================
820 // function : IsCullingEnabled
821 // purpose  :
822 // =======================================================================
823 Standard_Boolean OpenGl_Workspace::IsCullingEnabled() const
824 {
825   return myView->IsCullingEnabled();
826 }
827
828 // =======================================================================
829 // function : FBOCreate
830 // purpose  :
831 // =======================================================================
832 Handle(OpenGl_FrameBuffer) OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
833                                                         const Standard_Integer theHeight)
834 {
835   // activate OpenGL context
836   if (!Activate())
837     return Handle(OpenGl_FrameBuffer)();
838
839   DisableTexture();
840
841   // create the FBO
842   const Handle(OpenGl_Context)& aCtx = GetGlContext();
843   Handle(OpenGl_FrameBuffer) aFrameBuffer = new OpenGl_FrameBuffer();
844   if (!aFrameBuffer->Init (aCtx, theWidth, theHeight, GL_RGBA8, GL_DEPTH24_STENCIL8, 0))
845   {
846     aFrameBuffer->Release (aCtx.operator->());
847     return Handle(OpenGl_FrameBuffer)();
848   }
849   return aFrameBuffer;
850 }
851
852 // =======================================================================
853 // function : FBORelease
854 // purpose  :
855 // =======================================================================
856 void OpenGl_Workspace::FBORelease (Handle(OpenGl_FrameBuffer)& theFbo)
857 {
858   // activate OpenGL context
859   if (!Activate()
860    || theFbo.IsNull())
861   {
862     return;
863   }
864
865   theFbo->Release (GetGlContext().operator->());
866   theFbo.Nullify();
867 }
868
869 // =======================================================================
870 // function : getAligned
871 // purpose  :
872 // =======================================================================
873 inline Standard_Size getAligned (const Standard_Size theNumber,
874                                  const Standard_Size theAlignment)
875 {
876   return theNumber + theAlignment - 1 - (theNumber - 1) % theAlignment;
877 }
878
879 template<typename T>
880 inline void convertRowFromRgba (T* theRgbRow,
881                                 const Image_ColorRGBA* theRgbaRow,
882                                 const Standard_Size theWidth)
883 {
884   for (Standard_Size aCol = 0; aCol < theWidth; ++aCol)
885   {
886     const Image_ColorRGBA& anRgba = theRgbaRow[aCol];
887     T& anRgb = theRgbRow[aCol];
888     anRgb.r() = anRgba.r();
889     anRgb.g() = anRgba.g();
890     anRgb.b() = anRgba.b();
891   }
892 }
893
894 // =======================================================================
895 // function : BufferDump
896 // purpose  :
897 // =======================================================================
898 Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
899                                                Image_PixMap&                     theImage,
900                                                const Graphic3d_BufferType&       theBufferType)
901 {
902   if (theImage.IsEmpty()
903   || !Activate())
904   {
905     return Standard_False;
906   }
907
908   GLenum aFormat = 0;
909   GLenum aType   = 0;
910   bool toSwapRgbaBgra = false;
911   bool toConvRgba2Rgb = false;
912   switch (theImage.Format())
913   {
914   #if !defined(GL_ES_VERSION_2_0)
915     case Image_Format_Gray:
916       aFormat = GL_DEPTH_COMPONENT;
917       aType   = GL_UNSIGNED_BYTE;
918       break;
919     case Image_Format_GrayF:
920       aFormat = GL_DEPTH_COMPONENT;
921       aType   = GL_FLOAT;
922       break;
923     case Image_Format_RGB:
924       aFormat = GL_RGB;
925       aType   = GL_UNSIGNED_BYTE;
926       break;
927     case Image_Format_BGR:
928       aFormat = GL_BGR;
929       aType   = GL_UNSIGNED_BYTE;
930       break;
931     case Image_Format_BGRA:
932     case Image_Format_BGR32:
933       aFormat = GL_BGRA;
934       aType   = GL_UNSIGNED_BYTE;
935       break;
936     case Image_Format_BGRF:
937       aFormat = GL_BGR;
938       aType   = GL_FLOAT;
939       break;
940     case Image_Format_BGRAF:
941       aFormat = GL_BGRA;
942       aType   = GL_FLOAT;
943       break;
944   #else
945     case Image_Format_Gray:
946     case Image_Format_GrayF:
947     case Image_Format_BGRF:
948     case Image_Format_BGRAF:
949       return Standard_False;
950     case Image_Format_BGRA:
951     case Image_Format_BGR32:
952       aFormat = GL_RGBA;
953       aType   = GL_UNSIGNED_BYTE;
954       toSwapRgbaBgra = true;
955       break;
956     case Image_Format_BGR:
957     case Image_Format_RGB:
958       aFormat = GL_RGBA;
959       aType   = GL_UNSIGNED_BYTE;
960       toConvRgba2Rgb = true;
961       break;
962   #endif
963     case Image_Format_RGBA:
964     case Image_Format_RGB32:
965       aFormat = GL_RGBA;
966       aType   = GL_UNSIGNED_BYTE;
967       break;
968     case Image_Format_RGBF:
969       aFormat = GL_RGB;
970       aType   = GL_FLOAT;
971       break;
972     case Image_Format_RGBAF:
973       aFormat = GL_RGBA;
974       aType   = GL_FLOAT;
975       break;
976     case Image_Format_Alpha:
977     case Image_Format_AlphaF:
978       return Standard_False; // GL_ALPHA is no more supported in core context
979     case Image_Format_UNKNOWN:
980       return Standard_False;
981   }
982
983   if (aFormat == 0)
984   {
985     return Standard_False;
986   }
987
988 #if !defined(GL_ES_VERSION_2_0)
989   GLint aReadBufferPrev = GL_BACK;
990   if (theBufferType == Graphic3d_BT_Depth
991    && aFormat != GL_DEPTH_COMPONENT)
992   {
993     return Standard_False;
994   }
995 #else
996   (void )theBufferType;
997 #endif
998
999   // bind FBO if used
1000   if (!theFbo.IsNull() && theFbo->IsValid())
1001   {
1002     theFbo->BindBuffer (GetGlContext());
1003   }
1004   else
1005   {
1006   #if !defined(GL_ES_VERSION_2_0)
1007     glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
1008     GLint aDrawBufferPrev = GL_BACK;
1009     glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
1010     glReadBuffer (aDrawBufferPrev);
1011   #endif
1012   }
1013
1014   // setup alignment
1015   const GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
1016   glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
1017   bool isBatchCopy = !theImage.IsTopDown();
1018
1019   const GLint   anExtraBytes       = GLint(theImage.RowExtraBytes());
1020   GLint         aPixelsWidth       = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
1021   Standard_Size aSizeRowBytesEstim = getAligned (theImage.SizePixelBytes() * aPixelsWidth, anAligment);
1022   if (anExtraBytes < anAligment)
1023   {
1024     aPixelsWidth = 0;
1025   }
1026   else if (aSizeRowBytesEstim != theImage.SizeRowBytes())
1027   {
1028     aPixelsWidth = 0;
1029     isBatchCopy  = false;
1030   }
1031 #if !defined(GL_ES_VERSION_2_0)
1032   glPixelStorei (GL_PACK_ROW_LENGTH, aPixelsWidth);
1033 #else
1034   if (aPixelsWidth != 0)
1035   {
1036     isBatchCopy = false;
1037   }
1038 #endif
1039   if (toConvRgba2Rgb)
1040   {
1041     Handle(NCollection_BaseAllocator) anAlloc = new NCollection_AlignedAllocator (16);
1042     const Standard_Size aRowSize = theImage.SizeX() * 4;
1043     NCollection_Buffer aRowBuffer (anAlloc);
1044     if (!aRowBuffer.Allocate (aRowSize))
1045     {
1046       return Standard_False;
1047     }
1048
1049     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
1050     {
1051       // Image_PixMap rows indexation always starts from the upper corner
1052       // while order in memory depends on the flag and processed by ChangeRow() method
1053       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, aRowBuffer.ChangeData());
1054       const Image_ColorRGBA* aRowDataRgba = (const Image_ColorRGBA* )aRowBuffer.Data();
1055       if (theImage.Format() == Image_Format_BGR)
1056       {
1057         convertRowFromRgba ((Image_ColorBGR* )theImage.ChangeRow (aRow), aRowDataRgba, theImage.SizeX());
1058       }
1059       else
1060       {
1061         convertRowFromRgba ((Image_ColorRGB* )theImage.ChangeRow (aRow), aRowDataRgba, theImage.SizeX());
1062       }
1063     }
1064   }
1065   else if (!isBatchCopy)
1066   {
1067     // copy row by row
1068     for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
1069     {
1070       // Image_PixMap rows indexation always starts from the upper corner
1071       // while order in memory depends on the flag and processed by ChangeRow() method
1072       glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
1073     }
1074   }
1075   else
1076   {
1077     glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
1078   }
1079   const bool hasErrors = myGlContext->ResetErrors (true);
1080
1081   glPixelStorei (GL_PACK_ALIGNMENT,  1);
1082 #if !defined(GL_ES_VERSION_2_0)
1083   glPixelStorei (GL_PACK_ROW_LENGTH, 0);
1084 #endif
1085
1086   if (!theFbo.IsNull() && theFbo->IsValid())
1087   {
1088     theFbo->UnbindBuffer (GetGlContext());
1089   }
1090   else
1091   {
1092   #if !defined(GL_ES_VERSION_2_0)
1093     glReadBuffer (aReadBufferPrev);
1094   #endif
1095   }
1096
1097   if (toSwapRgbaBgra)
1098   {
1099     Image_PixMap::SwapRgbaBgra (theImage);
1100   }
1101
1102   return !hasErrors;
1103 }
1104
1105 // =======================================================================
1106 // function : ShouldRender
1107 // purpose  :
1108 // =======================================================================
1109 Standard_Boolean OpenGl_RaytraceFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
1110                                                       const OpenGl_Element*           theElement)
1111 {
1112   Standard_Boolean aPrevFilterResult = Standard_True;
1113   if (!myPrevRenderFilter.IsNull())
1114   {
1115     aPrevFilterResult = myPrevRenderFilter->ShouldRender (theWorkspace, theElement);
1116   }
1117   return aPrevFilterResult &&
1118     !OpenGl_Raytrace::IsRaytracedElement (theElement);
1119 }