0026809: Visualization, TKOpenGl - handle point arrays with per-vertex color within...
authorduv <duv@opencascade.com>
Sun, 17 Apr 2016 09:43:08 +0000 (12:43 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 22 Apr 2016 12:22:03 +0000 (15:22 +0300)
Shader rendering of point sprites with per-vertex colors and shading have been fixed.

Material state was removed from OpenGl_ShaderManager.
Material properties now should be modified trough OpenGl_Context::SetShadingMaterial().

src/OpenGl/OpenGl_Context.cxx
src/OpenGl/OpenGl_Context.hxx
src/OpenGl/OpenGl_PrimitiveArray.cxx
src/OpenGl/OpenGl_ShaderManager.cxx
src/OpenGl/OpenGl_ShaderManager.hxx
src/OpenGl/OpenGl_ShaderProgram.cxx
src/OpenGl/OpenGl_Text.cxx
src/OpenGl/OpenGl_View_Redraw.cxx

index b96d000..10a2c51 100644 (file)
@@ -29,6 +29,8 @@
 #include <OpenGl_FrameBuffer.hxx>
 #include <OpenGl_Sampler.hxx>
 #include <OpenGl_ShaderManager.hxx>
+#include <OpenGl_Workspace.hxx>
+#include <OpenGl_AspectFace.hxx>
 #include <Graphic3d_TransformUtils.hxx>
 
 #include <Message_Messenger.hxx>
@@ -2509,6 +2511,43 @@ Handle(OpenGl_FrameBuffer) OpenGl_Context::SetDefaultFrameBuffer (const Handle(O
 }
 
 // =======================================================================
+// function : SetShadingMaterial
+// purpose  :
+// =======================================================================
+void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect)
+{
+  if (!myActiveProgram.IsNull())
+  {
+    myActiveProgram->SetUniform (this,
+                                 myActiveProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
+                                 theAspect->DoTextureMap());
+    myActiveProgram->SetUniform (this,
+                                 myActiveProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
+                                 theAspect->DistinguishingMode());
+
+    OpenGl_Material aParams;
+    for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
+    {
+      const GLint aLoc = myActiveProgram->GetStateLocation (anIndex == 0
+                                                          ? OpenGl_OCCT_FRONT_MATERIAL
+                                                          : OpenGl_OCCT_BACK_MATERIAL);
+      if (aLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
+      {
+        continue;
+      }
+
+      const OPENGL_SURF_PROP& aProp = anIndex == 0 || theAspect->DistinguishingMode() != TOn
+                                    ? theAspect->IntFront()
+                                    : theAspect->IntBack();
+      aParams.Init (aProp);
+      aParams.Diffuse.a() = aProp.trans;
+      myActiveProgram->SetUniform (this, aLoc, OpenGl_Material::NbOfVec4(),
+                                   aParams.Packed());
+    }
+  }
+}
+
+// =======================================================================
 // function : SetColor4fv
 // purpose  :
 // =======================================================================
index a41b111..f43b381 100644 (file)
@@ -128,6 +128,7 @@ typedef OpenGl_TmplCore44<OpenGl_GlCore43>     OpenGl_GlCore44;
 class OpenGl_ShaderManager;
 class OpenGl_Sampler;
 class OpenGl_FrameBuffer;
+class OpenGl_AspectFace;
 
 class OpenGl_Context;
 DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
@@ -549,6 +550,9 @@ public: //! @name methods to alter or retrieve current state
   //! @return true if some program is bound to context
   Standard_EXPORT Standard_Boolean BindProgram (const Handle(OpenGl_ShaderProgram)& theProgram);
 
+  //! Setup current shading material.
+  Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect);
+
   //! Setup current color.
   Standard_EXPORT void SetColor4fv (const OpenGl_Vec4& theColor);
 
index 9b01949..7107c5e 100644 (file)
@@ -467,7 +467,7 @@ void OpenGl_PrimitiveArray::drawEdges (const TEL_COLOUR*               theEdgeCo
 
   if (aGlContext->core20fwd != NULL)
   {
-    aGlContext->ShaderManager()->BindProgram (anAspect, NULL, Standard_False, Standard_False, anAspect->ShaderProgramRes (aGlContext));
+    aGlContext->ShaderManager()->BindLineProgram (NULL, anAspect->Type() != Aspect_TOL_SOLID, Standard_False, Standard_False, anAspect->ShaderProgramRes (aGlContext));
   }
 
   /// OCC22236 NOTE: draw edges for all situations:
@@ -771,18 +771,18 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
                                                       ? anAspectMarker->SpriteHighlightRes (aCtx)
                                                       : aSpriteNorm;
             theWorkspace->EnableTexture (aSprite);
-            aCtx->ShaderManager()->BindProgram (anAspectMarker, aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
+            aCtx->ShaderManager()->BindMarkerProgram (aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
           }
           else
           {
-            aCtx->ShaderManager()->BindProgram (anAspectMarker, NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
+            aCtx->ShaderManager()->BindMarkerProgram (NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
           }
           break;
         }
         case GL_LINES:
         case GL_LINE_STRIP:
         {
-          aCtx->ShaderManager()->BindProgram (anAspectLine, NULL, isLightOn, hasVertColor, anAspectLine->ShaderProgramRes (aCtx));
+          aCtx->ShaderManager()->BindLineProgram (NULL, anAspectLine->Type() != Aspect_TOL_SOLID, isLightOn, hasVertColor, anAspectLine->ShaderProgramRes (aCtx));
           break;
         }
         default:
@@ -792,17 +792,22 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
                                               && (aTexture.IsNull()
                                                || aTexture->GetParams()->IsModulate());
           const Standard_Boolean toEnableEnvMap = (!aTexture.IsNull() && (aTexture == theWorkspace->EnvironmentTexture()));
-          aCtx->ShaderManager()->BindProgram (anAspectFace,
-                                              aTexture,
-                                              isLightOnFace,
-                                              hasVertColor,
-                                              toEnableEnvMap,
-                                              anAspectFace->ShaderProgramRes (aCtx));
+          aCtx->ShaderManager()->BindFaceProgram (aTexture,
+                                                  isLightOnFace,
+                                                  hasVertColor,
+                                                  toEnableEnvMap,
+                                                  anAspectFace->ShaderProgramRes (aCtx));
           break;
         }
       }
     }
 
+    // All primitives should gather material properties from the AspectFace in shading mode
+    if (isLightOn)
+    {
+      aCtx->SetShadingMaterial (anAspectFace);
+    }
+
     if (!theWorkspace->ActiveTexture().IsNull()
      && myDrawMode != GL_POINTS) // transformation is not supported within point sprites
     {
index 959faf8..0ff8cf6 100644 (file)
@@ -338,7 +338,6 @@ void OpenGl_ShaderManager::Unregister (TCollection_AsciiString&      theShareKey
       }
 
       myProgramList.Remove (anIt);
-      myMaterialStates.UnBind (theProgram);
       break;
     }
   }
