OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0026809: Visualization, TKOpenGl - handle point arrays with per-vertex color within built-in GLSL programs

Browse Source 
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().
This commit is contained in:
duv 2016-04-17 12:43:08 +03:00 committed by bugmaster
parent b8f67cc236
commit 299e0ab98f
8 changed files with 226 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/OpenGl/OpenGl_Context.cxx
View File

@ -29,6 +29,8 @@
#include <OpenGl_FrameBuffer.hxx> #include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_Sampler.hxx> #include <OpenGl_Sampler.hxx>
#include <OpenGl_ShaderManager.hxx> #include <OpenGl_ShaderManager.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_AspectFace.hxx>
#include <Graphic3d_TransformUtils.hxx> #include <Graphic3d_TransformUtils.hxx>
#include <Message_Messenger.hxx> #include <Message_Messenger.hxx>
@ -2508,6 +2510,43 @@ Handle(OpenGl_FrameBuffer) OpenGl_Context::SetDefaultFrameBuffer (const Handle(O
return aFbo; return aFbo;
} }
// =======================================================================
// 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 // function : SetColor4fv
// purpose : // purpose :

4
src/OpenGl/OpenGl_Context.hxx
View File

@ -128,6 +128,7 @@ typedef OpenGl_TmplCore44<OpenGl_GlCore43> OpenGl_GlCore44;
class OpenGl_ShaderManager; class OpenGl_ShaderManager;
class OpenGl_Sampler; class OpenGl_Sampler;
class OpenGl_FrameBuffer; class OpenGl_FrameBuffer;
class OpenGl_AspectFace;
class OpenGl_Context; class OpenGl_Context;
DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient) 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 //! @return true if some program is bound to context
Standard_EXPORT Standard_Boolean BindProgram (const Handle(OpenGl_ShaderProgram)& theProgram); 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. //! Setup current color.
Standard_EXPORT void SetColor4fv (const OpenGl_Vec4& theColor); Standard_EXPORT void SetColor4fv (const OpenGl_Vec4& theColor);

17
src/OpenGl/OpenGl_PrimitiveArray.cxx
View File

