0027961: Visualization - remove unused and no more working OpenGl_AVIWriter
[occt.git] / src / OpenGl / OpenGl_Workspace.cxx
index 22337ca..a0e7656 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <OpenGl_GlCore15.hxx>
-#include <OpenGl_ArbFBO.hxx>
-
-#include <InterfaceGraphic.hxx>
+#include <OpenGl_Workspace.hxx>
 
+#include <OpenGl_ArbFBO.hxx>
 #include <OpenGl_AspectLine.hxx>
 #include <OpenGl_AspectFace.hxx>
 #include <OpenGl_AspectMarker.hxx>
 #include <OpenGl_Context.hxx>
 #include <OpenGl_Element.hxx>
 #include <OpenGl_FrameBuffer.hxx>
+#include <OpenGl_GlCore15.hxx>
+#include <OpenGl_SceneGeometry.hxx>
 #include <OpenGl_Structure.hxx>
 #include <OpenGl_Sampler.hxx>
-#include <OpenGl_ShaderManager.hxx>
 #include <OpenGl_Texture.hxx>
-#include <OpenGl_Utils.hxx>
 #include <OpenGl_View.hxx>
-#include <OpenGl_Workspace.hxx>
+#include <OpenGl_Window.hxx>
 
 #include <Graphic3d_TextureParams.hxx>
+#include <Graphic3d_TransformUtils.hxx>
 
-#if defined(_WIN32) && defined(HAVE_VIDEOCAPTURE)
-  #include <OpenGl_AVIWriter.hxx>
-#endif
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_RaytraceFilter,OpenGl_RenderFilter)
 
-IMPLEMENT_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,OpenGl_Window)
+#ifdef HAVE_GL2PS
+  #include <gl2ps.h>
+  /* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
+     Pragma comment for gl2ps.lib is defined only here. */
+  #ifdef _MSC_VER
+  #pragma comment( lib, "gl2ps.lib" )
+  #endif
+#endif
 
 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_AspectText myDefaultAspectText;
 
-  static const OpenGl_TextParam myDefaultTextParam =
-  {
-    16, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM
-  };
-
   static const OpenGl_Matrix myDefaultMatrix =
   {
     {{ 1.0F, 0.0F, 0.0F, 0.0F },
@@ -65,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
   {
@@ -88,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
   {
@@ -102,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
   {
@@ -116,144 +109,74 @@ 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();
 }
 
 // =======================================================================
 // function : OpenGl_Workspace
 // purpose  :
 // =======================================================================
-OpenGl_Workspace::OpenGl_Workspace (const Handle(OpenGl_GraphicDriver)& theDriver,
-                                    const CALL_DEF_WINDOW&        theCWindow,
-                                    Aspect_RenderingContext       theGContext,
-                                    const Handle(OpenGl_Caps)&    theCaps,
-                                    const Handle(OpenGl_Context)& theShareCtx)
-: OpenGl_Window (theDriver, theCWindow, theGContext, theCaps, theShareCtx),
-  NamedStatus (0),
+OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow)
+: NamedStatus (0),
   HighlightColor (&THE_WHITE_COLOR),
-  //
-  myComputeInitStatus (OpenGl_RT_NONE),
-  myIsRaytraceDataValid (Standard_False),
-  myIsRaytraceWarnTextures (Standard_False),
-  myHasFboBlit (Standard_True),
-  myViewModificationStatus (0),
-  myLayersModificationStatus (0),
-  //
-  myRaytraceFilter       (new OpenGl_RaytraceFilter()),
-  myToRedrawGL           (Standard_True),
-  myViewId               (-1),
-  myAntiAliasingMode     (3),
-  myTransientDrawToFront (Standard_True),
-  myBackBufferRestored   (Standard_False),
-  myIsImmediateDrawn     (Standard_False),
-  myUseZBuffer (Standard_False),
-  myUseDepthTest (Standard_True),
+  myView (theView),
+  myWindow (theWindow),
+  myGlContext (!theWindow.IsNull() ? theWindow->GetGlContext() : NULL),
+  myUseZBuffer    (Standard_True),
+  myUseDepthWrite (Standard_True),
   myUseGLLight (Standard_True),
-  myIsCullingEnabled (Standard_False),
-  myFrameCounter (0),
   //
-  AspectLine_set (&myDefaultAspectLine),
-  AspectLine_applied (NULL),
-  AspectFace_set (&myDefaultAspectFace),
-  AspectFace_applied (NULL),
-  AspectMarker_set (&myDefaultAspectMarker),
-  AspectMarker_applied (NULL),
-  AspectText_set (&myDefaultAspectText),
-  AspectText_applied (NULL),
-  TextParam_set (&myDefaultTextParam),
-  TextParam_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)
 {
-  myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-  myResultFBO = new OpenGl_FrameBuffer();
-
-  if (!myGlContext->GetResource ("OpenGl_LineAttributes", myLineAttribs))
+  if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
   {
-    // share and register for release once the resource is no longer used
-    myLineAttribs = new OpenGl_LineAttributes();
-    myGlContext->ShareResource ("OpenGl_LineAttributes", myLineAttribs);
-    myLineAttribs->Init (myGlContext);
-  }
+    myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 
-  // General initialization of the context
-
-#if !defined(GL_ES_VERSION_2_0)
-  if (myGlContext->core11 != NULL)
-  {
-    // Eviter d'avoir les faces mal orientees en noir.
-    // Pourrait etre utiliser pour detecter les problemes d'orientation
-    glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
-
-    // Optimisation pour le Fog et l'antialiasing
-    glHint (GL_FOG_HINT,            GL_FASTEST);
-    glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
-  }
-
-  glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
-  glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
-#endif
-
-  // AA mode
-  const char* anAaEnv = ::getenv ("CALL_OPENGL_ANTIALIASING_MODE");
-  if (anAaEnv != NULL)
-  {
-    int v;
-    if (sscanf (anAaEnv, "%d", &v) > 0) myAntiAliasingMode = v;
-  }
-}
+    // General initialization of the context
+  #if !defined(GL_ES_VERSION_2_0)
+    if (myGlContext->core11 != NULL)
+    {
+      // Eviter d'avoir les faces mal orientees en noir.
+      // Pourrait etre utiliser pour detecter les problemes d'orientation
+      glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
 
-// =======================================================================
-// function : SetImmediateModeDrawToFront
-// purpose  :
-// =======================================================================
-Standard_Boolean OpenGl_Workspace::SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer)
-{
-  const Standard_Boolean aPrevMode = myTransientDrawToFront;
-  myTransientDrawToFront = theDrawToFrontBuffer;
-  return aPrevMode;
-}
+      // Optimisation pour le Fog et l'antialiasing
+      glHint (GL_FOG_HINT,            GL_FASTEST);
+      glHint (GL_POINT_SMOOTH_HINT,   GL_FASTEST);
+    }
 
-// =======================================================================
-// function : ~OpenGl_Workspace
-// purpose  :
-// =======================================================================
-OpenGl_Workspace::~OpenGl_Workspace()
-{
-  if (!myLineAttribs.IsNull())
-  {
-    myLineAttribs.Nullify();
-    myGlContext->ReleaseResource ("OpenGl_LineAttributes", Standard_True);
+    glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
+    glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
+  #endif
   }
 
-  if (!myResultFBO.IsNull())
-  {
-    myResultFBO->Release (myGlContext.operator->());
-    myResultFBO.Nullify();
-  }
-  if (myFullScreenQuad.IsValid())
-  {
-    myFullScreenQuad.Release (myGlContext.operator->());
-  }
+  myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter();
 
-  ReleaseRaytraceResources();
+  myNoneCulling .Aspect()->SetSuppressBackFaces (false);
+  myNoneCulling .Aspect()->SetDrawEdges (false);
+  myFrontCulling.Aspect()->SetSuppressBackFaces (true);
+  myFrontCulling.Aspect()->SetDrawEdges (false);
 }
 
 // =======================================================================
@@ -262,8 +185,10 @@ OpenGl_Workspace::~OpenGl_Workspace()
 // =======================================================================
 Standard_Boolean OpenGl_Workspace::Activate()
 {
-  if (!OpenGl_Window::Activate())
+  if (myWindow.IsNull() || !myWindow->Activate())
+  {
     return Standard_False;
+  }
 
   ViewMatrix_applied      = &myDefaultMatrix;
   StructureMatrix_applied = &myDefaultMatrix;
@@ -283,23 +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;
-  AspectText_set        = &myDefaultAspectText;
-  AspectText_applied    = NULL;
-  TextParam_set         = &myDefaultTextParam;
-  TextParam_applied     = NULL;
-  PolygonOffset_applied = THE_DEFAULT_POFFSET;
-  myCullingMode         = TelCullUndefined;
-
-  AspectLine(Standard_True);
-  AspectFace(Standard_True);
-  AspectMarker(Standard_True);
-  AspectText(Standard_True);
+  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());
 }
 
 // =======================================================================