@@ -810,230 +809,12 @@ void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)
 }
 
 // =======================================================================
-// function : UpdateMaterialStateTo
-// purpose  : Updates state of OCCT material for specified program
-// =======================================================================
-void OpenGl_ShaderManager::UpdateMaterialStateTo (const Handle(OpenGl_ShaderProgram)& theProgram,
-                                                  const OpenGl_Element*               theAspect)
-{
-  if (myMaterialStates.IsBound (theProgram))
-  {
-    OpenGl_MaterialState& aState = myMaterialStates.ChangeFind (theProgram);
-    aState.Set (theAspect);
-    aState.Update();
-  }
-  else
-  {
-    myMaterialStates.Bind       (theProgram, OpenGl_MaterialState (theAspect));
-    myMaterialStates.ChangeFind (theProgram).Update();
-  }
-}
-
-// =======================================================================
-// function : ResetMaterialStates
-// purpose  : Resets state of OCCT material for all programs
-// =======================================================================
-void OpenGl_ShaderManager::ResetMaterialStates()
-{
-  for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
-  {
-    anIt.Value()->UpdateState (OpenGl_MATERIALS_STATE, 0);
-  }
-}
-
-// =======================================================================
-// function : MaterialState
-// purpose  : Returns state of OCCT material for specified program
-// =======================================================================
-const OpenGl_MaterialState* OpenGl_ShaderManager::MaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
-{
-  if (!myMaterialStates.IsBound (theProgram))
-    return NULL;
-
-  return &myMaterialStates.Find (theProgram);
-}
-
-namespace
-{
-
-static const OpenGl_Vec4 THE_COLOR_BLACK_VEC4 (0.0f, 0.0f, 0.0f, 0.0f);
-
-// =======================================================================
-// function : PushAspectFace
-// purpose  :
-// =======================================================================
-static void PushAspectFace (const Handle(OpenGl_Context)&       theCtx,
-                            const Handle(OpenGl_ShaderProgram)& theProgram,
-                            const OpenGl_AspectFace*            theAspect)
-{
-  theProgram->SetUniform (theCtx,
-                          theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
-                          theAspect->DoTextureMap());
-  theProgram->SetUniform (theCtx,
-                          theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),
-                          0 /* GL_TEXTURE0 */);
-  theProgram->SetUniform (theCtx,
-                          theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
-                          theAspect->DistinguishingMode());
-
-  OpenGl_Material aParams;
-  for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
-  {
-    const GLint aLoc = theProgram->GetStateLocation (anIndex == 0
-                                                   ? OpenGl_OCCT_FRONT_MATERIAL
-                                                   : OpenGl_OCCT_BACK_MATERIAL);
-    if (aLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
-    {
-      continue;
-    }
-
-    const OPENGL_SURF_PROP& aProp = anIndex == 0 || theAspect->DistinguishingMode() != TOn
-                                  ? theAspect->IntFront()
-                                  : theAspect->IntBack();
-    aParams.Init (aProp);
-    aParams.Diffuse.a() = aProp.trans;
-    theProgram->SetUniform (theCtx, aLoc, OpenGl_Material::NbOfVec4(),
-                            aParams.Packed());
-  }
-}
-
-// =======================================================================
-// function : PushAspectLine
-// purpose  :
-// =======================================================================
-static void PushAspectLine (const Handle(OpenGl_Context)&       theCtx,
-                            const Handle(OpenGl_ShaderProgram)& theProgram,
-                            const OpenGl_AspectLine*            theAspect)
-{
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOff);
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
-
-  const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
-                              theAspect->Color().rgb[1],
-                              theAspect->Color().rgb[2],
-                              theAspect->Color().rgb[3]);
-  OpenGl_Vec4 aParams[5];
-  aParams[0] = THE_COLOR_BLACK_VEC4;
-  aParams[1] = THE_COLOR_BLACK_VEC4;
-  aParams[2] = aDiffuse;
-  aParams[3] = THE_COLOR_BLACK_VEC4;
-  aParams[4].x() = 0.0f; // shininess
-  aParams[4].y() = 0.0f; // transparency
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
-                          5, aParams);
-}
-
-// =======================================================================
-// function : PushAspectText
-// purpose  :
-// =======================================================================
-static void PushAspectText (const Handle(OpenGl_Context)&       theCtx,
-                            const Handle(OpenGl_ShaderProgram)& theProgram,
-                            const OpenGl_AspectText*            theAspect)
-{
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
-
-  OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
-                        theAspect->Color().rgb[1],
-                        theAspect->Color().rgb[2],
-                        theAspect->Color().rgb[3]);
-  if (theAspect->DisplayType() == Aspect_TODT_DEKALE
-   || theAspect->DisplayType() == Aspect_TODT_SUBTITLE)
-  {
-    aDiffuse = OpenGl_Vec4 (theAspect->SubtitleColor().rgb[0],
-                            theAspect->SubtitleColor().rgb[1],
-                            theAspect->SubtitleColor().rgb[2],
-                            theAspect->SubtitleColor().rgb[3]);
-  }
-
-  OpenGl_Vec4 aParams[5];
-  aParams[0] = THE_COLOR_BLACK_VEC4;
-  aParams[1] = THE_COLOR_BLACK_VEC4;
-  aParams[2] = aDiffuse;
-  aParams[3] = THE_COLOR_BLACK_VEC4;
-  aParams[4].x() = 0.0f; // shininess
-  aParams[4].y() = 0.0f; // transparency
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
-                          5, aParams);
-}
-
-// =======================================================================
-// function : PushAspectMarker
-// purpose  :
-// =======================================================================
-static void PushAspectMarker (const Handle(OpenGl_Context)&       theCtx,
-                              const Handle(OpenGl_ShaderProgram)& theProgram,
-                              const OpenGl_AspectMarker*          theAspect)
-{
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
-
-  const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
-                              theAspect->Color().rgb[1],
-                              theAspect->Color().rgb[2],
-                              theAspect->Color().rgb[3]);
-  OpenGl_Vec4 aParams[5];
-  aParams[0] = THE_COLOR_BLACK_VEC4;
-  aParams[1] = THE_COLOR_BLACK_VEC4;
-  aParams[2] = aDiffuse;
-  aParams[3] = THE_COLOR_BLACK_VEC4;
-  aParams[4].x() = 0.0f; // shininess
-  aParams[4].y() = 0.0f; // transparency
-  theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
-                          5, aParams);
-}
-
-} // nameless namespace
-
-// =======================================================================
-// function : PushMaterialState
-// purpose  : Pushes current state of OCCT material to the program
-// =======================================================================
-void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
-{
-  if (!myMaterialStates.IsBound (theProgram))
-  {
-    return;
-  }
-
-  const OpenGl_MaterialState& aState = myMaterialStates.Find (theProgram);
-  if (aState.Index() == theProgram->ActiveState (OpenGl_MATERIALS_STATE))
-  {
-    return;
-  }
-
-  const OpenGl_Element* anAspect = aState.Aspect();
-  if (typeid (*anAspect) == typeid (OpenGl_AspectFace))
-  {
-    PushAspectFace   (myContext, theProgram, dynamic_cast<const OpenGl_AspectFace*> (anAspect));
-  }
-  else if (typeid (*anAspect) == typeid (OpenGl_AspectLine))
-  {
-    PushAspectLine   (myContext, theProgram, dynamic_cast<const OpenGl_AspectLine*> (anAspect));
-  }
-  else if (typeid (*anAspect) == typeid (OpenGl_AspectText))
-  {
-    PushAspectText   (myContext, theProgram, dynamic_cast<const OpenGl_AspectText*> (anAspect));
-  }
-  else if (typeid (*anAspect) == typeid (OpenGl_AspectMarker))
-  {
-    PushAspectMarker (myContext, theProgram, dynamic_cast<const OpenGl_AspectMarker*> (anAspect));
-  }
-
-  theProgram->UpdateState (OpenGl_MATERIALS_STATE, aState.Index());
-}
-
-// =======================================================================
 // function : PushState
 // purpose  : Pushes state of OCCT graphics parameters to the program
 // =======================================================================
 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 {
   PushClippingState    (theProgram);
-  PushMaterialState    (theProgram);
   PushWorldViewState   (theProgram);
   PushModelWorldState  (theProgram);
   PushProjectionState  (theProgram);
@@ -1160,6 +941,37 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
 }
 
 // =======================================================================