@ -467,7 +467,7 @@ void OpenGl_PrimitiveArray::drawEdges (const TEL_COLOUR* theEdgeCo
if (aGlContext->core20fwd != NULL) 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: /// OCC22236 NOTE: draw edges for all situations:
@ -771,18 +771,18 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
? anAspectMarker->SpriteHighlightRes (aCtx) ? anAspectMarker->SpriteHighlightRes (aCtx)
: aSpriteNorm; : aSpriteNorm;
theWorkspace->EnableTexture (aSprite); theWorkspace->EnableTexture (aSprite);
aCtx->ShaderManager()->BindProgram (anAspectMarker, aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx)); aCtx->ShaderManager()->BindMarkerProgram (aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
} }
else else
{ {
aCtx->ShaderManager()->BindProgram (anAspectMarker, NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx)); aCtx->ShaderManager()->BindMarkerProgram (NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
} }
break; break;
} }
case GL_LINES: case GL_LINES:
case GL_LINE_STRIP: 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; break;
} }
default: default:
@ -792,8 +792,7 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
&& (aTexture.IsNull() && (aTexture.IsNull()
|| aTexture->GetParams()->IsModulate()); || aTexture->GetParams()->IsModulate());
const Standard_Boolean toEnableEnvMap = (!aTexture.IsNull() && (aTexture == theWorkspace->EnvironmentTexture())); const Standard_Boolean toEnableEnvMap = (!aTexture.IsNull() && (aTexture == theWorkspace->EnvironmentTexture()));
aCtx->ShaderManager()->BindProgram (anAspectFace, aCtx->ShaderManager()->BindFaceProgram (aTexture,
aTexture,
isLightOnFace, isLightOnFace,
hasVertColor, hasVertColor,
toEnableEnvMap, toEnableEnvMap,
@ -803,6 +802,12 @@ void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace
} }
} }
// All primitives should gather material properties from the AspectFace in shading mode
if (isLightOn)
{
aCtx->SetShadingMaterial (anAspectFace);
}
if (!theWorkspace->ActiveTexture().IsNull() if (!theWorkspace->ActiveTexture().IsNull()
&& myDrawMode != GL_POINTS) // transformation is not supported within point sprites && myDrawMode != GL_POINTS) // transformation is not supported within point sprites
{ {

397
src/OpenGl/OpenGl_ShaderManager.cxx
View File

@ -338,7 +338,6 @@ void OpenGl_ShaderManager::Unregister (TCollection_AsciiString& theShareKey
} }
myProgramList.Remove (anIt); myProgramList.Remove (anIt);
myMaterialStates.UnBind (theProgram);
break; break;
} }
} }
@ -809,223 +808,6 @@ void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)
delete[] aSpaces; delete[] aSpaces;
} }
// =======================================================================
// 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 // function : PushState
// purpose : Pushes state of OCCT graphics parameters to the program // purpose : Pushes state of OCCT graphics parameters to the program
@ -1033,7 +815,6 @@ void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)
void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
{ {
PushClippingState (theProgram); PushClippingState (theProgram);
PushMaterialState (theProgram);
PushWorldViewState (theProgram); PushWorldViewState (theProgram);
PushModelWorldState (theProgram); PushModelWorldState (theProgram);
PushProjectionState (theProgram); PushProjectionState (theProgram);
@ -1159,6 +940,37 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
return Standard_True; return Standard_True;
} }
// =======================================================================
// 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 // function : prepareStdProgramFlat
// purpose : // purpose :
@ -1167,7 +979,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
const Standard_Integer theBits) const Standard_Integer theBits)
{ {
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram(); 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 aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
TCollection_AsciiString aSrcFragMainGetColor = EOL" occFragColor = getColor();"; TCollection_AsciiString aSrcFragMainGetColor = EOL" occFragColor = getColor();";
if ((theBits & OpenGl_PO_Point) != 0) if ((theBits & OpenGl_PO_Point) != 0)
@ -1175,42 +987,11 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
#if defined(GL_ES_VERSION_2_0) #if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;"; aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif #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 if (textureUsed (theBits))
+ 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;";
}
else if ((theBits & OpenGl_PO_TextureRGB) != 0)
{ {
aSrcFragGetColor = aSrcGetAlpha = pointSpriteAlphaSrc();
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 !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL if (myContext->core11 != NULL
&& myContext->IsGlGreaterEqual (2, 1)) && myContext->IsGlGreaterEqual (2, 1))
@ -1219,6 +1000,18 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
} }
#endif #endif
} }
if ((theBits & OpenGl_PO_TextureRGB) != 0)
{
aSrcFragGetColor =
EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, gl_PointCoord); }";
}
aSrcFragMainGetColor =
EOL" vec4 aColor = getColor();"
EOL" aColor.a = getAlpha();"
EOL" if (aColor.a <= 0.1) discard;"
EOL" occFragColor = aColor;";
} }
else else
{ {
@ -1334,6 +1127,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
aSrcFrag = aSrcFrag =
aSrcFragExtraOut aSrcFragExtraOut
+ aSrcFragGetColor + aSrcFragGetColor
+ aSrcGetAlpha
+ EOL"void main()" + EOL"void main()"
EOL"{" EOL"{"
+ aSrcFragExtraMain + aSrcFragExtraMain
@ -1358,6 +1152,40 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
return Standard_True; return Standard_True;
} }
// =======================================================================
// 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 // function : stdComputeLighting
// purpose : // purpose :
@ -1462,21 +1290,9 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
#if defined(GL_ES_VERSION_2_0) #if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;"; aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif #endif
}
if ((theBits & OpenGl_PO_VertColor) != 0) if (textureUsed (theBits))
{ {
aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
}
if ((theBits & OpenGl_PO_Point) != 0)
{
if ((theBits & OpenGl_PO_TextureRGB) != 0)
{
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 !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL if (myContext->core11 != NULL
&& myContext->IsGlGreaterEqual (2, 1)) && myContext->IsGlGreaterEqual (2, 1))
@ -1484,6 +1300,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
} }
#endif #endif
aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
} }
} }
else else
@ -1502,6 +1320,12 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S
EOL"}"; EOL"}";
} }
} }
if ((theBits & OpenGl_PO_VertColor) != 0)
{
aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
}
if ((theBits & OpenGl_PO_ClipPlanes) != 0) if ((theBits & OpenGl_PO_ClipPlanes) != 0)
{ {
aSrcVertExtraOut += aSrcVertExtraOut +=
@ -1584,25 +1408,9 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
#if defined(GL_ES_VERSION_2_0) #if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;"; aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif #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 (textureUsed (theBits))
{ {
if ((theBits & OpenGl_PO_TextureRGB) != 0)
{
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 !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL if (myContext->core11 != NULL
&& myContext->IsGlGreaterEqual (2, 1)) && myContext->IsGlGreaterEqual (2, 1))
@ -1610,6 +1418,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha
aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
} }
#endif #endif
aSrcFragGetColor = pointSpriteShadingSrc (thePhongCompLight, theBits);
} }
} }
else 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) if ((theBits & OpenGl_PO_ClipPlanes) != 0)
{ {
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES; aSrcFragExtraMain += THE_FRAG_CLIP_PLANES;
@ -1914,8 +1732,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_Sh
// function : bindProgramWithState // function : bindProgramWithState
// purpose : // purpose :
// ======================================================================= // =======================================================================
Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram, Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
const OpenGl_Element* theAspect)
{ {
if (!myContext->BindProgram (theProgram)) if (!myContext->BindProgram (theProgram))
{ {
@ -1923,12 +1740,6 @@ Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl
} }
theProgram->ApplyVariables (myContext); theProgram->ApplyVariables (myContext);
const OpenGl_MaterialState* aMaterialState = MaterialState (theProgram);
if (aMaterialState == NULL || aMaterialState->Aspect() != theAspect)
{
UpdateMaterialStateTo (theProgram, theAspect);
}
PushState (theProgram); PushState (theProgram);
return Standard_True; return Standard_True;
} }

61
src/OpenGl/OpenGl_ShaderManager.hxx
View File

@ -37,9 +37,6 @@ class OpenGl_View;
//! List of shader programs. //! List of shader programs.
typedef NCollection_Sequence<Handle(OpenGl_ShaderProgram)> OpenGl_ShaderProgramList; 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; class OpenGl_ShaderManager;
DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient) DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient)
@ -79,8 +76,7 @@ public:
Standard_EXPORT Standard_Boolean IsEmpty() const; Standard_EXPORT Standard_Boolean IsEmpty() const;
//! Bind program for filled primitives rendering //! Bind program for filled primitives rendering
Standard_Boolean BindProgram (const OpenGl_AspectFace* theAspect, Standard_Boolean BindFaceProgram (const Handle(OpenGl_Texture)& theTexture,
const Handle(OpenGl_Texture)& theTexture,
const Standard_Boolean theToLightOn, const Standard_Boolean theToLightOn,
const Standard_Boolean theHasVertColor, const Standard_Boolean theHasVertColor,
const Standard_Boolean theEnableEnvMap, const Standard_Boolean theEnableEnvMap,
@ -89,17 +85,17 @@ public:
if (!theCustomProgram.IsNull() if (!theCustomProgram.IsNull()
|| myContext->caps->ffpEnable) || myContext->caps->ffpEnable)
{ {
return bindProgramWithState (theCustomProgram, theAspect); return bindProgramWithState (theCustomProgram);
} }
const Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor, theEnableEnvMap); const Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor, theEnableEnvMap);
Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits); Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
return bindProgramWithState (aProgram, theAspect); return bindProgramWithState (aProgram);
} }
//! Bind program for line rendering //! Bind program for line rendering
Standard_Boolean BindProgram (const OpenGl_AspectLine* theAspect, Standard_Boolean BindLineProgram (const Handle(OpenGl_Texture)& theTexture,
const Handle(OpenGl_Texture)& theTexture, const Standard_Boolean theStipple,
const Standard_Boolean theToLightOn, const Standard_Boolean theToLightOn,
const Standard_Boolean theHasVertColor, const Standard_Boolean theHasVertColor,
const Handle(OpenGl_ShaderProgram)& theCustomProgram) const Handle(OpenGl_ShaderProgram)& theCustomProgram)
@ -107,22 +103,21 @@ public:
if (!theCustomProgram.IsNull() if (!theCustomProgram.IsNull()
|| myContext->caps->ffpEnable) || myContext->caps->ffpEnable)
{ {
return bindProgramWithState (theCustomProgram, theAspect); return bindProgramWithState (theCustomProgram);
} }
Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor); Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor);
if (theAspect->Type() != Aspect_TOL_SOLID) if (theStipple)
{ {
aBits |= OpenGl_PO_StippleLine; aBits |= OpenGl_PO_StippleLine;
} }
Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits); Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
return bindProgramWithState (aProgram, theAspect); return bindProgramWithState (aProgram);
} }
//! Bind program for point rendering //! Bind program for point rendering
Standard_Boolean BindProgram (const OpenGl_AspectMarker* theAspect, Standard_Boolean BindMarkerProgram (const Handle(OpenGl_Texture)& theTexture,
const Handle(OpenGl_Texture)& theTexture,
const Standard_Boolean theToLightOn, const Standard_Boolean theToLightOn,
const Standard_Boolean theHasVertColor, const Standard_Boolean theHasVertColor,
const Handle(OpenGl_ShaderProgram)& theCustomProgram) const Handle(OpenGl_ShaderProgram)& theCustomProgram)
@ -130,29 +125,29 @@ public:
if (!theCustomProgram.IsNull() if (!theCustomProgram.IsNull()
|| myContext->caps->ffpEnable) || myContext->caps->ffpEnable)
{ {
return bindProgramWithState (theCustomProgram, theAspect); return bindProgramWithState (theCustomProgram);
} }
const Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor) | OpenGl_PO_Point; const Standard_Integer aBits = getProgramBits (theTexture, theHasVertColor) | OpenGl_PO_Point;
Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits); Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theToLightOn, aBits);
return bindProgramWithState (aProgram, theAspect); return bindProgramWithState (aProgram);
} }
//! Bind program for rendering alpha-textured font. //! Bind program for rendering alpha-textured font.
Standard_Boolean BindProgram (const OpenGl_AspectText* theAspect, Standard_Boolean BindFontProgram (const Handle(OpenGl_ShaderProgram)& theCustomProgram)
const Handle(OpenGl_ShaderProgram)& theCustomProgram)
{ {
if (!theCustomProgram.IsNull() if (!theCustomProgram.IsNull()
|| myContext->caps->ffpEnable) || myContext->caps->ffpEnable)
{ {
return bindProgramWithState (theCustomProgram, theAspect); return bindProgramWithState (theCustomProgram);
} }
if (myFontProgram.IsNull()) if (myFontProgram.IsNull())
{ {
prepareStdProgramFont(); prepareStdProgramFont();
} }
return bindProgramWithState (myFontProgram, theAspect);
return bindProgramWithState (myFontProgram);
} }
//! Bind program for FBO blit operation. //! Bind program for FBO blit operation.
@ -238,21 +233,6 @@ public:
//! Pushes current state of OCCT clipping planes to specified program. //! Pushes current state of OCCT clipping planes to specified program.
Standard_EXPORT void PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const; Standard_EXPORT void PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
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: public:
//! Pushes current state of OCCT graphics parameters to specified program. //! Pushes current state of OCCT graphics parameters to specified program.
@ -341,6 +321,12 @@ protected:
return aProgram; 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. //! Prepare standard GLSL program for textured font.
Standard_EXPORT Standard_Boolean prepareStdProgramFont(); Standard_EXPORT Standard_Boolean prepareStdProgramFont();
@ -373,8 +359,7 @@ protected:
Standard_EXPORT TCollection_AsciiString stdComputeLighting (const Standard_Boolean theHasVertColor); Standard_EXPORT TCollection_AsciiString stdComputeLighting (const Standard_Boolean theHasVertColor);
//! Bind specified program to current context and apply state. //! Bind specified program to current context and apply state.
Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram, Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram);
const OpenGl_Element* theAspect);
//! Set pointer myLightPrograms to active lighting programs set from myMapOfLightPrograms //! Set pointer myLightPrograms to active lighting programs set from myMapOfLightPrograms
Standard_EXPORT void switchLightPrograms(); Standard_EXPORT void switchLightPrograms();
@ -399,7 +384,6 @@ protected:
protected: protected:
OpenGl_MaterialStates myMaterialStates; //!< Per-program state of OCCT material
OpenGl_ProjectionState myProjectionState; //!< State of OCCT projection transformation OpenGl_ProjectionState myProjectionState; //!< State of OCCT projection transformation
OpenGl_ModelWorldState myModelWorldState; //!< State of OCCT model-world transformation OpenGl_ModelWorldState myModelWorldState; //!< State of OCCT model-world transformation
OpenGl_WorldViewState myWorldViewState; //!< State of OCCT world-view transformation OpenGl_WorldViewState myWorldViewState; //!< State of OCCT world-view transformation
@ -413,7 +397,6 @@ private:
public: public:
DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient) DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
}; };
#endif // _OpenGl_ShaderManager_HeaderFile #endif // _OpenGl_ShaderManager_HeaderFile