@@ -389,21 +313,8 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
   }
 
 #if !defined(GL_ES_VERSION_2_0)
-  GLint aMatrixMode = GL_TEXTURE;
   if (myGlContext->core11 != NULL)
   {
-    glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
-
-    // setup texture matrix
-    glMatrixMode (GL_TEXTURE);
-    OpenGl_Mat4 aTextureMat;
-    const Graphic3d_Vec2& aScale = aParams->Scale();
-    const Graphic3d_Vec2& aTrans = aParams->Translation();
-    OpenGl_Utils::Scale     (aTextureMat,  aScale.x(),  aScale.y(), 1.0f);
-    OpenGl_Utils::Translate (aTextureMat, -aTrans.x(), -aTrans.y(), 0.0f);
-    OpenGl_Utils::Rotate    (aTextureMat, -aParams->Rotation(), 0.0f, 0.0f, 1.0f);
-    glLoadMatrixf (aTextureMat);
-
     GLint anEnvMode = GL_MODULATE; // lighting mode
     if (!aParams->IsModulate())
     {
@@ -460,12 +371,11 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
       }
       case Graphic3d_TOTM_SPRITE:
       {
-        if (GetGlContext()->core20fwd != NULL)
+        if (myGlContext->core20fwd != NULL)
         {
           glEnable  (GL_POINT_SPRITE);
           glTexEnvi (GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
           anEnvMode = GL_REPLACE;
-          GetGlContext()->core15->glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
         }
         break;
       }
@@ -616,12 +526,6 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
     default: break;
   }
 
-#if !defined(GL_ES_VERSION_2_0)
-  if (myGlContext->core11 != NULL)
-  {
-    glMatrixMode (aMatrixMode); // turn back active matrix
-  }
-#endif
   theTexture->SetParams (aParams);
 }
 
@@ -662,524 +566,653 @@ Handle(OpenGl_Texture) OpenGl_Workspace::EnableTexture (const Handle(OpenGl_Text
 }
 
 // =======================================================================
-// function : Redraw
+// function : updateMaterial
 // purpose  :
 // =======================================================================
-void OpenGl_Workspace::Redraw (const Graphic3d_CView& theCView,
-                               const Aspect_CLayer2d& theCUnderLayer,
-                               const Aspect_CLayer2d& theCOverLayer)
+void OpenGl_Workspace::updateMaterial (const int theFlag)
 {
-  if (!Activate())
+  // Case of hidden line
+  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;
   }
 
-  ++myFrameCounter;
-  myIsCullingEnabled = theCView.IsCullingEnabled;
-
-  // release pending GL resources
-  myGlContext->ReleaseDelayed();
-
-  // fetch OpenGl context state
-  myGlContext->FetchState();
-
-  OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theCView.ptrFBO;
-  if (aFrameBuffer != NULL)
+  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)
   {
-    aFrameBuffer->SetupViewport (myGlContext);
+    aFace        = GL_BACK;
+    aSrcMat      = &myAspectFaceSet->Aspect()->BackMaterial();
+    aSrcIntColor = &myAspectFaceSet->Aspect()->BackInteriorColor();
   }