+// function : pointSpriteAlphaSrc
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc()
+{
+  TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, gl_PointCoord).a; }";
+#if !defined(GL_ES_VERSION_2_0)
+  if (myContext->core11 == NULL)
+  {
+    aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, gl_PointCoord).r; }";
+  }
+#endif
+
+  return aSrcGetAlpha;
+}
+
+namespace
+{
+
+  // =======================================================================
+  // function : textureUsed
+  // purpose  :
+  // =======================================================================
+  static bool textureUsed (const Standard_Integer theBits)
+  {
+    return (theBits & OpenGl_PO_TextureA) != 0 || (theBits & OpenGl_PO_TextureRGB) != 0;
+  }
+
+}
+
+// =======================================================================
 // function : prepareStdProgramFlat
 // purpose  :
 // =======================================================================
@@ -1167,7 +979,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
                                                               const Standard_Integer        theBits)
 {
   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
-  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+  TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
   TCollection_AsciiString aSrcFragGetColor     = EOL"vec4 getColor(void) { return occColor; }";
   TCollection_AsciiString aSrcFragMainGetColor = EOL"  occFragColor = getColor();";
   if ((theBits & OpenGl_PO_Point) != 0)
@@ -1175,50 +987,31 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
   #if defined(GL_ES_VERSION_2_0)
     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
   #endif
-    if ((theBits & OpenGl_PO_TextureA) != 0)
-    {
-      TCollection_AsciiString
-        aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, gl_PointCoord).a; }";
-    #if !defined(GL_ES_VERSION_2_0)
-      if (myContext->core11 == NULL)
-      {
-        aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, gl_PointCoord).r; }";
-      }
-      else if (myContext->IsGlGreaterEqual (2, 1))
-      {
-        aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
-      }
-    #endif
-
-      aSrcFragGetColor = aSrcGetAlpha
-      + EOL"vec4  getColor(void)"
-        EOL"{"
-        EOL"  vec4 aColor = occColor;"
-        EOL"  aColor.a *= getAlpha();"
-        EOL"  return aColor;"
-        EOL"}";
 