13
src/OpenGl/OpenGl_ShaderProgram.cxx
View File

@ -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; return Standard_True;
} }

5
src/OpenGl/OpenGl_Text.cxx
View File

@ -418,8 +418,7 @@ void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
// Bind custom shader program or generate default version // Bind custom shader program or generate default version
if (aCtx->core20fwd != NULL) if (aCtx->core20fwd != NULL)
{ {
aCtx->ShaderManager()->BindProgram ( aCtx->ShaderManager()->BindFontProgram (aTextAspect->ShaderProgramRes (aCtx));
aTextAspect, aTextAspect->ShaderProgramRes (aCtx));
} }
myOrientationMatrix = theWorkspace->View()->Camera()->OrientationMatrix(); 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 !defined(GL_ES_VERSION_2_0)
if (theCtx->core11 != NULL) 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)); setupMatrix (thePrintCtx, theCtx, theTextAspect, OpenGl_Vec3 (0.0f, 0.0f, 0.00001f));
glBindTexture (GL_TEXTURE_2D, 0); glBindTexture (GL_TEXTURE_2D, 0);

1
src/OpenGl/OpenGl_View_Redraw.cxx
View File

@ -952,7 +952,6 @@ void OpenGl_View::render (Graphic3d_Camera::Projection theProjection,
if (!aManager->IsEmpty()) if (!aManager->IsEmpty())
{ {
aManager->ResetMaterialStates();
aManager->RevertClippingState(); aManager->RevertClippingState();
// We need to disable (unbind) all shaders programs to ensure // We need to disable (unbind) all shaders programs to ensure