-  else
+  else if (myAspectFaceSet->Aspect()->Distinguish()
+        && !(NamedStatus & OPENGL_NS_RESMAT))
   {
-    myGlContext->core11fwd->glViewport (0, 0, myWidth, myHeight);
+    aFace = GL_FRONT;
   }
-  bool toSwap = myGlContext->IsRender()
-            && !myGlContext->caps->buffersNoSwap
-            &&  aFrameBuffer == NULL;
 
-  Standard_Integer aSizeX = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeX() : myWidth;
-  Standard_Integer aSizeY = aFrameBuffer != NULL ? aFrameBuffer->GetVPSizeY() : myHeight;
+  myMatTmp.Init (*aSrcMat, *aSrcIntColor);
+  if (myToHighlight)
+  {
+    myMatTmp.SetColor (*HighlightColor);
+  }
 
-  if (myHasFboBlit
-   && myTransientDrawToFront)
+  // handling transparency
+  if (NamedStatus & OPENGL_NS_2NDPASSDO)
   {
-    if (myResultFBO->GetVPSizeX() != aSizeX
-     || myResultFBO->GetVPSizeY() != aSizeY)
+    // second pass
+    myMatTmp.Diffuse.a() = aSrcMat->EnvReflexion();
+  }
+  else
+  {
+    if (aSrcMat->EnvReflexion() != 0.0f)
     {
-      // prepare FBOs containing main scene
-      // for further blitting and rendering immediate presentations on top
-      if (myGlContext->core20fwd != NULL)
+      // if the material reflects the environment scene, the second pass is needed
+      NamedStatus |= OPENGL_NS_2NDPASSNEED;
+    }
+
+    const float aTransp = (float )aSrcMat->Transparency();
+    if (aTransp != 0.0f)
+    {
+      // render transparent
+      myMatTmp.Diffuse.a() = 1.0f - aTransp;
+      glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+      glEnable    (GL_BLEND);
+      if (myUseDepthWrite)
       {
-        myResultFBO->Init (myGlContext, aSizeX, aSizeY);
+        glDepthMask (GL_FALSE);
       }
     }
-
-    if (myResultFBO->IsValid())
+    else
     {
-      myResultFBO->SetupViewport (myGlContext);
+      // render opaque
+      glBlendFunc (GL_ONE, GL_ZERO);
+      glDisable   (GL_BLEND);
+      if (myUseDepthWrite)
+      {
+        glDepthMask (GL_TRUE);
+      }
     }
   }
-  else
+
+  // do not update material properties in case of zero reflection mode,
+  // because GL lighting will be disabled by OpenGl_PrimitiveArray::DrawArray() anyway.
+  if (myAspectFaceSet->IsNoLighting())
   {
-    myResultFBO->Release (myGlContext.operator->());
+    return;
   }
 
-  myToRedrawGL = Standard_True;
-  if (theCView.RenderParams.Method == Graphic3d_RM_RAYTRACING
-   && myComputeInitStatus != OpenGl_RT_FAIL)
+  // reset material
+  if (NamedStatus & OPENGL_NS_RESMAT)
   {
-    if (UpdateRaytraceGeometry (OpenGl_GUM_CHECK) && myIsRaytraceDataValid)
+  #if !defined(GL_ES_VERSION_2_0)
+    if (myGlContext->core11 != NULL)
     {
-      myToRedrawGL = Standard_False;
-
-      // Only non-raytracable structures should be rendered in OpenGL mode.
-      Handle(OpenGl_RenderFilter) aRenderFilter = GetRenderFilter();
-      myRaytraceFilter->SetPrevRenderFilter (aRenderFilter);
-      SetRenderFilter (myRaytraceFilter);
-
-      if (myOpenGlFBO.IsNull())
-      {
-        myOpenGlFBO = new OpenGl_FrameBuffer();
-      }
-      if (myOpenGlFBO->GetVPSizeX() != aSizeX
-       || myOpenGlFBO->GetVPSizeY() != aSizeY)
-      {
-        myOpenGlFBO->Init (myGlContext, aSizeX, aSizeY);
-      }
-
-      // OverLayer and UnderLayer shouldn't be drawn by OpenGL.
-      // They will be drawn during ray-tracing.
-      Aspect_CLayer2d anEmptyCLayer;
-      anEmptyCLayer.ptrLayer = NULL;
-
-      myOpenGlFBO->BindBuffer (myGlContext);
-      redraw1 (theCView, anEmptyCLayer, anEmptyCLayer);
-      myOpenGlFBO->UnbindBuffer (myGlContext);
-
-      Raytrace (theCView, aSizeX, aSizeY,
-                theCOverLayer, theCUnderLayer,
-                myResultFBO->IsValid() ? myResultFBO.operator->() : aFrameBuffer);
-      myBackBufferRestored = Standard_True;
-      myIsImmediateDrawn   = Standard_False;
-      if (!redrawImmediate (theCView, theCOverLayer, theCUnderLayer, aFrameBuffer))
-      {
-        toSwap = false;
-      }
-
-      SetRenderFilter (aRenderFilter);
+      myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT,   myMatTmp.Ambient.GetData());
+      myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE,   myMatTmp.Diffuse.GetData());
+      myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR,  myMatTmp.Specular.GetData());
+      myGlContext->core11->glMaterialfv (aFace, GL_EMISSION,  myMatTmp.Emission.GetData());
+      myGlContext->core11->glMaterialf  (aFace, GL_SHININESS, myMatTmp.Shine());
+    }
+  #endif
 
-      theCView.WasRedrawnGL = Standard_False;
+    if (theFlag == TEL_FRONT_MATERIAL)
+    {
+      myMatFront = myMatTmp;
+      myMatBack  = myMatTmp;
+    }
+    else
+    {
+      myMatBack = myMatTmp;
     }
+
+    NamedStatus &= ~OPENGL_NS_RESMAT;
+    return;
   }
 