-      aSrcFragMainGetColor =
-        EOL"  vec4 aColor = getColor();"
-        EOL"  if (aColor.a <= 0.1) discard;"
-        EOL"  occFragColor = aColor;";
+    if (textureUsed (theBits))
+    {
+      aSrcGetAlpha = pointSpriteAlphaSrc();
+
+      #if !defined(GL_ES_VERSION_2_0)
+        if (myContext->core11 != NULL
+         && myContext->IsGlGreaterEqual (2, 1))
+        {
+          aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
+        }
+      #endif
     }
-    else if ((theBits & OpenGl_PO_TextureRGB) != 0)
+
+    if ((theBits & OpenGl_PO_TextureRGB) != 0)
     {
       aSrcFragGetColor =
         EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, gl_PointCoord); }";
-      aSrcFragMainGetColor =
-        EOL"  vec4 aColor = getColor();"
-        EOL"  if (aColor.a <= 0.1) discard;"
-        EOL"  occFragColor = aColor;";
-    #if !defined(GL_ES_VERSION_2_0)
-      if (myContext->core11 != NULL
-       && myContext->IsGlGreaterEqual (2, 1))
-      {
-        aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
-      }
-    #endif
     }
+
+    aSrcFragMainGetColor =
+      EOL"  vec4 aColor = getColor();"
+      EOL"  aColor.a = getAlpha();"
+      EOL"  if (aColor.a <= 0.1) discard;"
+      EOL"  occFragColor = aColor;";
   }
   else
   {
@@ -1334,6 +1127,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
   aSrcFrag =
       aSrcFragExtraOut
     + aSrcFragGetColor
+    + aSrcGetAlpha
     + EOL"void main()"
       EOL"{"
     + aSrcFragExtraMain
@@ -1359,6 +1153,40 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
 }
 
 // =======================================================================
