OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +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_Sampler.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_AspectFace.hxx>
#include <Graphic3d_TransformUtils.hxx>
#include <Message_Messenger.hxx>
@ -2508,6 +2510,43 @@ Handle(OpenGl_FrameBuffer) OpenGl_Context::SetDefaultFrameBuffer (const Handle(O
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
// 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_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);

25
src/OpenGl/OpenGl_PrimitiveArray.cxx
View 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
{

431
src/OpenGl/OpenGl_ShaderManager.cxx
View File

@ -338,7 +338,6 @@ void OpenGl_ShaderManager::Unregister (TCollection_AsciiString& theShareKey
}
myProgramList.Remove (anIt);
myMaterialStates.UnBind (theProgram);
break;
}
}
@ -809,223 +808,6 @@ void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)
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
// 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
{
PushClippingState (theProgram);
PushMaterialState (theProgram);
PushWorldViewState (theProgram);
PushModelWorldState (theProgram);
PushProjectionState (theProgram);
@ -1159,6 +940,37 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
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
// 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)
if (textureUsed (theBits))
{
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
aSrcGetAlpha = pointSpriteAlphaSrc();
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 !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
@ -1358,6 +1152,40 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
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
// 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;
}

81
src/OpenGl/OpenGl_ShaderManager.hxx
View 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.
@ -238,21 +233,6 @@ public:
//! Pushes current state of OCCT clipping planes to specified program.
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:
//! Pushes current state of OCCT graphics parameters to specified program.
@ -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

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;
}

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
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);

1
src/OpenGl/OpenGl_View_Redraw.cxx
View 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