-  if (myToRedrawGL)
+  // reduce updates
+  OpenGl_Material& anOld = (theFlag == TEL_FRONT_MATERIAL)
+                         ? myMatFront
+                         : myMatBack;
+#if !defined(GL_ES_VERSION_2_0)
+  if (myGlContext->core11 != NULL)
   {
-    // draw entire frame using normal OpenGL pipeline
-    if (myResultFBO->IsValid())
+    if (myMatTmp.Ambient.r() != anOld.Ambient.r()
+     || myMatTmp.Ambient.g() != anOld.Ambient.g()
+     || myMatTmp.Ambient.b() != anOld.Ambient.b())
     {
-      myResultFBO->BindBuffer (myGlContext);
+      myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT, myMatTmp.Ambient.GetData());
     }
-    else if (aFrameBuffer != NULL)
+    if (myMatTmp.Diffuse.r() != anOld.Diffuse.r()
+     || myMatTmp.Diffuse.g() != anOld.Diffuse.g()
+     || myMatTmp.Diffuse.b() != anOld.Diffuse.b()
+     || fabs (myMatTmp.Diffuse.a() - anOld.Diffuse.a()) > 0.01f)
     {
-      aFrameBuffer->BindBuffer (myGlContext);
+      myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE, myMatTmp.Diffuse.GetData());
     }
+    if (myMatTmp.Specular.r() != anOld.Specular.r()
+     || myMatTmp.Specular.g() != anOld.Specular.g()
+     || myMatTmp.Specular.b() != anOld.Specular.b())
+    {
+      myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR, myMatTmp.Specular.GetData());
+    }
+    if (myMatTmp.Emission.r() != anOld.Emission.r()
+     || myMatTmp.Emission.g() != anOld.Emission.g()
+     || myMatTmp.Emission.b() != anOld.Emission.b())
+    {
+      myGlContext->core11->glMaterialfv (aFace, GL_EMISSION, myMatTmp.Emission.GetData());
+    }
+    if (myMatTmp.Shine() != anOld.Shine())
+    {
+      myGlContext->core11->glMaterialf (aFace, GL_SHININESS, myMatTmp.Shine());
+    }
+  }
+#endif
+  anOld = myMatTmp;
+  if (aFace == GL_FRONT_AND_BACK)
+  {
+    myMatBack = myMatTmp;
+  }
+}
 