+// function : pointSpriteShadingSrc
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString theBaseColorSrc,
+                                                                     const Standard_Integer theBits)
+{
+  TCollection_AsciiString aSrcFragGetColor;
+  if ((theBits & OpenGl_PO_TextureA) != 0)
+  {
+    aSrcFragGetColor = pointSpriteAlphaSrc() +
+      EOL"vec4 getColor(void)"
+      EOL"{"
+      EOL"  vec4 aColor = " + theBaseColorSrc + ";"
+      EOL"  aColor.a = getAlpha();"
+      EOL"  if (aColor.a <= 0.1) discard;"
+      EOL"  return aColor;"
+      EOL"}";
+  }
+  else if ((theBits & OpenGl_PO_TextureRGB) != 0)
+  {
+    aSrcFragGetColor = TCollection_AsciiString() +
+      EOL"vec4 getColor(void)"
+      EOL"{"
+      EOL"  vec4 aColor = " + theBaseColorSrc + ";"
+      EOL"  aColor = occTexture2D(occActiveSampler, gl_PointCoord) * aColor;"
+      EOL"  if (aColor.a <= 0.1) discard;"
+      EOL"  return aColor;"
+      EOL"}";
+  }
+
+  return aSrcFragGetColor;
+}
+
+// =======================================================================
 // function : stdComputeLighting
 // purpose  :
 // =======================================================================
@@ -1462,28 +1290,18 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
   #if defined(GL_ES_VERSION_2_0)
     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
   #endif
-  }
-  if ((theBits & OpenGl_PO_VertColor) != 0)
-  {
-    aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
-  }
-  if ((theBits & OpenGl_PO_Point) != 0)
-  {
-    if ((theBits & OpenGl_PO_TextureRGB) != 0)
+
+    if (textureUsed (theBits))
     {
-      aSrcFragGetColor =
-        EOL"vec4 getColor(void)"
-        EOL"{"
-        EOL"  vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
-        EOL"  return occTexture2D(occActiveSampler, gl_PointCoord) * aColor;"
-        EOL"}";
-    #if !defined(GL_ES_VERSION_2_0)
-      if (myContext->core11 != NULL
-       && myContext->IsGlGreaterEqual (2, 1))
-      {
-        aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
-      }
-    #endif
+      #if !defined(GL_ES_VERSION_2_0)
+        if (myContext->core11 != NULL
+         && myContext->IsGlGreaterEqual (2, 1))
+        {
+          aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
+        }
+      #endif
+
+      aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
     }
   }
   else
@@ -1502,6 +1320,12 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
         EOL"}";
     }
   }
