0027961: Visualization - remove unused and no more working OpenGl_AVIWriter
[occt.git] / src / OpenGl / OpenGl_Workspace.cxx
index 03f3ba4..a0e7656 100644 (file)
@@ -15,8 +15,6 @@
 
 #include <OpenGl_Workspace.hxx>
 
-#include <InterfaceGraphic.hxx>
-
 #include <OpenGl_ArbFBO.hxx>
 #include <OpenGl_AspectLine.hxx>
 #include <OpenGl_AspectFace.hxx>
@@ -36,6 +34,9 @@
 #include <Graphic3d_TextureParams.hxx>
 #include <Graphic3d_TransformUtils.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_RaytraceFilter,OpenGl_RenderFilter)
+
 #ifdef HAVE_GL2PS
   #include <gl2ps.h>
   /* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
 
 namespace
 {
-  static const TEL_COLOUR  THE_WHITE_COLOR = { { 1.0f, 1.0f, 1.0f, 1.0f } };
-  static const OpenGl_Vec4 THE_BLACK_COLOR      (0.0f, 0.0f, 0.0f, 1.0f);
+  static const OpenGl_Vec4 THE_WHITE_COLOR (1.0f, 1.0f, 1.0f, 1.0f);
+  static const OpenGl_Vec4 THE_BLACK_COLOR (0.0f, 0.0f, 0.0f, 1.0f);
 
   static const OpenGl_AspectLine myDefaultAspectLine;
   static const OpenGl_AspectFace myDefaultAspectFace;
   static const OpenGl_AspectMarker myDefaultAspectMarker;
-
-  static const OpenGl_TextParam myDefaultTextParam =
-  {
-    16, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM
-  };
+  static const OpenGl_AspectText myDefaultAspectText;
 
   static const OpenGl_Matrix myDefaultMatrix =
   {
@@ -67,22 +64,22 @@ namespace
      { 0.0F, 0.0F, 0.0F, 1.0F }}
   };
 
-};
+}
 
 // =======================================================================
 // function : Init
 // purpose  :
 // =======================================================================
-void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
+void OpenGl_Material::Init (const Graphic3d_MaterialAspect& theMat,
+                            const Quantity_Color&           theInteriorColor)
 {
+  const bool isPhysic = theMat.MaterialType (Graphic3d_MATERIAL_PHYSIC) == Standard_True;
+
   // ambient component
-  if (theProp.color_mask & OPENGL_AMBIENT_MASK)
+  if (theMat.ReflectionMode (Graphic3d_TOR_AMBIENT))
   {
-    const float* aSrcAmb = theProp.isphysic ? theProp.ambcol.rgb : theProp.matcol.rgb;
-    Ambient = OpenGl_Vec4 (aSrcAmb[0] * theProp.amb,
-                           aSrcAmb[1] * theProp.amb,
-                           aSrcAmb[2] * theProp.amb,
-                           1.0f);
+    const OpenGl_Vec3& aSrcAmb = isPhysic ? theMat.AmbientColor() : theInteriorColor;
+    Ambient = OpenGl_Vec4 (aSrcAmb * (float )theMat.Ambient(), 1.0f);
   }
   else
   {
@@ -90,13 +87,10 @@ void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
   }
 
   // diffusion component
-  if (theProp.color_mask & OPENGL_DIFFUSE_MASK)
+  if (theMat.ReflectionMode (Graphic3d_TOR_DIFFUSE))
   {
-    const float* aSrcDif = theProp.isphysic ? theProp.difcol.rgb : theProp.matcol.rgb;
-    Diffuse = OpenGl_Vec4 (aSrcDif[0] * theProp.diff,
-                           aSrcDif[1] * theProp.diff,
-                           aSrcDif[2] * theProp.diff,
-                           1.0f);
+    const OpenGl_Vec3& aSrcDif = isPhysic ? theMat.DiffuseColor() : theInteriorColor;
+    Diffuse = OpenGl_Vec4 (aSrcDif * (float )theMat.Diffuse(), 1.0f);
   }
   else
   {
@@ -104,13 +98,10 @@ void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
   }
 
   // specular component
-  if (theProp.color_mask & OPENGL_SPECULAR_MASK)
+  if (theMat.ReflectionMode (Graphic3d_TOR_SPECULAR))
   {
-    const float* aSrcSpe = theProp.isphysic ? theProp.speccol.rgb : THE_WHITE_COLOR.rgb;
-    Specular = OpenGl_Vec4 (aSrcSpe[0] * theProp.spec,
-                            aSrcSpe[1] * theProp.spec,
-                            aSrcSpe[2] * theProp.spec,
-                            1.0f);
+    const OpenGl_Vec3& aSrcSpe = isPhysic ? (const OpenGl_Vec3& )theMat.SpecularColor() : THE_WHITE_COLOR.rgb();
+    Specular = OpenGl_Vec4 (aSrcSpe * (float )theMat.Specular(), 1.0f);
   }
   else
   {
@@ -118,21 +109,18 @@ void OpenGl_Material::Init (const OPENGL_SURF_PROP& theProp)
   }
 
   // emission component
-  if (theProp.color_mask & OPENGL_EMISSIVE_MASK)
+  if (theMat.ReflectionMode (Graphic3d_TOR_EMISSION))
   {
-    const float* aSrcEms = theProp.isphysic ? theProp.emscol.rgb : theProp.matcol.rgb;
-    Emission = OpenGl_Vec4 (aSrcEms[0] * theProp.emsv,
-                            aSrcEms[1] * theProp.emsv,
-                            aSrcEms[2] * theProp.emsv,
-                            1.0f);
+    const OpenGl_Vec3& aSrcEms = isPhysic ? theMat.EmissiveColor() : theInteriorColor;
+    Emission = OpenGl_Vec4 (aSrcEms * (float )theMat.Emissive(), 1.0f);
   }
   else
   {
     Emission = THE_BLACK_COLOR;
   }
 
-  ChangeShine()        = theProp.shine;
-  ChangeTransparency() = theProp.trans;
+  ChangeShine()        = 128.0f * float(theMat.Shininess());
+  ChangeTransparency() = 1.0f - (float )theMat.Transparency();
 }
 
 // =======================================================================
@@ -149,32 +137,23 @@ OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Wi
   myUseDepthWrite (Standard_True),
   myUseGLLight (Standard_True),
   //
-  AspectLine_set (&myDefaultAspectLine),
-  AspectLine_applied (NULL),
-  AspectFace_set (&myDefaultAspectFace),
-  AspectFace_applied (NULL),
-  AspectMarker_set (&myDefaultAspectMarker),
-  AspectMarker_applied (NULL),
+  myAspectLineSet (&myDefaultAspectLine),
+  myAspectFaceSet (&myDefaultAspectFace),
+  myAspectMarkerSet (&myDefaultAspectMarker),
+  myAspectTextSet (&myDefaultAspectText),
+  myAspectFaceAppliedWithHL (false),
+  //
   ViewMatrix_applied (&myDefaultMatrix),
   StructureMatrix_applied (&myDefaultMatrix),
-  myCullingMode (TelCullUndefined),
-  myModelViewMatrix (myDefaultMatrix),
-  PolygonOffset_applied (THE_DEFAULT_POFFSET)
+  myToAllowFaceCulling (false),
+  myToHighlight (false),
+  myModelViewMatrix (myDefaultMatrix)
 {
   if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
   {
     myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 
-    if (!myGlContext->GetResource ("OpenGl_LineAttributes", myLineAttribs))
-    {
-      // share and register for release once the resource is no longer used
-      myLineAttribs = new OpenGl_LineAttributes();
-      myGlContext->ShareResource ("OpenGl_LineAttributes", myLineAttribs);
-      myLineAttribs->Init (myGlContext);
-    }
-
     // General initialization of the context
-
   #if !defined(GL_ES_VERSION_2_0)
     if (myGlContext->core11 != NULL)
     {
@@ -192,24 +171,12 @@ OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Wi
   #endif
   }
 
-  myDefaultCappingAlgoFilter         = new OpenGl_CappingAlgoFilter();
-  myNoneCulling.ChangeCullingMode()  = TelCullNone;
-  myNoneCulling.ChangeEdge()         = 0;
-  myFrontCulling.ChangeCullingMode() = TelCullBack;
-  myFrontCulling.ChangeEdge()        = 0;
-}
+  myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter();
 
-// =======================================================================
-// function : ~OpenGl_Workspace
-// purpose  :
-// =======================================================================
-OpenGl_Workspace::~OpenGl_Workspace()
-{
-  if (!myLineAttribs.IsNull())
-  {
-    myLineAttribs.Nullify();
-    myGlContext->ReleaseResource ("OpenGl_LineAttributes", Standard_True);
-  }
+  myNoneCulling .Aspect()->SetSuppressBackFaces (false);
+  myNoneCulling .Aspect()->SetDrawEdges (false);
+  myFrontCulling.Aspect()->SetSuppressBackFaces (true);
+  myFrontCulling.Aspect()->SetDrawEdges (false);
 }
 
 // =======================================================================
@@ -241,22 +208,22 @@ void OpenGl_Workspace::ResetAppliedAspect()
 
   NamedStatus           = !myTextureBound.IsNull() ? OPENGL_NS_TEXTURE : 0;
   HighlightColor        = &THE_WHITE_COLOR;
-  AspectLine_set        = &myDefaultAspectLine;
-  AspectLine_applied    = NULL;
-  AspectFace_set        = &myDefaultAspectFace;
-  AspectFace_applied    = NULL;
-  AspectMarker_set      = &myDefaultAspectMarker;
-  AspectMarker_applied  = NULL;
-  PolygonOffset_applied = THE_DEFAULT_POFFSET;
-  myCullingMode         = TelCullUndefined;
-
-  AspectLine(Standard_True);
-  AspectFace(Standard_True);
-  AspectMarker(Standard_True);
-  AspectText(Standard_True);
-
-  myGlContext->SetTypeOfLine (myDefaultAspectLine.Type());
-  myGlContext->SetLineWidth  (myDefaultAspectLine.Width());
+  myToAllowFaceCulling  = false;
+  myAspectLineSet       = &myDefaultAspectLine;
+  myAspectFaceSet       = &myDefaultAspectFace;
+  myAspectFaceApplied.Nullify();
+  myAspectMarkerSet     = &myDefaultAspectMarker;
+  myAspectMarkerApplied.Nullify();
+  myAspectTextSet       = &myDefaultAspectText;
+  myPolygonOffsetApplied= Graphic3d_PolygonOffset();
+
+  ApplyAspectLine();
+  ApplyAspectFace();
+  ApplyAspectMarker();
+  ApplyAspectText();
+
+  myGlContext->SetTypeOfLine (myDefaultAspectLine.Aspect()->Type());
+  myGlContext->SetLineWidth  (myDefaultAspectLine.Aspect()->Width());
 }
 
 // =======================================================================
@@ -409,7 +376,6 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
           glEnable  (GL_POINT_SPRITE);
           glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
           anEnvMode = GL_REPLACE;
-          myGlContext->core15->glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
         }
         break;
       }
@@ -600,94 +566,63 @@ Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Text
 }
 
 // =======================================================================
-// function : TelUpdatePolygonOffsets
-// purpose  :
-// =======================================================================
-static void TelUpdatePolygonOffsets (const TEL_POFFSET_PARAM& theOffsetData)
-{
-  if ((theOffsetData.mode & Aspect_POM_Fill) == Aspect_POM_Fill)
-  {
-    glEnable (GL_POLYGON_OFFSET_FILL);
-  }
-  else
-  {
-    glDisable (GL_POLYGON_OFFSET_FILL);
-  }
-
-#if !defined(GL_ES_VERSION_2_0)
-  if ((theOffsetData.mode & Aspect_POM_Line) == Aspect_POM_Line)
-  {
-    glEnable (GL_POLYGON_OFFSET_LINE);
-  }
-  else
-  {
-    glDisable (GL_POLYGON_OFFSET_LINE);
-  }
-
-  if ((theOffsetData.mode & Aspect_POM_Point) == Aspect_POM_Point)
-  {
-    glEnable (GL_POLYGON_OFFSET_POINT);
-  }
-  else
-  {
-    glDisable (GL_POLYGON_OFFSET_POINT);
-  }
-#endif
-
-  glPolygonOffset (theOffsetData.factor, theOffsetData.units);
-}
-
-// =======================================================================
 // function : updateMaterial
 // purpose  :
 // =======================================================================
 void OpenGl_Workspace::updateMaterial (const int theFlag)
 {
   // Case of hidden line
-  if (AspectFace_set->InteriorStyle() == Aspect_IS_HIDDENLINE)
-  {
-    myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect
-    myAspectFaceHl.ChangeIntFront().matcol     = myView->BackgroundColor();
-    myAspectFaceHl.ChangeIntFront().color_mask = 0;
-    myAspectFaceHl.ChangeIntFront().color_mask = 0;
-
-    AspectFace_set = &myAspectFaceHl;
+  if (myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HIDDENLINE)
+  {
+    // copy all values including line edge aspect
+    *myAspectFaceHl.Aspect().operator->() = *myAspectFaceSet->Aspect();
+    myAspectFaceHl.SetAspectEdge (myAspectFaceSet->AspectEdge());
+    myAspectFaceHl.Aspect()->SetInteriorColor (myView->BackgroundColor().GetRGB());
+    myAspectFaceHl.SetNoLighting (true);
+    myAspectFaceSet = &myAspectFaceHl;
     return;
   }
 
-  const OPENGL_SURF_PROP* aProps = &AspectFace_set->IntFront();
+  const Graphic3d_MaterialAspect* aSrcMat      = &myAspectFaceSet->Aspect()->FrontMaterial();
+  const Quantity_Color*           aSrcIntColor = &myAspectFaceSet->Aspect()->InteriorColor();
   GLenum aFace = GL_FRONT_AND_BACK;
   if (theFlag == TEL_BACK_MATERIAL)
   {
-    aFace  = GL_BACK;
-    aProps = &AspectFace_set->IntBack();
+    aFace        = GL_BACK;
+    aSrcMat      = &myAspectFaceSet->Aspect()->BackMaterial();
+    aSrcIntColor = &myAspectFaceSet->Aspect()->BackInteriorColor();
   }
-  else if (AspectFace_set->DistinguishingMode() == TOn
+  else if (myAspectFaceSet->Aspect()->Distinguish()
         && !(NamedStatus & OPENGL_NS_RESMAT))
   {
     aFace = GL_FRONT;
   }
 
-  myMatTmp.Init (*aProps);
+  myMatTmp.Init (*aSrcMat, *aSrcIntColor);
+  if (myToHighlight)
+  {
+    myMatTmp.SetColor (*HighlightColor);
+  }
 
   // handling transparency
   if (NamedStatus & OPENGL_NS_2NDPASSDO)
   {
     // second pass
-    myMatTmp.Diffuse.a() = aProps->env_reflexion;
+    myMatTmp.Diffuse.a() = aSrcMat->EnvReflexion();
   }
   else
   {
-    if (aProps->env_reflexion != 0.0f)
+    if (aSrcMat->EnvReflexion() != 0.0f)
     {
       // if the material reflects the environment scene, the second pass is needed
       NamedStatus |= OPENGL_NS_2NDPASSNEED;
     }
 
-    if (aProps->trans != 1.0f)
+    const float aTransp = (float )aSrcMat->Transparency();
+    if (aTransp != 0.0f)
     {
       // render transparent
-      myMatTmp.Diffuse.a() = aProps->trans;
+      myMatTmp.Diffuse.a() = 1.0f - aTransp;
       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       glEnable    (GL_BLEND);
       if (myUseDepthWrite)
@@ -698,11 +633,8 @@ void OpenGl_Workspace::updateMaterial (const int theFlag)
     else
     {
       // render opaque
-      if ((NamedStatus & OPENGL_NS_ANTIALIASING) == 0)
-      {
-        glBlendFunc (GL_ONE, GL_ZERO);
-        glDisable   (GL_BLEND);
-      }
+      glBlendFunc (GL_ONE, GL_ZERO);
+      glDisable   (GL_BLEND);
       if (myUseDepthWrite)
       {
         glDepthMask (GL_TRUE);
@@ -712,7 +644,7 @@ void OpenGl_Workspace::updateMaterial (const int theFlag)
 
   // do not update material properties in case of zero reflection mode,
   // because GL lighting will be disabled by OpenGl_PrimitiveArray::DrawArray() anyway.
-  if (aProps->color_mask == 0)
+  if (myAspectFaceSet->IsNoLighting())
   {
     return;
   }
@@ -794,150 +726,113 @@ void OpenGl_Workspace::updateMaterial (const int theFlag)
 // function : SetAspectLine
 // purpose  :
 // =======================================================================
-const OpenGl_AspectLine * OpenGl_Workspace::SetAspectLine(const OpenGl_AspectLine *AnAspect)
+const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
 {
-  const OpenGl_AspectLine *AspectLine_old = AspectLine_set;
-  AspectLine_set = AnAspect;
-  return AspectLine_old;
+  const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
+  myAspectLineSet = theAspect;
+  return aPrevAspectLine;
 }
 
 // =======================================================================
 // function : SetAspectFace
 // purpose  :
 // =======================================================================
-const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace(const OpenGl_AspectFace *AnAspect)
+const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
 {
-  const OpenGl_AspectFace *AspectFace_old = AspectFace_set;
-  AspectFace_set = AnAspect;
-  return AspectFace_old;
+  const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
+  myAspectFaceSet = theAspect;
+  return aPrevAspectFace;
 }
 
 // =======================================================================
 // function : SetAspectMarker
 // purpose  :
 // =======================================================================
-const OpenGl_AspectMarker * OpenGl_Workspace::SetAspectMarker(const OpenGl_AspectMarker *AnAspect)
+const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
 {
-  const OpenGl_AspectMarker *AspectMarker_old = AspectMarker_set;
-  AspectMarker_set = AnAspect;
-  return AspectMarker_old;
+  const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
+  myAspectMarkerSet = theAspect;
+  return aPrevAspectMarker;
 }
 
 // =======================================================================
 // function : SetAspectText
 // purpose  :
 // =======================================================================
-const OpenGl_AspectText * OpenGl_Workspace::SetAspectText(const OpenGl_AspectText *AnAspect)
-{
-  const OpenGl_AspectText *AspectText_old = AspectText_set;
-  AspectText_set = AnAspect;
-  return AspectText_old;
-}
-
-// =======================================================================
-// function : AspectLine
-// purpose  :
-// =======================================================================
-const OpenGl_AspectLine * OpenGl_Workspace::AspectLine(const Standard_Boolean theWithApply)
+const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
 {
-  if (theWithApply)
-  {
-    AspectLine_applied = AspectLine_set;
-  }
-
-  return AspectLine_set;
+  const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
+  myAspectTextSet = theAspect;
+  return aPrevAspectText;
 }
 
 // =======================================================================
-// function : AspectFace
+// function : ApplyAspectFace
 // purpose  :
 // =======================================================================
-const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean theToApply)
+const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
 {
-  if (!theToApply)
-  {
-    return AspectFace_set;
-  }
-
   if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
   {
     // manage back face culling mode, disable culling when clipping is enabled
-    TelCullMode aCullingMode = (myGlContext->Clipping().IsClippingOrCappingOn()
-                             || AspectFace_set->InteriorStyle() == Aspect_IS_HATCH)
-                             ? TelCullNone
-                             : (TelCullMode )AspectFace_set->CullingMode();
-    if (aCullingMode != TelCullNone
-     && !(NamedStatus & OPENGL_NS_2NDPASSDO))
+    bool toSuppressBackFaces = myToAllowFaceCulling
+                            && myAspectFaceSet->Aspect()->ToSuppressBackFaces();
+    if (toSuppressBackFaces)
     {
-      // disable culling in case of translucent shading aspect
-      if (AspectFace_set->IntFront().trans != 1.0f)
+      if (myGlContext->Clipping().IsClippingOrCappingOn()
+       || myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HATCH)
       {
-        aCullingMode = TelCullNone;
+        toSuppressBackFaces = false;
       }
     }
-    if (myCullingMode != aCullingMode)
+    if (toSuppressBackFaces)
     {
-      myCullingMode = aCullingMode;
-      switch (myCullingMode)
+      if (!(NamedStatus & OPENGL_NS_2NDPASSDO)
+       && (float )myAspectFaceSet->Aspect()->FrontMaterial().Transparency() != 0.0f)
       {
-        case TelCullNone:
-        case TelCullUndefined:
-        {
-          glDisable (GL_CULL_FACE);
-          break;
-        }
-        case TelCullFront:
-        {
-          glCullFace (GL_FRONT);
-          glEnable (GL_CULL_FACE);
-          break;
-        }
-        case TelCullBack:
-        {
-          glCullFace (GL_BACK);
-          glEnable (GL_CULL_FACE);
-          break;
-        }
+        // disable culling in case of translucent shading aspect
+        toSuppressBackFaces = false;
       }
     }
+    myGlContext->SetCullBackFaces (toSuppressBackFaces);
   }
 
-  if (AspectFace_set == AspectFace_applied)
+  if (myAspectFaceSet->Aspect() == myAspectFaceApplied
+   && myToHighlight == myAspectFaceAppliedWithHL)
   {
-    return AspectFace_set;
+    return myAspectFaceSet;
   }
+  myAspectFaceAppliedWithHL = myToHighlight;
 
 #if !defined(GL_ES_VERSION_2_0)
-  const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle();
-  if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle() != anIntstyle)
+  const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->Aspect()->InteriorStyle();
+  if (myAspectFaceApplied.IsNull()
+   || myAspectFaceApplied->InteriorStyle() != anIntstyle)
   {
     switch (anIntstyle)
     {
       case Aspect_IS_EMPTY:
       case Aspect_IS_HOLLOW:
       {
-        glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
+        myGlContext->SetPolygonMode (GL_LINE);
         break;
       }
       case Aspect_IS_HATCH:
       {
-        glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
-        myLineAttribs->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch() : TEL_HS_SOLID);
+        myGlContext->SetPolygonMode (GL_FILL);
+        myGlContext->SetPolygonHatchEnabled (true);
         break;
       }
       case Aspect_IS_SOLID:
       case Aspect_IS_HIDDENLINE:
       {
-        glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
-        if (myGlContext->core11 != NULL)
-        {
-          glDisable (GL_POLYGON_STIPPLE);
-        }
+        myGlContext->SetPolygonMode (GL_FILL);
+        myGlContext->SetPolygonHatchEnabled (false);
         break;
       }
       case Aspect_IS_POINT:
       {
-        glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);
+        myGlContext->SetPolygonMode (GL_POINT);
         break;
       }
     }
@@ -945,39 +840,38 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
 
   if (anIntstyle == Aspect_IS_HATCH)
   {
-    const Tint hatchstyle = AspectFace_set->Hatch();
-    if (AspectFace_applied == NULL || AspectFace_applied->Hatch() != hatchstyle)
-    {
-      myLineAttribs->SetTypeOfHatch (hatchstyle);
-    }
+    myGlContext->SetPolygonHatchStyle (myAspectFaceSet->Aspect()->HatchStyle());
   }
 #endif
 
   // Aspect_POM_None means: do not change current settings
-  if ((AspectFace_set->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
+  if ((myAspectFaceSet->Aspect()->PolygonOffset().Mode & Aspect_POM_None) != Aspect_POM_None)
   {
-    if (PolygonOffset_applied.mode   != AspectFace_set->PolygonOffset().mode
-     || PolygonOffset_applied.factor != AspectFace_set->PolygonOffset().factor
-     || PolygonOffset_applied.units  != AspectFace_set->PolygonOffset().units)
+    if (myPolygonOffsetApplied.Mode   != myAspectFaceSet->Aspect()->PolygonOffset().Mode
+     || myPolygonOffsetApplied.Factor != myAspectFaceSet->Aspect()->PolygonOffset().Factor
+     || myPolygonOffsetApplied.Units  != myAspectFaceSet->Aspect()->PolygonOffset().Units)
     {
-      SetPolygonOffset (AspectFace_set->PolygonOffset().mode,
-                        AspectFace_set->PolygonOffset().factor,
-                        AspectFace_set->PolygonOffset().units);
+      SetPolygonOffset (myAspectFaceSet->Aspect()->PolygonOffset());
     }
   }
 
   updateMaterial (TEL_FRONT_MATERIAL);
-  if (AspectFace_set->DistinguishingMode() == TOn)
+  if (myAspectFaceSet->Aspect()->Distinguish())
   {
     updateMaterial (TEL_BACK_MATERIAL);
   }
 
-  if ((NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
+  if (myAspectFaceSet->Aspect()->ToMapTexture())
   {
-    if (AspectFace_set->DoTextureMap())
+    EnableTexture (myAspectFaceSet->TextureRes (myGlContext),
+                   myAspectFaceSet->TextureParams());
+  }
+  else
+  {
+    if (!myEnvironmentTexture.IsNull())
     {
-      EnableTexture (AspectFace_set->TextureRes (myGlContext),
-                     AspectFace_set->TextureParams());
+      EnableTexture (myEnvironmentTexture,
+                     myEnvironmentTexture->GetParams());
     }
     else
     {
@@ -985,59 +879,70 @@ const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean th
     }
   }
 
-  AspectFace_applied = AspectFace_set;
-  return AspectFace_set;
+  myAspectFaceApplied = myAspectFaceSet->Aspect();
+  return myAspectFaceSet;
 }
 
 //=======================================================================
 //function : SetPolygonOffset
 //purpose  :
 //=======================================================================
-void OpenGl_Workspace::SetPolygonOffset (int theMode,
-                                         Standard_ShortReal theFactor,
-                                         Standard_ShortReal theUnits)
+void OpenGl_Workspace::SetPolygonOffset (const Graphic3d_PolygonOffset& theParams)
 {
-  PolygonOffset_applied.mode   = theMode;
-  PolygonOffset_applied.factor = theFactor;
-  PolygonOffset_applied.units  = theUnits;
+  myPolygonOffsetApplied = theParams;
+
+  if ((theParams.Mode & Aspect_POM_Fill) == Aspect_POM_Fill)
+  {
+    glEnable (GL_POLYGON_OFFSET_FILL);
+  }
+  else
+  {
+    glDisable (GL_POLYGON_OFFSET_FILL);
+  }
 
-  TelUpdatePolygonOffsets (PolygonOffset_applied);
+#if !defined(GL_ES_VERSION_2_0)
+  if ((theParams.Mode & Aspect_POM_Line) == Aspect_POM_Line)
+  {
+    glEnable (GL_POLYGON_OFFSET_LINE);
+  }
+  else
+  {
+    glDisable (GL_POLYGON_OFFSET_LINE);
+  }
+
+  if ((theParams.Mode & Aspect_POM_Point) == Aspect_POM_Point)
+  {
+    glEnable (GL_POLYGON_OFFSET_POINT);
+  }
+  else
+  {
+    glDisable (GL_POLYGON_OFFSET_POINT);
+  }
+#endif
+  glPolygonOffset (theParams.Factor, theParams.Units);
 }
 
 // =======================================================================
-// function : AspectMarker
+// function : ApplyAspectMarker
 // purpose  :
 // =======================================================================
-const OpenGl_AspectMarker* OpenGl_Workspace::AspectMarker (const Standard_Boolean theToApply)
+const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
 {
-  if (theToApply && (AspectMarker_set != AspectMarker_applied))
+  if (myAspectMarkerSet->Aspect() != myAspectMarkerApplied)
   {
-    if (!AspectMarker_applied || (AspectMarker_set->Scale() != AspectMarker_applied->Scale()))
+    if (myAspectMarkerApplied.IsNull()
+    || (myAspectMarkerSet->Aspect()->Scale() != myAspectMarkerApplied->Scale()))
     {
     #if !defined(GL_ES_VERSION_2_0)
-      glPointSize (AspectMarker_set->Scale());
+      glPointSize (myAspectMarkerSet->Aspect()->Scale());
     #ifdef HAVE_GL2PS
-      gl2psPointSize (AspectMarker_set->Scale());
+      gl2psPointSize (myAspectMarkerSet->Aspect()->Scale());
     #endif
     #endif
     }
-    AspectMarker_applied = AspectMarker_set;
+    myAspectMarkerApplied = myAspectMarkerSet->Aspect();
   }
-  return AspectMarker_set;
-}
-
-// =======================================================================
-// function : AspectText
-// purpose  :
-// =======================================================================
-const OpenGl_AspectText* OpenGl_Workspace::AspectText (const Standard_Boolean theWithApply)
-{
-  if (theWithApply)
-  {
-    AspectText_applied = AspectText_set;
-  }
-
-  return AspectText_set;
+  return myAspectMarkerSet;
 }
 
 // =======================================================================
@@ -1068,15 +973,6 @@ Standard_Boolean OpenGl_Workspace::UseGLLight() const
 }
 
 // =======================================================================
-// function : AntiAliasingMode
-// purpose  :
-// =======================================================================
-Standard_Integer OpenGl_Workspace::AntiAliasingMode() const
-{
-  return myView->IsAntialiasingEnabled();
-}
-
-// =======================================================================
 // function : IsCullingEnabled
 // purpose  :
 // =======================================================================
@@ -1089,45 +985,41 @@ Standard_Boolean OpenGl_Workspace::IsCullingEnabled() const
 // function : FBOCreate
 // purpose  :
 // =======================================================================
-Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
-                                                      const Standard_Integer theHeight)
+Handle(OpenGl_FrameBuffer) OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
+                                                        const Standard_Integer theHeight)
 {
   // activate OpenGL context
   if (!Activate())
-    return NULL;
+    return Handle(OpenGl_FrameBuffer)();
+
+  DisableTexture();
 
   // create the FBO
   const Handle(OpenGl_Context)& aCtx = GetGlContext();
-  OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
+  Handle(OpenGl_FrameBuffer) aFrameBuffer = new OpenGl_FrameBuffer();
   if (!aFrameBuffer->Init (aCtx, theWidth, theHeight, GL_RGBA8, GL_DEPTH24_STENCIL8, 0))
   {
     aFrameBuffer->Release (aCtx.operator->());
-    delete aFrameBuffer;
-    return NULL;
+    return Handle(OpenGl_FrameBuffer)();
   }
-  return (Graphic3d_PtrFrameBuffer )aFrameBuffer;
+  return aFrameBuffer;
 }
 
 // =======================================================================
 // function : FBORelease
 // purpose  :
 // =======================================================================
-void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr)
+void OpenGl_Workspace::FBORelease (Handle(OpenGl_FrameBuffer)& theFbo)
 {
   // activate OpenGL context
   if (!Activate()
-   || theFBOPtr == NULL)
+   || theFbo.IsNull())
   {
     return;
   }
 
-  // release the object
-  OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
-  if (aFrameBuffer != NULL)
-  {
-    aFrameBuffer->Release (GetGlContext().operator->());
-  }
-  delete aFrameBuffer;
+  theFbo->Release (GetGlContext().operator->());
+  theFbo.Nullify();
 }
 
 inline bool getDataFormat (const Image_PixMap& theData,
@@ -1214,9 +1106,9 @@ inline Standard_Size getAligned (const Standard_Size theNumber,
 // function : BufferDump
 // purpose  :
 // =======================================================================
-Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFBOPtr,
-                                               Image_PixMap&               theImage,
-                                               const Graphic3d_BufferType& theBufferType)
+Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
+                                               Image_PixMap&                     theImage,
+                                               const Graphic3d_BufferType&       theBufferType)
 {
   GLenum aFormat, aType;
   if (theImage.IsEmpty()
@@ -1232,12 +1124,14 @@ Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFB
   {
     return Standard_False;
   }
+#else
+  (void )theBufferType;
 #endif
 
   // bind FBO if used
-  if (theFBOPtr != NULL && theFBOPtr->IsValid())
+  if (!theFbo.IsNull() && theFbo->IsValid())
   {
-    theFBOPtr->BindBuffer (GetGlContext());
+    theFbo->BindBuffer (GetGlContext());
   }
   else
   {
@@ -1295,9 +1189,9 @@ Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer*         theFB
   glPixelStorei (GL_PACK_ROW_LENGTH, 0);
 #endif
 
-  if (theFBOPtr != NULL && theFBOPtr->IsValid())
+  if (!theFbo.IsNull() && theFbo->IsValid())
   {
-    theFBOPtr->UnbindBuffer (GetGlContext());
+    theFbo->UnbindBuffer (GetGlContext());
   }
   else
   {