-    redraw1 (theCView, theCUnderLayer, theCOverLayer);
-    myBackBufferRestored = Standard_True;
-    myIsImmediateDrawn   = Standard_False;
-    if (!redrawImmediate (theCView, theCOverLayer, theCUnderLayer, aFrameBuffer))
+// =======================================================================
+// function : SetAspectLine
+// purpose  :
+// =======================================================================
+const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
+{
+  const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
+  myAspectLineSet = theAspect;
+  return aPrevAspectLine;
+}
+
+// =======================================================================
+// function : SetAspectFace
+// purpose  :
+// =======================================================================
+const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
+{
+  const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
+  myAspectFaceSet = theAspect;
+  return aPrevAspectFace;
+}
+
+// =======================================================================
+// function : SetAspectMarker
+// purpose  :
+// =======================================================================
+const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
+{
+  const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
+  myAspectMarkerSet = theAspect;
+  return aPrevAspectMarker;
+}
+
+// =======================================================================
+// function : SetAspectText
+// purpose  :
+// =======================================================================
+const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
+{
+  const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
+  myAspectTextSet = theAspect;
+  return aPrevAspectText;
+}
+
+// =======================================================================
+// function : ApplyAspectFace
+// purpose  :
+// =======================================================================
+const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
+{
+  if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
+  {
+    // manage back face culling mode, disable culling when clipping is enabled
+    bool toSuppressBackFaces = myToAllowFaceCulling
+                            && myAspectFaceSet->Aspect()->ToSuppressBackFaces();
+    if (toSuppressBackFaces)
+    {
+      if (myGlContext->Clipping().IsClippingOrCappingOn()
+       || myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HATCH)
+      {
+        toSuppressBackFaces = false;
+      }
+    }
+    if (toSuppressBackFaces)
     {
-      toSwap = false;
+      if (!(NamedStatus & OPENGL_NS_2NDPASSDO)
+       && (float )myAspectFaceSet->Aspect()->FrontMaterial().Transparency() != 0.0f)
+      {
+        // disable culling in case of translucent shading aspect
+        toSuppressBackFaces = false;
+      }
     }
+    myGlContext->SetCullBackFaces (toSuppressBackFaces);
+  }
 
-    theCView.WasRedrawnGL = Standard_True;
+  if (myAspectFaceSet->Aspect() == myAspectFaceApplied
+   && myToHighlight == myAspectFaceAppliedWithHL)
+  {
+    return myAspectFaceSet;
   }
+  myAspectFaceAppliedWithHL = myToHighlight;
 
-  if (aFrameBuffer != NULL)
+#if !defined(GL_ES_VERSION_2_0)
+  const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->Aspect()->InteriorStyle();
+  if (myAspectFaceApplied.IsNull()
+   || myAspectFaceApplied->InteriorStyle() != anIntstyle)
   {
-    aFrameBuffer->UnbindBuffer (myGlContext);
-    // move back original viewport
-    myGlContext->core11fwd->glViewport (0, 0, myWidth, myHeight);
+    switch (anIntstyle)
+    {
+      case Aspect_IS_EMPTY:
+      case Aspect_IS_HOLLOW:
+      {
+        myGlContext->SetPolygonMode (GL_LINE);
+        break;
+      }
+      case Aspect_IS_HATCH:
+      {
+        myGlContext->SetPolygonMode (GL_FILL);
+        myGlContext->SetPolygonHatchEnabled (true);
+        break;
+      }
+      case Aspect_IS_SOLID:
+      case Aspect_IS_HIDDENLINE:
+      {
+        myGlContext->SetPolygonMode (GL_FILL);
+        myGlContext->SetPolygonHatchEnabled (false);
+        break;
+      }
+      case Aspect_IS_POINT:
+      {
+        myGlContext->SetPolygonMode (GL_POINT);
+        break;
+      }
+    }
   }
 
-#if defined(_WIN32) && defined(HAVE_VIDEOCAPTURE)
-  if (OpenGl_AVIWriter_AllowWriting (theCView.DefWindow.XWindow))
+  if (anIntstyle == Aspect_IS_HATCH)
   {
-    GLint params[4];
-    glGetIntegerv (GL_VIEWPORT, params);
-    int nWidth  = params[2] & ~0x7;
-    int nHeight = params[3] & ~0x7;
-
-    const int nBitsPerPixel = 24;
-    GLubyte* aDumpData = new GLubyte[nWidth * nHeight * nBitsPerPixel / 8];
-
-    glPixelStorei (GL_PACK_ALIGNMENT, 1);
-    glReadPixels (0, 0, nWidth, nHeight, GL_BGR_EXT, GL_UNSIGNED_BYTE, aDumpData);
-    OpenGl_AVIWriter_AVIWriter (aDumpData, nWidth, nHeight, nBitsPerPixel);
-    delete[] aDumpData;
+    myGlContext->SetPolygonHatchStyle (myAspectFaceSet->Aspect()->HatchStyle());
   }
 #endif
 
-  // Swap the buffers
-  if (toSwap)
+  // Aspect_POM_None means: do not change current settings
+  if ((myAspectFaceSet->Aspect()->PolygonOffset().Mode & Aspect_POM_None) != Aspect_POM_None)
   {
-    GetGlContext()->SwapBuffers();
-    if (!myResultFBO->IsValid())
+    if (myPolygonOffsetApplied.Mode   != myAspectFaceSet->Aspect()->PolygonOffset().Mode
+     || myPolygonOffsetApplied.Factor != myAspectFaceSet->Aspect()->PolygonOffset().Factor
+     || myPolygonOffsetApplied.Units  != myAspectFaceSet->Aspect()->PolygonOffset().Units)
     {
-      myBackBufferRestored = Standard_False;
+      SetPolygonOffset (myAspectFaceSet->Aspect()->PolygonOffset());
     }
   }
-  else
+
+  updateMaterial (TEL_FRONT_MATERIAL);
+  if (myAspectFaceSet->Aspect()->Distinguish())
   {
-    myGlContext->core11fwd->glFlush();
+    updateMaterial (TEL_BACK_MATERIAL);
   }
 
-  // reset render mode state
-  myGlContext->FetchState();
-}
-
-// =======================================================================
-// function : redraw1
-// purpose  :
-// =======================================================================
-void OpenGl_Workspace::redraw1 (const Graphic3d_CView& theCView,
-                                const Aspect_CLayer2d& theCUnderLayer,
-                                const Aspect_CLayer2d& theCOverLayer)
-{
-  if (myView.IsNull())
+  if (myAspectFaceSet->Aspect()->ToMapTexture())
   {
-    return;
+    EnableTexture (myAspectFaceSet->TextureRes (myGlContext),
+                   myAspectFaceSet->TextureParams());
   }
-
-  // request reset of material
-  NamedStatus |= OPENGL_NS_RESMAT;
-
-  GLbitfield toClear = GL_COLOR_BUFFER_BIT;
-  if (myUseZBuffer)
+  else
   {
-    glDepthFunc (GL_LEQUAL);
-    glDepthMask (GL_TRUE);
-    if (myUseDepthTest)
+    if (!myEnvironmentTexture.IsNull())
     {
-      glEnable (GL_DEPTH_TEST);
+      EnableTexture (myEnvironmentTexture,
+                     myEnvironmentTexture->GetParams());
     }
     else
     {
-      glDisable (GL_DEPTH_TEST);
+      DisableTexture();
     }
+  }
 
-  #if !defined(GL_ES_VERSION_2_0)
-    glClearDepth (1.0);
-  #else
-    glClearDepthf (1.0f);
-  #endif
-    toClear |= GL_DEPTH_BUFFER_BIT;
+  myAspectFaceApplied = myAspectFaceSet->Aspect();
+  return myAspectFaceSet;
+}
+
+//=======================================================================
+//function : SetPolygonOffset
+//purpose  :
+//=======================================================================
+void OpenGl_Workspace::SetPolygonOffset (const Graphic3d_PolygonOffset& theParams)
+{
+  myPolygonOffsetApplied = theParams;
+
+  if ((theParams.Mode & Aspect_POM_Fill) == Aspect_POM_Fill)
+  {
+    glEnable (GL_POLYGON_OFFSET_FILL);
   }
   else
   {
-    glDisable (GL_DEPTH_TEST);
+    glDisable (GL_POLYGON_OFFSET_FILL);
   }
 
-  if (!ToRedrawGL())
+#if !defined(GL_ES_VERSION_2_0)
+  if ((theParams.Mode & Aspect_POM_Line) == Aspect_POM_Line)
   {
-    // set background to black
-    glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
-    toClear |= GL_DEPTH_BUFFER_BIT; //
+    glEnable (GL_POLYGON_OFFSET_LINE);
   }
   else
   {
-    if (NamedStatus & OPENGL_NS_WHITEBACK)
-    {
-        // set background to white
-      glClearColor (1.0f, 1.0f, 1.0f, 1.0f);
-      toClear |= GL_DEPTH_BUFFER_BIT;
-    }
-    else
-    {
-      glClearColor (myBgColor.rgb[0], myBgColor.rgb[1], myBgColor.rgb[2], 0.0f);
-    }
+    glDisable (GL_POLYGON_OFFSET_LINE);
   }
-  glClear (toClear);
 
-  Handle(OpenGl_Workspace) aWS (this);
-  myView->Render (myPrintContext, aWS, theCView, theCUnderLayer, theCOverLayer, Standard_False);
+  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 : copyBackToFront
+// function : ApplyAspectMarker
 // purpose  :
 // =======================================================================
-void OpenGl_Workspace::copyBackToFront()
+const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
 {
-#if !defined(GL_ES_VERSION_2_0)
-
-  OpenGl_Mat4 aProjectMat;
-  OpenGl_Utils::Ortho2D<Standard_ShortReal> (aProjectMat,
-    0.f, static_cast<GLfloat> (myWidth), 0.f, static_cast<GLfloat> (myHeight));
-
-  myGlContext->WorldViewState.Push();
-  myGlContext->ProjectionState.Push();
-
-  myGlContext->WorldViewState.SetIdentity();
-  myGlContext->ProjectionState.SetCurrent (aProjectMat);
-
-  myGlContext->ApplyProjectionMatrix();
-  myGlContext->ApplyWorldViewMatrix();
-
-  DisableFeatures();
-
-  glDrawBuffer (GL_FRONT);
-  glReadBuffer (GL_BACK);
+  if (myAspectMarkerSet->Aspect() != myAspectMarkerApplied)
+  {
+    if (myAspectMarkerApplied.IsNull()
+    || (myAspectMarkerSet->Aspect()->Scale() != myAspectMarkerApplied->Scale()))
+    {
+    #if !defined(GL_ES_VERSION_2_0)
+      glPointSize (myAspectMarkerSet->Aspect()->Scale());
+    #ifdef HAVE_GL2PS
+      gl2psPointSize (myAspectMarkerSet->Aspect()->Scale());
+    #endif
+    #endif
+    }
+    myAspectMarkerApplied = myAspectMarkerSet->Aspect();
+  }
+  return myAspectMarkerSet;
+}
 
-  glRasterPos2i (0, 0);
-  glCopyPixels  (0, 0, myWidth + 1, myHeight + 1, GL_COLOR);
-  //glCopyPixels  (0, 0, myWidth + 1, myHeight + 1, GL_DEPTH);
+// =======================================================================
+// function : Width
+// purpose  :
+// =======================================================================
+Standard_Integer OpenGl_Workspace::Width()  const
+{
+  return !myView->GlWindow().IsNull() ? myView->GlWindow()->Width() : 0;
+}
 
-  EnableFeatures();
+// =======================================================================
+// function : Height
+// purpose  :
+// =======================================================================
+Standard_Integer OpenGl_Workspace::Height() const
+{
+  return !myView->GlWindow().IsNull() ? myView->GlWindow()->Height() : 0;
+}
 
-  myGlContext->WorldViewState.Pop();
-  myGlContext->ProjectionState.Pop();
-  myGlContext->ApplyProjectionMatrix();
-  glDrawBuffer (GL_BACK);
+// =======================================================================
+// function : UseGLLight
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_Workspace::UseGLLight() const
+{
+  return myView->IsGLLightEnabled();
+}
 
-#endif
-  myIsImmediateDrawn = Standard_False;
+// =======================================================================
+// function : IsCullingEnabled
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_Workspace::IsCullingEnabled() const
+{
+  return myView->IsCullingEnabled();
 }
 
 // =======================================================================
-// function : DisplayCallback
+// function : FBOCreate
 // purpose  :
 // =======================================================================
-void OpenGl_Workspace::DisplayCallback (const Graphic3d_CView& theCView,
-                                        Standard_Integer       theReason)
+Handle(OpenGl_FrameBuffer) OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
+                                                        const Standard_Integer theHeight)
 {
-  if (theCView.GDisplayCB == NULL)
+  // activate OpenGL context
+  if (!Activate())
+    return Handle(OpenGl_FrameBuffer)();
+
+  DisableTexture();
+
+  // create the FBO
+  const Handle(OpenGl_Context)& aCtx = GetGlContext();
+  Handle(OpenGl_FrameBuffer) aFrameBuffer = new OpenGl_FrameBuffer();
+  if (!aFrameBuffer->Init (aCtx, theWidth, theHeight, GL_RGBA8, GL_DEPTH24_STENCIL8, 0))
   {
-    return;
+    aFrameBuffer->Release (aCtx.operator->());
+    return Handle(OpenGl_FrameBuffer)();
   }
-
-  Aspect_GraphicCallbackStruct aCallData;
-  aCallData.reason    = theReason;
-  aCallData.glContext = myGlContext;
-  aCallData.wsID      = theCView.WsId;
-  aCallData.viewID    = theCView.ViewId;
-  aCallData.IsCoreProfile = (myGlContext->core11 == NULL);
-  theCView.GDisplayCB (theCView.DefWindow.XWindow, theCView.GClientData, &aCallData);
+  return aFrameBuffer;
 }
 
 // =======================================================================