+
+  if ((theBits & OpenGl_PO_VertColor) != 0)
+  {
+    aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
+  }
+
   if ((theBits & OpenGl_PO_ClipPlanes) != 0)
   {
     aSrcVertExtraOut +=
@@ -1584,32 +1408,18 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
   #if defined(GL_ES_VERSION_2_0)
     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
   #endif
-  }
-  if ((theBits & OpenGl_PO_VertColor) != 0)
-  {
-    aSrcVertExtraOut    += EOL"THE_SHADER_OUT vec4 VertColor;";
-    aSrcVertExtraMain   += EOL"  VertColor = occVertColor;";
-    aSrcFragGetVertColor = EOL"THE_SHADER_IN  vec4 VertColor;"
-                           EOL"vec4 getVertColor(void) { return VertColor; }";
-  }
 
-  if ((theBits & OpenGl_PO_Point) != 0)
-  {
-    if ((theBits & OpenGl_PO_TextureRGB) != 0)
+    if (textureUsed (theBits))
     {
-      aSrcFragGetColor =
-        EOL"vec4 getColor(void)"
-        EOL"{"
-        EOL"  vec4 aColor = " thePhongCompLight ";"
-        EOL"  return occTexture2D(occActiveSampler, gl_PointCoord) * aColor;"
-        EOL"}";
-    #if !defined(GL_ES_VERSION_2_0)
-      if (myContext->core11 != NULL
-       && myContext->IsGlGreaterEqual (2, 1))
-      {
-        aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
-      }
-    #endif
+      #if !defined(GL_ES_VERSION_2_0)
+        if (myContext->core11 != NULL
+         && myContext->IsGlGreaterEqual (2, 1))
+        {
+          aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
+        }
+      #endif
+
+      aSrcFragGetColor = pointSpriteShadingSrc (thePhongCompLight, theBits);
     }
   }
   else
@@ -1629,6 +1439,14 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
     }
   }
 
+  if ((theBits & OpenGl_PO_VertColor) != 0)
+  {
+    aSrcVertExtraOut    += EOL"THE_SHADER_OUT vec4 VertColor;";
+    aSrcVertExtraMain   += EOL"  VertColor = occVertColor;";
+    aSrcFragGetVertColor = EOL"THE_SHADER_IN  vec4 VertColor;"
+                           EOL"vec4 getVertColor(void) { return VertColor; }";
+  }
+
   if ((theBits & OpenGl_PO_ClipPlanes) != 0)
   {
     aSrcFragExtraMain += THE_FRAG_CLIP_PLANES;
@@ -1914,8 +1732,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_Sh
 // function : bindProgramWithState
 // purpose  :
 // =======================================================================
-Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram,
-                                                             const OpenGl_Element*               theAspect)
+Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
 {
   if (!myContext->BindProgram (theProgram))
   {
@@ -1923,12 +1740,6 @@ Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl
   }
   theProgram->ApplyVariables (myContext);
 
-  const OpenGl_MaterialState* aMaterialState = MaterialState (theProgram);
-  if (aMaterialState == NULL || aMaterialState->Aspect() != theAspect)
-  {
-    UpdateMaterialStateTo (theProgram, theAspect);
-  }
-
   PushState (theProgram);
   return Standard_True;
 }
index e15aad5..8f6cad7 100644 (file)
@@ -37,9 +37,6 @@ class OpenGl_View;
 //! List of shader programs.
 typedef NCollection_Sequence<Handle(OpenGl_ShaderProgram)> OpenGl_ShaderProgramList;
 
-//! Map to declare per-program states of OCCT materials.
-typedef NCollection_DataMap<Handle(OpenGl_ShaderProgram), OpenGl_MaterialState> OpenGl_MaterialStates;
-
 class OpenGl_ShaderManager;
 DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient)
 
@@ -79,80 +76,78 @@ public:
   Standard_EXPORT Standard_Boolean IsEmpty() const;
 
   //! Bind program for filled primitives rendering