-// function : RedrawImmediate
+// function : FBORelease
 // purpose  :
 // =======================================================================
-void OpenGl_Workspace::RedrawImmediate (const Graphic3d_CView& theCView,
-                                        const Aspect_CLayer2d& theCUnderLayer,
-                                        const Aspect_CLayer2d& theCOverLayer)
+void OpenGl_Workspace::FBORelease (Handle(OpenGl_FrameBuffer)& theFbo)
 {
-  if (!myTransientDrawToFront
-   || !myBackBufferRestored
-   || (myGlContext->caps->buffersNoSwap && !myResultFBO->IsValid()))
-  {
-    Redraw (theCView, theCUnderLayer, theCOverLayer);
-    return;
-  }
-  else if (!Activate())
+  // activate OpenGL context
+  if (!Activate()
+   || theFbo.IsNull())
   {
     return;
   }
 
-  if (redrawImmediate (theCView, theCUnderLayer, theCOverLayer, NULL, Standard_True))
-  {
-    myGlContext->SwapBuffers();
-  }
-  else
+  theFbo->Release (GetGlContext().operator->());
+  theFbo.Nullify();
+}
+
+inline bool getDataFormat (const Image_PixMap& theData,
+                           GLenum&             thePixelFormat,
+                           GLenum&             theDataType)
+{
+  thePixelFormat = GL_RGB;
+  theDataType    = GL_UNSIGNED_BYTE;
+  switch (theData.Format())
   {
-    myGlContext->core11fwd->glFlush();
-    MakeBackBufCurrent();
+  #if !defined(GL_ES_VERSION_2_0)
+    case Image_PixMap::ImgGray:
+      thePixelFormat = GL_DEPTH_COMPONENT;
+      theDataType    = GL_UNSIGNED_BYTE;
+      return true;
+    case Image_PixMap::ImgGrayF:
+      thePixelFormat = GL_DEPTH_COMPONENT;
+      theDataType    = GL_FLOAT;
+      return true;
+    case Image_PixMap::ImgBGR:
+      thePixelFormat = GL_BGR;
+      theDataType    = GL_UNSIGNED_BYTE;
+      return true;
+    case Image_PixMap::ImgBGRA:
+    case Image_PixMap::ImgBGR32:
+      thePixelFormat = GL_BGRA;
+      theDataType    = GL_UNSIGNED_BYTE;
+      return true;
+    case Image_PixMap::ImgBGRF:
+      thePixelFormat = GL_BGR;
+      theDataType    = GL_FLOAT;
+      return true;
+    case Image_PixMap::ImgBGRAF:
+      thePixelFormat = GL_BGRA;
+      theDataType    = GL_FLOAT;
+      return true;
+  #else
+    case Image_PixMap::ImgGray:
+    case Image_PixMap::ImgGrayF:
+    case Image_PixMap::ImgBGR:
+    case Image_PixMap::ImgBGRA:
+    case Image_PixMap::ImgBGR32:
+    case Image_PixMap::ImgBGRF:
+    case Image_PixMap::ImgBGRAF:
+      return false;
+  #endif
+    case Image_PixMap::ImgRGB:
+      thePixelFormat = GL_RGB;
+      theDataType    = GL_UNSIGNED_BYTE;
+      return true;
+    case Image_PixMap::ImgRGBA:
+    case Image_PixMap::ImgRGB32:
+      thePixelFormat = GL_RGBA;
+      theDataType    = GL_UNSIGNED_BYTE;
+      return true;
+    case Image_PixMap::ImgRGBF:
+      thePixelFormat = GL_RGB;
+      theDataType    = GL_FLOAT;
+      return true;
+    case Image_PixMap::ImgRGBAF:
+      thePixelFormat = GL_RGBA;
+      theDataType    = GL_FLOAT;
+      return true;
+    case Image_PixMap::ImgAlpha:
+    case Image_PixMap::ImgAlphaF:
+      return false; // GL_ALPHA is no more supported in core context
+    case Image_PixMap::ImgUNKNOWN:
+      return false;
   }
+  return false;
+}
+
+// =======================================================================
+// function : getAligned
+// purpose  :
+// =======================================================================
+inline Standard_Size getAligned (const Standard_Size theNumber,
+                                 const Standard_Size theAlignment)
+{
+  return theNumber + theAlignment - 1 - (theNumber - 1) % theAlignment;
 }
 
 // =======================================================================
-// function : redrawImmediate
+// function : BufferDump
 // purpose  :
 // =======================================================================
-bool OpenGl_Workspace::redrawImmediate (const Graphic3d_CView& theCView,
-                                        const Aspect_CLayer2d& theCUnderLayer,
-                                        const Aspect_CLayer2d& theCOverLayer,
-                                        OpenGl_FrameBuffer*    theTargetFBO,
-                                        const Standard_Boolean theIsPartialUpdate)
+Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
+                                               Image_PixMap&                     theImage,
+                                               const Graphic3d_BufferType&       theBufferType)
 {
-  GLboolean toCopyBackToFront = GL_FALSE;
-  if (!myTransientDrawToFront)
+  GLenum aFormat, aType;
+  if (theImage.IsEmpty()
+   || !getDataFormat (theImage, aFormat, aType)
+   || !Activate())
   {
-    myBackBufferRestored = Standard_False;
+    return Standard_False;
   }
-  else if (myResultFBO->IsValid()
-        && myGlContext->IsRender())
+#if !defined(GL_ES_VERSION_2_0)
+  GLint aReadBufferPrev = GL_BACK;
+  if (theBufferType == Graphic3d_BT_Depth
+   && aFormat != GL_DEPTH_COMPONENT)
+  {
+    return Standard_False;
+  }
+#else
+  (void )theBufferType;
+#endif
+
+  // bind FBO if used
+  if (!theFbo.IsNull() && theFbo->IsValid())
+  {
+    theFbo->BindBuffer (GetGlContext());
+  }
+  else
   {
-    // clear destination before blitting
-    if (theTargetFBO != NULL)
-    {
-      theTargetFBO->BindBuffer (myGlContext);
-    }
-    else
-    {
-      myGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
-    }
   #if !defined(GL_ES_VERSION_2_0)
-    myGlContext->core20fwd->glClearDepth  (1.0);
-  #else
-    myGlContext->core20fwd->glClearDepthf (1.0f);
+    glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
+    GLint aDrawBufferPrev = GL_BACK;
+    glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
+    glReadBuffer (aDrawBufferPrev);
   #endif
-    myGlContext->core20fwd->glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
-  /*#if !defined(GL_ES_VERSION_2_0)
-    if (myGlContext->arbFBOBlit != NULL)
-    {
-      myResultFBO->BindReadBuffer (myGlContext);
-      if (theTargetFBO != NULL)
-      {
-        theTargetFBO->BindDrawBuffer (myGlContext);
-      }
-      else
-      {
-        myGlContext->arbFBO->glBindFramebuffer (GL_DRAW_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
-      }
-      // we don't copy stencil buffer here... does it matter for performance?
-      myGlContext->arbFBOBlit->glBlitFramebuffer (0, 0, myResultFBO->GetVPSizeX(), myResultFBO->GetVPSizeY(),
-                                                  0, 0, myResultFBO->GetVPSizeX(), myResultFBO->GetVPSizeY(),
-                                                  GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-
-      if (theTargetFBO != NULL)
-      {
-        theTargetFBO->BindBuffer (myGlContext);
-      }
-      else
-      {
-        myGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
-      }
-    }
-    else
-  #endif*/
-    {
-      myGlContext->core20fwd->glDepthFunc (GL_ALWAYS);
-      myGlContext->core20fwd->glDepthMask (GL_TRUE);
-      myGlContext->core20fwd->glEnable (GL_DEPTH_TEST);
-
-      DisableTexture();
-      if (!myFullScreenQuad.IsValid())
-      {
-        OpenGl_Vec4 aQuad[4] =
-        {
-          OpenGl_Vec4( 1.0f, -1.0f, 1.0f, 0.0f),
-          OpenGl_Vec4( 1.0f,  1.0f, 1.0f, 1.0f),
-          OpenGl_Vec4(-1.0f, -1.0f, 0.0f, 0.0f),
-          OpenGl_Vec4(-1.0f,  1.0f, 0.0f, 1.0f)
-        };
-        myFullScreenQuad.Init (myGlContext, 4, 4, aQuad[0].GetData());
-      }
-
-      const Handle(OpenGl_ShaderManager)& aManager = myGlContext->ShaderManager();
-      if (myFullScreenQuad.IsValid()
-       && aManager->BindFboBlitProgram())
-      {
-        myResultFBO->ColorTexture()       ->Bind   (myGlContext, GL_TEXTURE0 + 0);
-        myResultFBO->DepthStencilTexture()->Bind   (myGlContext, GL_TEXTURE0 + 1);
-        myFullScreenQuad.BindVertexAttrib (myGlContext, 0);
+  }
 
-        myGlContext->core20fwd->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
+  // setup alignment
+  const GLint anAligment   = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
+  glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
+  bool isBatchCopy = !theImage.IsTopDown();
 
-        myFullScreenQuad.UnbindVertexAttrib (myGlContext, 0);
-        myResultFBO->DepthStencilTexture()->Unbind (myGlContext, GL_TEXTURE0 + 1);
-        myResultFBO->ColorTexture()       ->Unbind (myGlContext, GL_TEXTURE0 + 0);
-      }
-      else
-      {
-        TCollection_ExtendedString aMsg = TCollection_ExtendedString()
-          + "Error! FBO blitting has failed";
-        myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
-                                  GL_DEBUG_TYPE_ERROR_ARB,
-                                  0,
-                                  GL_DEBUG_SEVERITY_HIGH_ARB,
-                                  aMsg);
-        myHasFboBlit = Standard_False;
-        myResultFBO->Release (myGlContext.operator->());
-        return true;
-      }
-    }
+  const GLint   anExtraBytes       = GLint(theImage.RowExtraBytes());
+  GLint         aPixelsWidth       = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
+  Standard_Size aSizeRowBytesEstim = getAligned (theImage.SizePixelBytes() * aPixelsWidth, anAligment);
+  if (anExtraBytes < anAligment)
+  {
+    aPixelsWidth = 0;
   }