-  Standard_Boolean BindProgram (const OpenGl_AspectFace*            theAspect,
-                                const Handle(OpenGl_Texture)&       theTexture,
-                                const Standard_Boolean              theToLightOn,
-                                const Standard_Boolean              theHasVertColor,
-                                const Standard_Boolean              theEnableEnvMap,
-                                const Handle(OpenGl_ShaderProgram)& theCustomProgram)
+  Standard_Boolean BindFaceProgram (const Handle(OpenGl_Texture)&       theTexture,
+                                    const Standard_Boolean              theToLightOn,
+                                    const Standard_Boolean              theHasVertColor,
+                                    const Standard_Boolean              theEnableEnvMap,
+                                    const Handle(OpenGl_ShaderProgram)& theCustomProgram)
   {
     if (!theCustomProgram.IsNull()
      || myContext->caps->ffpEnable)
     {
-      return bindProgramWithState (theCustomProgram, theAspect);
+      return bindProgramWithState (theCustomProgram);
     }
 
     const Standard_Integer        aBits    = getProgramBits (theTexture, theHasVertColor, theEnableEnvMap);
     Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
-    return bindProgramWithState (aProgram, theAspect);
+    return bindProgramWithState (aProgram);
   }
 
   //! Bind program for line rendering
-  Standard_Boolean BindProgram (const OpenGl_AspectLine*            theAspect,
-                                const Handle(OpenGl_Texture)&       theTexture,
-                                const Standard_Boolean              theToLightOn,
-                                const Standard_Boolean              theHasVertColor,
-                                const Handle(OpenGl_ShaderProgram)& theCustomProgram)
+  Standard_Boolean BindLineProgram (const Handle(OpenGl_Texture)&       theTexture,
+                                    const Standard_Boolean              theStipple,
+                                    const Standard_Boolean              theToLightOn,
+                                    const Standard_Boolean              theHasVertColor,
+                                    const Handle(OpenGl_ShaderProgram)& theCustomProgram)
   {
     if (!theCustomProgram.IsNull()
      || myContext->caps->ffpEnable)
     {
-      return bindProgramWithState (theCustomProgram, theAspect);
+      return bindProgramWithState (theCustomProgram);
     }
 
     Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor);
-    if (theAspect->Type() != Aspect_TOL_SOLID)
+    if (theStipple)
     {
       aBits |= OpenGl_PO_StippleLine;
     }
 
     Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
-    return bindProgramWithState (aProgram, theAspect);
+    return bindProgramWithState (aProgram);
   }
 
   //! Bind program for point rendering
-  Standard_Boolean BindProgram (const OpenGl_AspectMarker*          theAspect,
-                                const Handle(OpenGl_Texture)&       theTexture,
-                                const Standard_Boolean              theToLightOn,
-                                const Standard_Boolean              theHasVertColor,
-                                const Handle(OpenGl_ShaderProgram)& theCustomProgram)
+  Standard_Boolean BindMarkerProgram (const Handle(OpenGl_Texture)&       theTexture,
+                                      const Standard_Boolean              theToLightOn,
+                                      const Standard_Boolean              theHasVertColor,
+                                      const Handle(OpenGl_ShaderProgram)& theCustomProgram)
   {
     if (!theCustomProgram.IsNull()
      || myContext->caps->ffpEnable)
     {
-      return bindProgramWithState (theCustomProgram, theAspect);
+      return bindProgramWithState (theCustomProgram);
     }
 
     const Standard_Integer        aBits    = getProgramBits (theTexture, theHasVertColor) | OpenGl_PO_Point;
     Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
-    return bindProgramWithState (aProgram, theAspect);
+    return bindProgramWithState (aProgram);
   }
 
   //! Bind program for rendering alpha-textured font.
-  Standard_Boolean BindProgram (const OpenGl_AspectText*            theAspect,
-                                const Handle(OpenGl_ShaderProgram)& theCustomProgram)
+  Standard_Boolean BindFontProgram (const Handle(OpenGl_ShaderProgram)& theCustomProgram)
   {
     if (!theCustomProgram.IsNull()
      || myContext->caps->ffpEnable)
     {
-      return bindProgramWithState (theCustomProgram, theAspect);
+      return bindProgramWithState (theCustomProgram);
     }
 
     if (myFontProgram.IsNull())
     {
       prepareStdProgramFont();
     }
-    return bindProgramWithState (myFontProgram, theAspect);
+
+    return bindProgramWithState (myFontProgram);
   }
 
   //! Bind program for FBO blit operation.
@@ -240,21 +235,6 @@ public:
 
 public:
 