-  else if (theTargetFBO == NULL)
+  else if (aSizeRowBytesEstim != theImage.SizeRowBytes())
   {
-  #if !defined(GL_ES_VERSION_2_0)
-    myGlContext->core11fwd->glGetBooleanv (GL_DOUBLEBUFFER, &toCopyBackToFront);
-  #endif
-    if (toCopyBackToFront)
-    {
-      if (!myView->HasImmediateStructures()
-       && !theIsPartialUpdate)
-      {
-        // prefer Swap Buffers within Redraw in compatibility mode (without FBO)
-        return true;
-      }
-      copyBackToFront();
-      MakeFrontBufCurrent();
-    }
-    else
-    {
-      myBackBufferRestored = Standard_False;
-    }
+    aPixelsWidth = 0;
+    isBatchCopy  = false;
   }
-  else
+#if !defined(GL_ES_VERSION_2_0)
+  glPixelStorei (GL_PACK_ROW_LENGTH, aPixelsWidth);
+#else
+  if (aPixelsWidth != 0)
   {
-    myBackBufferRestored = Standard_False;
+    isBatchCopy = false;
   }
-  myIsImmediateDrawn = Standard_True;
-
-  Handle(OpenGl_Workspace) aWS (this);
+#endif
 
-  if (myUseZBuffer)
+  if (!isBatchCopy)
   {
-    glDepthFunc (GL_LEQUAL);
-    glDepthMask (GL_TRUE);
-    if (myUseDepthTest)
-    {
-      glEnable (GL_DEPTH_TEST);
-    }
-    else
+    // copy row by row
+    for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
     {
-      glDisable (GL_DEPTH_TEST);
+      // Image_PixMap rows indexation always starts from the upper corner
+      // while order in memory depends on the flag and processed by ChangeRow() method
+      glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
     }
-
-  #if !defined(GL_ES_VERSION_2_0)
-    glClearDepth (1.0);
-  #else
-    glClearDepthf (1.0f);
-  #endif
   }
   else
   {
-    glDisable (GL_DEPTH_TEST);
+    glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
   }
 
-  myView->Render (myPrintContext, aWS, theCView, theCUnderLayer, theCOverLayer, Standard_True);
-  if (!myView->ImmediateStructures().IsEmpty())
+  glPixelStorei (GL_PACK_ALIGNMENT,  1);
+#if !defined(GL_ES_VERSION_2_0)
+  glPixelStorei (GL_PACK_ROW_LENGTH, 0);
+#endif
+
+  if (!theFbo.IsNull() && theFbo->IsValid())
   {
-    glDisable (GL_DEPTH_TEST);
+    theFbo->UnbindBuffer (GetGlContext());
   }
-  for (OpenGl_SequenceOfStructure::Iterator anIter (myView->ImmediateStructures());
-       anIter.More(); anIter.Next())
+  else
   {
-    const OpenGl_Structure* aStructure = anIter.Value();
-    if (!aStructure->IsVisible())
-    {
-      continue;
-    }
-
-    aStructure->Render (aWS);
+  #if !defined(GL_ES_VERSION_2_0)
+    glReadBuffer (aReadBufferPrev);
+  #endif
   }
+  return Standard_True;
+}
 
-  if (toCopyBackToFront)
+// =======================================================================
+// function : CanRender
+// purpose  :
+// =======================================================================
+Standard_Boolean OpenGl_RaytraceFilter::CanRender (const OpenGl_Element* theElement)
+{
+  Standard_Boolean aPrevFilterResult = Standard_True;
+  if (!myPrevRenderFilter.IsNull())
   {
-    MakeBackBufCurrent();
-    return false;
+    aPrevFilterResult = myPrevRenderFilter->CanRender (theElement);
   }
-  return true;
+  return aPrevFilterResult &&
+    !OpenGl_Raytrace::IsRaytracedElement (theElement);
 }