-  //! Resets state of OCCT material for all programs.
-  Standard_EXPORT void ResetMaterialStates();
-
-  //! Updates state of OCCT material for specified program.
-  Standard_EXPORT void UpdateMaterialStateTo (const Handle(OpenGl_ShaderProgram)& theProgram,
-                                              const OpenGl_Element*               theAspect);
-
-  //! Pushes current state of OCCT material to specified program.
-  Standard_EXPORT void PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
-
-  //! Returns current state of OCCT material for specified program.
-  Standard_EXPORT const OpenGl_MaterialState* MaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
-
-public:
-
   //! Pushes current state of OCCT graphics parameters to specified program.
   Standard_EXPORT void PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 
@@ -341,6 +321,12 @@ protected:
     return aProgram;
   }
 
+  //! Prepare standard GLSL program for accessing point sprite alpha.
+  Standard_EXPORT TCollection_AsciiString pointSpriteAlphaSrc();
+
+  //! Prepare standard GLSL program for computing point sprite shading.
+  Standard_EXPORT TCollection_AsciiString pointSpriteShadingSrc (const TCollection_AsciiString theBaseColorSrc, const Standard_Integer theBits);
+
   //! Prepare standard GLSL program for textured font.
   Standard_EXPORT Standard_Boolean prepareStdProgramFont();
 
@@ -373,8 +359,7 @@ protected:
   Standard_EXPORT TCollection_AsciiString stdComputeLighting (const Standard_Boolean theHasVertColor);
 
   //! Bind specified program to current context and apply state.
-  Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram,
-                                                         const OpenGl_Element*               theAspect);
+  Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram);
 
   //! Set pointer myLightPrograms to active lighting programs set from myMapOfLightPrograms
   Standard_EXPORT void switchLightPrograms();
@@ -399,7 +384,6 @@ protected:
 
 protected:
 
-  OpenGl_MaterialStates              myMaterialStates;     //!< Per-program state of OCCT material
   OpenGl_ProjectionState             myProjectionState;    //!< State of OCCT projection  transformation
   OpenGl_ModelWorldState             myModelWorldState;    //!< State of OCCT model-world transformation
   OpenGl_WorldViewState              myWorldViewState;     //!< State of OCCT world-view  transformation
@@ -413,7 +397,6 @@ private:
 public:
 
   DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
-
 };
 
 #endif // _OpenGl_ShaderManager_HeaderFile
index 7392d07..a3c0a46 100755 (executable)
@@ -341,6 +341,19 @@ Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&
     }
   }
 
+  // set uniform defaults
+  const GLint aLocSampler   = GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER);
+  const GLint aLocTexEnable = GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE);
+  if (aLocSampler   != INVALID_LOCATION
+   || aLocTexEnable != INVALID_LOCATION)
+  {
+    const Handle(OpenGl_ShaderProgram)& anOldProgram = theCtx->ActiveProgram();
+    theCtx->core20fwd->glUseProgram (myProgramID);
+    SetUniform (theCtx, aLocSampler,   0); // GL_TEXTURE0
+    SetUniform (theCtx, aLocTexEnable, 0); // Off
+    theCtx->core20fwd->glUseProgram (!anOldProgram.IsNull() ? anOldProgram->ProgramId() : OpenGl_ShaderProgram::NO_PROGRAM);
+  }
+
   return Standard_True;
 }
 
index 74552a1..1d9de64 100644 (file)
@@ -418,8 +418,7 @@ void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
   // Bind custom shader program or generate default version
   if (aCtx->core20fwd != NULL)
   {
-    aCtx->ShaderManager()->BindProgram (
-      aTextAspect, aTextAspect->ShaderProgramRes (aCtx));
+    aCtx->ShaderManager()->BindFontProgram (aTextAspect->ShaderProgramRes (aCtx));
   }
 
   myOrientationMatrix = theWorkspace->View()->Camera()->OrientationMatrix();
@@ -899,7 +898,7 @@ void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
     #if !defined(GL_ES_VERSION_2_0)
       if (theCtx->core11 != NULL)
       {
-        theCtx->core11->glColor3fv (theColorSubs.rgb);
+        theCtx->SetColor4fv (*(const OpenGl_Vec4* )theColorSubs.rgb);
         setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.00001f));
 
         glBindTexture (GL_TEXTURE_2D, 0);
index 64852d1..2a0e2d3 100644 (file)
@@ -952,7 +952,6 @@ void OpenGl_View::render (Graphic3d_Camera::Projection theProjection,
 
   if (!aManager->IsEmpty())
   {
-    aManager->ResetMaterialStates();
     aManager->RevertClippingState();
 
     // We need to disable (unbind) all shaders programs to ensure