#define EOL "\n"
-//! Definition of TexCoord varying.
-const char THE_VARY_TexCoord_OUT[] =
- EOL"THE_SHADER_OUT vec4 TexCoord;";
-const char THE_VARY_TexCoord_IN[] =
- EOL"THE_SHADER_IN vec4 TexCoord;";
//! Compute TexCoord value in Vertex Shader
const char THE_VARY_TexCoord_Trsf[] =
EOL" float aRotSin = occTextureTrsf_RotationSin();"
EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
EOL" }"
EOL
- EOL"Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
- EOL"Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
+ EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
+ EOL" Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
EOL"}";
//! Function computes contribution of spotlight source
EOL" discard;"
EOL" }";
+//! Modify color for Wireframe presentation.
+const char THE_FRAG_WIREFRAME_COLOR[] =
+EOL"vec4 getFinalColor(void)"
+EOL"{"
+EOL" float aDistance = min (min (EdgeDistance[0], EdgeDistance[1]), EdgeDistance[2]);"
+EOL" bool isHollow = occWireframeColor.a < 0.0;"
+EOL" float aMixVal = smoothstep (occLineWidth - occLineFeather * 0.5, occLineWidth + occLineFeather * 0.5, aDistance);"
+EOL" vec4 aMixColor = isHollow"
+EOL" ? vec4 (getColor().rgb, 1.0 - aMixVal)" // edges only (of interior color)
+EOL" : mix (occWireframeColor, getColor(), aMixVal);" // interior + edges
+EOL" return aMixColor;"
+EOL"}";
+
+//! Compute gl_Position vertex shader output.
+const char THE_VERT_gl_Position[] =
+EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;";
+
+//! Displace gl_Position alongside vertex normal for outline rendering.
+//! This code adds silhouette only for smooth surfaces of closed primitive, and produces visual artifacts on sharp edges.
+const char THE_VERT_gl_Position_OUTLINE[] =
+EOL" float anOutlineDisp = occOrthoScale > 0.0 ? occOrthoScale : gl_Position.w;"
+EOL" vec4 anOutlinePos = occVertex + vec4 (occNormal * (occSilhouetteThickness * anOutlineDisp), 0.0);"
+EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * anOutlinePos;";
+
#if !defined(GL_ES_VERSION_2_0)
static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
}
#endif
+ //! Generate map key for light sources configuration.
+ static TCollection_AsciiString genLightKey (const Handle(Graphic3d_LightSet)& theLights)
+ {
+ if (theLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
+ {
+ return TCollection_AsciiString ("l_") + theLights->KeyEnabledLong();
+ }
+
+ const Standard_Integer aMaxLimit = roundUpMaxLightSources (theLights->NbEnabled());
+ return TCollection_AsciiString ("l_") + theLights->KeyEnabledShort() + aMaxLimit;
+ }
}
// =======================================================================
OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
: myFfpProgram (new OpenGl_ShaderProgramFFP()),
myShadingModel (Graphic3d_TOSM_VERTEX),
- myUnlitPrograms (new OpenGl_SetOfShaderPrograms()),
+ myUnlitPrograms (new OpenGl_SetOfPrograms()),
myContext (theContext),
myHasLocalOrigin (Standard_False),
myLastView (NULL)
{
myProgramList.Clear();
myLightPrograms.Nullify();
- myUnlitPrograms = new OpenGl_SetOfShaderPrograms();
+ myUnlitPrograms = new OpenGl_SetOfPrograms();
+ myOutlinePrograms.Nullify();
myMapOfLightPrograms.Clear();
myFontProgram.Nullify();
myBlitProgram.Nullify();
const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
if (aLights.IsNull())
{
- myLightPrograms = myUnlitPrograms;
+ if (!myMapOfLightPrograms.Find ("unlit", myLightPrograms))
+ {
+ myLightPrograms = new OpenGl_SetOfShaderPrograms (myUnlitPrograms);
+ myMapOfLightPrograms.Bind ("unlit", myLightPrograms);
+ }
return;
}
- TCollection_AsciiString aKey ("l_");
- if (aLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
- {
- aKey += aLights->KeyEnabledLong();
- }
- else
- {
- const Standard_Integer aMaxLimit = roundUpMaxLightSources (aLights->NbEnabled());
- aKey += aLights->KeyEnabledShort();
- aKey += aMaxLimit;
- }
-
+ const TCollection_AsciiString aKey = genLightKey (aLights);
if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
{
myLightPrograms = new OpenGl_SetOfShaderPrograms();
return;
}
+ myContext->SetSampleAlphaToCoverage (false);
if (myMaterialState.AlphaCutoff() < ShortRealLast())
{
glAlphaFunc (GL_GEQUAL, myMaterialState.AlphaCutoff());
return;
}
+ myContext->SetSampleAlphaToCoverage (myMaterialState.HasAlphaCutoff());
theProgram->SetUniform (myContext,
theProgram->GetStateLocation (OpenGl_OCCT_ALPHA_CUTOFF),
myMaterialState.AlphaCutoff());
theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
myMaterialState.ToDistinguish() ? 1 : 0);
- const GLint aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL);
- if (aLocFront != OpenGl_ShaderProgram::INVALID_LOCATION)
+ if (const OpenGl_ShaderUniformLocation aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL))
{
theProgram->SetUniform (myContext, aLocFront, OpenGl_Material::NbOfVec4(),
aFrontMat.Packed());
}
-
- const GLint aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_BACK_MATERIAL);
- if (aLocBack != OpenGl_ShaderProgram::INVALID_LOCATION)
+ if (const OpenGl_ShaderUniformLocation aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_BACK_MATERIAL))
{
theProgram->SetUniform (myContext, aLocBack, OpenGl_Material::NbOfVec4(),
aBackMat.Packed());
}
}
+// =======================================================================
+// function : PushInteriorState
+// purpose :
+// =======================================================================
+void OpenGl_ShaderManager::PushInteriorState (const Handle(OpenGl_ShaderProgram)& theProgram,
+ const Handle(Graphic3d_AspectFillArea3d)& theAspect) const
+{
+ if (theProgram.IsNull()
+ || !theProgram->IsValid())
+ {
+ return;
+ }
+
+ if (const OpenGl_ShaderUniformLocation aLocViewPort = theProgram->GetStateLocation (OpenGl_OCCT_VIEWPORT))
+ {
+ theProgram->SetUniform (myContext, aLocViewPort, OpenGl_Vec4 ((float )myContext->Viewport()[0], (float )myContext->Viewport()[1], (float )myContext->Viewport()[2], (float )myContext->Viewport()[3]));
+ }
+ if (const OpenGl_ShaderUniformLocation aLocLineWidth = theProgram->GetStateLocation (OpenGl_OCCT_LINE_WIDTH))
+ {
+ theProgram->SetUniform (myContext, aLocLineWidth, theAspect->EdgeWidth() * myContext->LineWidthScale());
+ theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCCT_LINE_FEATHER), myContext->LineFeather() * myContext->LineWidthScale());
+ }
+ if (const OpenGl_ShaderUniformLocation aLocWireframeColor = theProgram->GetStateLocation (OpenGl_OCCT_WIREFRAME_COLOR))
+ {
+ if (theAspect->InteriorStyle() == Aspect_IS_HOLLOW)
+ {
+ theProgram->SetUniform (myContext, aLocWireframeColor, OpenGl_Vec4 (-1.0f, -1.0f, -1.0f, -1.0f));
+ }
+ else
+ {
+ theProgram->SetUniform (myContext, aLocWireframeColor, theAspect->EdgeColorRGBA());
+ }
+ }
+ if (const OpenGl_ShaderUniformLocation aLocQuadModeState = theProgram->GetStateLocation (OpenGl_OCCT_QUAD_MODE_STATE))
+ {
+ theProgram->SetUniform (myContext, aLocQuadModeState, theAspect->ToSkipFirstEdge() ? 1 : 0);
+ }
+}
+
// =======================================================================
// function : PushState
// purpose : Pushes state of OCCT graphics parameters to the program
// =======================================================================
Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
{
- Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+
TCollection_AsciiString aSrcVert = TCollection_AsciiString()
- + EOL"THE_SHADER_OUT vec2 TexCoord;"
- EOL"void main()"
- EOL"{"
- EOL" TexCoord = occTexCoord.st;"
- EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + EOL"void main()"
+ EOL"{"
+ EOL" TexCoord = occTexCoord.st;"
+ + THE_VERT_gl_Position
+ + EOL"}";
TCollection_AsciiString
aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
}
#endif
- TCollection_AsciiString aSrcFrag = TCollection_AsciiString() +
- + EOL"THE_SHADER_IN vec2 TexCoord;"
- + aSrcGetAlpha
+ TCollection_AsciiString aSrcFrag =
+ aSrcGetAlpha
+ EOL"void main()"
EOL"{"
EOL" vec4 aColor = occColor;"
EOL" occSetFragColor (aColor);"
EOL"}";
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
-#endif
+ Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ defaultGlslVersion (aProgramSrc, "font", 0);
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, myFontProgram))
{
// =======================================================================
Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
{
- Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+
TCollection_AsciiString aSrcVert =
- EOL"THE_SHADER_OUT vec2 TexCoord;"
EOL"void main()"
EOL"{"
EOL" TexCoord = occVertex.zw;"
EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
EOL"}";
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uColorSampler", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uDepthSampler", Graphic3d_TOS_FRAGMENT));
TCollection_AsciiString aSrcFrag =
- EOL"uniform sampler2D uColorSampler;"
- EOL"uniform sampler2D uDepthSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
EOL" occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
EOL"}";
+ Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
#if defined(GL_ES_VERSION_2_0)
if (myContext->IsGlGreaterEqual (3, 0))
{
{
// there is no way to draw into depth buffer
aSrcFrag =
- EOL"uniform sampler2D uColorSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
aProgramSrc->SetHeader ("#version 150");
}
#endif
+ aProgramSrc->SetId ("occt_blit");
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, myBlitProgram))
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
TCollection_AsciiString aSrcVert, aSrcFrag;
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+
aSrcVert =
- EOL"THE_SHADER_OUT vec2 TexCoord;"
EOL"void main()"
EOL"{"
EOL" TexCoord = occVertex.zw;"
if (!theMsaa)
{
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uAccumTexture", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uWeightTexture", Graphic3d_TOS_FRAGMENT));
aSrcFrag =
- EOL"uniform sampler2D uAccumTexture;"
- EOL"uniform sampler2D uWeightTexture;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aAccum = occTexture2D (uAccumTexture, TexCoord);"
}
else
{
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uAccumTexture", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uWeightTexture", Graphic3d_TOS_FRAGMENT));
aSrcFrag =
- EOL"uniform sampler2DMS uAccumTexture;"
- EOL"uniform sampler2DMS uWeightTexture;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" ivec2 aTexel = ivec2 (vec2 (textureSize (uAccumTexture)) * TexCoord);"
#endif
}
+ aProgramSrc->SetId (theMsaa ? "occt_weight-oit-msaa" : "occt_weight-oit");
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, aProgram))
{
TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 == NULL
- && (theBits & OpenGl_PO_TextureA) != 0)
+ && (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureA)
{
aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }";
}
return aSrcGetAlpha;
}
-namespace
+// =======================================================================
+// function : defaultGlslVersion
+// purpose :
+// =======================================================================
+int OpenGl_ShaderManager::defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
+ const TCollection_AsciiString& theName,
+ int theBits,
+ bool theUsesDerivates) const
{
+ int aBits = theBits;
+#if !defined(GL_ES_VERSION_2_0)
+ if (myContext->core32 != NULL)
+ {
+ theProgram->SetHeader ("#version 150");
+ }
+ else
+ {
+ if ((theBits & OpenGl_PO_StippleLine) != 0)
+ {
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ theProgram->SetHeader ("#version 130");
+ }
+ else if (myContext->CheckExtension ("GL_EXT_gpu_shader4"))
+ {
+ theProgram->SetHeader ("#extension GL_EXT_gpu_shader4 : enable");
+ }
+ else
+ {
+ aBits = aBits & ~OpenGl_PO_StippleLine;
+ }
+ }
+ }
+ (void )theUsesDerivates;
+#else
+ // prefer "100 es" on OpenGL ES 3.0- devices (save the features unavailable before "300 es")
+ // and "300 es" on OpenGL ES 3.1+ devices
+ if (myContext->IsGlGreaterEqual (3, 1))
+ {
+ if ((theBits & OpenGl_PO_NeedsGeomShader) != 0)
+ {
+ theProgram->SetHeader (myContext->hasGeometryStage != OpenGl_FeatureInExtensions ? "#version 320 es" : "#version 310 es");
+ }
+ else
+ {
+ theProgram->SetHeader ("#version 300 es");
+ }
+ }
+ else
+ {
+ if ((theBits & OpenGl_PO_WriteOit) != 0
+ || (theBits & OpenGl_PO_StippleLine) != 0)
+ {
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ theProgram->SetHeader ("#version 300 es");
+ }
+ else
+ {
+ aBits = aBits & ~OpenGl_PO_WriteOit;
+ aBits = aBits & ~OpenGl_PO_StippleLine;
+ }
+ }
+ if (theUsesDerivates)
+ {
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ theProgram->SetHeader ("#version 300 es");
+ }
+ else if (myContext->oesStdDerivatives)
+ {
+ theProgram->SetHeader ("#extension GL_OES_standard_derivatives : enable");
+ }
+ }
+ }
+#endif
+
+ // should fit OpenGl_PO_NB
+ char aBitsStr[64];
+ Sprintf (aBitsStr, "%04x", aBits);
+ theProgram->SetId (TCollection_AsciiString ("occt_") + theName + aBitsStr);
+ return aBits;
+}
+
+// =======================================================================
+// function : prepareGeomMainSrc
+// purpose :
+// =======================================================================
+TCollection_AsciiString OpenGl_ShaderManager::prepareGeomMainSrc (OpenGl_ShaderObject::ShaderVariableList& theUnifoms,
+ OpenGl_ShaderObject::ShaderVariableList& theStageInOuts,
+ Standard_Integer theBits)
+{
+ if ((theBits & OpenGl_PO_NeedsGeomShader) == 0)
+ {
+ return TCollection_AsciiString();
+ }
+
+ TCollection_AsciiString aSrcMainGeom =
+ EOL"void main()"
+ EOL"{";
- // =======================================================================
- // function : textureUsed
- // purpose :
- // =======================================================================
- static bool textureUsed (const Standard_Integer theBits)
+ if ((theBits & OpenGl_PO_MeshEdges) != 0)
{
- return (theBits & OpenGl_PO_TextureA) != 0 || (theBits & OpenGl_PO_TextureRGB) != 0;
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_GEOMETRY));
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("bool occIsQuadMode", Graphic3d_TOS_GEOMETRY));
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_GEOMETRY));
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_FRAGMENT));
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineFeather", Graphic3d_TOS_FRAGMENT));
+ theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occWireframeColor", Graphic3d_TOS_FRAGMENT));
+ theStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable ("vec3 EdgeDistance", Graphic3d_TOS_GEOMETRY | Graphic3d_TOS_FRAGMENT));
+
+ aSrcMainGeom = TCollection_AsciiString()
+ + EOL"vec3 ViewPortTransform (vec4 theVec)"
+ EOL"{"
+ EOL" vec3 aWinCoord = theVec.xyz / theVec.w;"
+ EOL" aWinCoord = aWinCoord * 0.5 + 0.5;"
+ EOL" aWinCoord.xy = aWinCoord.xy * occViewport.zw + occViewport.xy;"
+ EOL" return aWinCoord;"
+ EOL"}"
+ + aSrcMainGeom
+ + EOL" vec3 aSideA = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[1].gl_Position);"
+ EOL" vec3 aSideB = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
+ EOL" vec3 aSideC = ViewPortTransform (gl_in[1].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
+ EOL" float aQuadArea = abs (aSideB.x * aSideC.y - aSideB.y * aSideC.x);"
+ EOL" vec3 aLenABC = vec3 (length (aSideA), length (aSideB), length (aSideC));"
+ EOL" vec3 aHeightABC = vec3 (aQuadArea) / aLenABC;"
+ EOL" aHeightABC = max (aHeightABC, vec3 (10.0 * occLineWidth));" // avoid shrunk presentation disappearing at distance
+ EOL" float aQuadModeHeightC = occIsQuadMode ? occLineWidth + 1.0 : 0.0;";
+ }
+
+ for (Standard_Integer aVertIter = 0; aVertIter < 3; ++aVertIter)
+ {
+ const TCollection_AsciiString aVertIndex (aVertIter);
+ // pass variables from Vertex shader to Fragment shader through Geometry shader
+ for (OpenGl_ShaderObject::ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
+ {
+ if (aVarListIter.Value().Stages == (Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT))
+ {
+ const TCollection_AsciiString aVarName = aVarListIter.Value().Name.Token (" ", 2);
+ aSrcMainGeom += TCollection_AsciiString()
+ + EOL" geomOut." + aVarName + " = geomIn[" + aVertIndex + "]." + aVarName + ";";
+ }
+ }
+
+ if ((theBits & OpenGl_PO_MeshEdges) != 0)
+ {
+ switch (aVertIter)
+ {
+ case 0: aSrcMainGeom += EOL" EdgeDistance = vec3 (aHeightABC[0], 0.0, aQuadModeHeightC);"; break;
+ case 1: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, aHeightABC[1], aQuadModeHeightC);"; break;
+ case 2: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, 0.0, aHeightABC[2]);"; break;
+ }
+ }
+ aSrcMainGeom += TCollection_AsciiString()
+ + EOL" gl_Position = gl_in[" + aVertIndex + "].gl_Position;"
+ EOL" EmitVertex();";
}
+ aSrcMainGeom +=
+ EOL" EndPrimitive();"
+ EOL"}";
+ return aSrcMainGeom;
}
// =======================================================================
// purpose :
// =======================================================================
Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
- const Standard_Integer theBits)
+ Standard_Integer theBits,
+ Standard_Boolean theIsOutline)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha;
- TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
+ TCollection_AsciiString aSrcVert, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcVertEndMain;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
- TCollection_AsciiString aSrcFragMainGetColor = EOL" occSetFragColor (getColor());";
+ TCollection_AsciiString aSrcFragMainGetColor = EOL" occSetFragColor (getFinalColor());";
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+
if ((theBits & OpenGl_PO_Point) != 0)
{
#if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
- aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
- }
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
+ {
+ aSrcFragGetColor =
+ EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
+ }
- if (textureUsed (theBits))
- {
aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
#if !defined(GL_ES_VERSION_2_0)
}
else
{
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_TextureRGB) != 0 || (theBits & OpenGl_PO_TextureEnv) != 0)
+ {
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ }
+
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
- aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
- aSrcFragExtraOut += THE_VARY_TexCoord_IN;
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
}
else if ((theBits & OpenGl_PO_TextureEnv) != 0)
{
- aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
- aSrcFragExtraOut += THE_VARY_TexCoord_IN;
-
aSrcVertExtraFunc = THE_FUNC_transformNormal;
aSrcVertExtraMain +=
}
if ((theBits & OpenGl_PO_VertColor) != 0)
{
- aSrcVertExtraOut += EOL"THE_SHADER_OUT vec4 VertColor;";
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += EOL" VertColor = occVertColor;";
- aSrcFragExtraOut += EOL"THE_SHADER_IN vec4 VertColor;";
aSrcFragGetColor = EOL"vec4 getColor(void) { return VertColor; }";
}
int aNbClipPlanes = 0;
if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
{
- aSrcVertExtraOut +=
- EOL"THE_SHADER_OUT vec4 PositionWorld;"
- EOL"THE_SHADER_OUT vec4 Position;";
- aSrcFragExtraOut +=
- EOL"THE_SHADER_IN vec4 PositionWorld;"
- EOL"THE_SHADER_IN vec4 Position;";
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain +=
EOL" PositionWorld = occModelWorldMatrix * occVertex;"
EOL" Position = occWorldViewMatrix * PositionWorld;";
- if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
+ if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
+ {
+ aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
+ aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
+ ? THE_FRAG_CLIP_CHAINS_N
+ : THE_FRAG_CLIP_PLANES_N;
+ }
+ else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
{
aNbClipPlanes = 1;
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
? THE_FRAG_CLIP_CHAINS_2
: THE_FRAG_CLIP_PLANES_2;
}
- else
- {
- aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
- aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
- ? THE_FRAG_CLIP_CHAINS_N
- : THE_FRAG_CLIP_PLANES_N;
- }
}
if ((theBits & OpenGl_PO_WriteOit) != 0)
{
aProgramSrc->SetNbFragmentOutputs (2);
aProgramSrc->SetWeightOitOutput (true);
- #if defined(GL_ES_VERSION_2_0)
- if (myContext->IsGlGreaterEqual (3, 0))
- {
- aProgramSrc->SetHeader ("#version 300 es");
- }
- #endif
}
- TCollection_AsciiString aSrcVertEndMain;
- if ((theBits & OpenGl_PO_StippleLine) != 0)
+ if (theIsOutline)
{
- bool hasGlslBitOps = false;
- #if defined(GL_ES_VERSION_2_0)
- if (myContext->IsGlGreaterEqual (3, 0))
- {
- aProgramSrc->SetHeader ("#version 300 es");
- hasGlslBitOps = true;
- }
- #else
- if (myContext->IsGlGreaterEqual (3, 0))
- {
- aProgramSrc->SetHeader ("#version 130");
- hasGlslBitOps = true;
- }
- else if(myContext->CheckExtension("GL_EXT_gpu_shader4"))
- {
- aProgramSrc->SetHeader ("#extension GL_EXT_gpu_shader4 : enable");
- hasGlslBitOps = true;
- }
- #endif
-
- if (hasGlslBitOps)
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occOrthoScale", Graphic3d_TOS_VERTEX));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occSilhouetteThickness", Graphic3d_TOS_VERTEX));
+ aSrcVertEndMain = THE_VERT_gl_Position_OUTLINE;
+ }
+ else if ((theBits & OpenGl_PO_StippleLine) != 0)
+ {
+ const Standard_Integer aBits = defaultGlslVersion (aProgramSrc, "unlit", theBits);
+ if ((aBits & OpenGl_PO_StippleLine) != 0)
{
- aSrcVertExtraOut +=
- EOL"THE_SHADER_OUT vec2 ScreenSpaceCoord;";
- aSrcFragExtraOut +=
- EOL"THE_SHADER_IN vec2 ScreenSpaceCoord;"
- EOL"uniform int uPattern;"
- EOL"uniform float uFactor;";
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uPattern", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float uFactor", Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 ScreenSpaceCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertEndMain =
EOL" ScreenSpaceCoord = gl_Position.xy / gl_Position.w;";
aSrcFragMainGetColor =
EOL" float aRotatePoint = gl_FragCoord.x * sin (anAngle) + gl_FragCoord.y * cos (anAngle);"
EOL" uint aBit = uint (floor (aRotatePoint / uFactor + 0.5)) & 15U;"
EOL" if ((uint (uPattern) & (1U << aBit)) == 0U) discard;"
- EOL" vec4 aColor = getColor();"
+ EOL" vec4 aColor = getFinalColor();"
EOL" if (aColor.a <= 0.1) discard;"
EOL" occSetFragColor (aColor);";
}
else
{
- const TCollection_ExtendedString aWarnMessage =
- "Warning: stipple lines in GLSL will be ignored.";
- myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
- GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, aWarnMessage);
+ myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, "Warning: stipple lines in GLSL will be ignored.");
}
}
aSrcVert =
aSrcVertExtraFunc
- + aSrcVertExtraOut
+ EOL"void main()"
EOL"{"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
+ + THE_VERT_gl_Position
+ aSrcVertEndMain
+ EOL"}";
+ TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
+ aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
+ ? THE_FRAG_WIREFRAME_COLOR
+ : EOL"#define getFinalColor getColor";
+
aSrcFrag =
- aSrcFragExtraOut
- + aSrcFragGetColor
+ aSrcFragGetColor
+ aSrcGetAlpha
+ EOL"void main()"
EOL"{"
+ aSrcFragExtraMain
+ aSrcFragMainGetColor
- + aSrcFragWriteOit
+ EOL"}";
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
-#endif
+ defaultGlslVersion (aProgramSrc, theIsOutline ? "outline" : "unlit", theBits);
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
-
+ const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, theProgram))
{
const Standard_Integer theBits)
{
TCollection_AsciiString aSrcFragGetColor;
- if ((theBits & OpenGl_PO_TextureA) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureA)
{
aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
EOL"vec4 getColor(void)"
EOL" return aColor;"
EOL"}";
}
- else if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ else if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
aSrcFragGetColor = TCollection_AsciiString() +
EOL"vec4 getColor(void)"
const Standard_Integer theBits)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain;
- TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
+ TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraMain;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+
if ((theBits & OpenGl_PO_Point) != 0)
{
#if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if (textureUsed (theBits))
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL
}
else
{
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
- aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
- aSrcFragExtraOut += THE_VARY_TexCoord_IN;
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
int aNbClipPlanes = 0;
if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
{
- aSrcVertExtraOut +=
- EOL"THE_SHADER_OUT vec4 PositionWorld;"
- EOL"THE_SHADER_OUT vec4 Position;";
- aSrcFragExtraOut +=
- EOL"THE_SHADER_IN vec4 PositionWorld;"
- EOL"THE_SHADER_IN vec4 Position;";
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain +=
EOL" PositionWorld = aPositionWorld;"
EOL" Position = aPosition;";
- if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
+ if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
+ {
+ aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
+ aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
+ ? THE_FRAG_CLIP_CHAINS_N
+ : THE_FRAG_CLIP_PLANES_N;
+ }
+ else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
{
aNbClipPlanes = 1;
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
? THE_FRAG_CLIP_CHAINS_2
: THE_FRAG_CLIP_PLANES_2;
}
- else
- {
- aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
- aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
- ? THE_FRAG_CLIP_CHAINS_N
- : THE_FRAG_CLIP_PLANES_N;
- }
}
if ((theBits & OpenGl_PO_WriteOit) != 0)
{
aProgramSrc->SetNbFragmentOutputs (2);
aProgramSrc->SetWeightOitOutput (true);
- #if defined(GL_ES_VERSION_2_0)
- if (myContext->IsGlGreaterEqual (3, 0))
- {
- aProgramSrc->SetHeader ("#version 300 es");
- }
- #endif
}
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 FrontColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 BackColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+
Standard_Integer aNbLights = 0;
const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
aSrcVert = TCollection_AsciiString()
+ EOL
+ aSrcVertColor
+ aLights
- + EOL
- EOL"THE_SHADER_OUT vec4 FrontColor;"
- EOL"THE_SHADER_OUT vec4 BackColor;"
- EOL
- + aSrcVertExtraOut
+ EOL"void main()"
EOL"{"
EOL" vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
EOL" FrontColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
EOL" BackColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + THE_VERT_gl_Position
+ + EOL"}";
+
+ TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
+ aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
+ ? THE_FRAG_WIREFRAME_COLOR
+ : EOL"#define getFinalColor getColor";
aSrcFrag = TCollection_AsciiString()
- + EOL"THE_SHADER_IN vec4 FrontColor;"
- EOL"THE_SHADER_IN vec4 BackColor;"
- + aSrcFragExtraOut
+ aSrcFragGetColor
+ EOL"void main()"
EOL"{"
+ aSrcFragExtraMain
- + EOL" occSetFragColor (getColor());"
- + aSrcFragWriteOit
+ + EOL" occSetFragColor (getFinalColor());"
+ EOL"}";
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
-#endif
+ const TCollection_AsciiString aProgId = TCollection_AsciiString ("gouraud-") + genLightKey (myLightSourceState.LightSources()) + "-";
+ defaultGlslVersion (aProgramSrc, aProgId, theBits);
aProgramSrc->SetNbLightsMax (aNbLights);
aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, theProgram))
{
const Standard_Boolean theIsFlatNormal)
{
#define thePhongCompLight "computeLighting (normalize (Normal), normalize (View), Position, gl_FrontFacing)"
-#if defined(GL_ES_VERSION_2_0)
const bool isFlatNormal = theIsFlatNormal
- && (myContext->IsGlGreaterEqual (3, 0)
- || myContext->oesStdDerivatives);
-#else
- const bool isFlatNormal = theIsFlatNormal;
+ && myContext->hasFlatShading != OpenGl_FeatureNotAvailable;
+ const char* aDFdxSignReversion = "";
+#if defined(GL_ES_VERSION_2_0)
+ if (isFlatNormal != theIsFlatNormal)
+ {
+ myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+ GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
+ "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
+ }
+ else if (isFlatNormal
+ && myContext->Vendor().Search("qualcomm") != -1)
+ {
+ // workaround Adreno driver bug computing reversed normal using dFdx/dFdy
+ aDFdxSignReversion = "-";
+ myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
+ "Warning: applied workaround for flat shading normal computation using dFdx/dFdy on Adreno");
+ }
#endif
-
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain;
- TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain, aSrcFragWriteOit;
+ TCollection_AsciiString aSrcVert, aSrcVertExtraFunc, aSrcVertExtraMain;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return " thePhongCompLight "; }";
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
if ((theBits & OpenGl_PO_Point) != 0)
{
#if defined(GL_ES_VERSION_2_0)
aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
#endif
- if (textureUsed (theBits))
+ if ((theBits & OpenGl_PO_HasTextures) != 0)
{
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 != NULL
}
else
{
- if ((theBits & OpenGl_PO_TextureRGB) != 0)
+ if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
{
- aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
- aSrcFragExtraOut += THE_VARY_TexCoord_IN;
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
if ((theBits & OpenGl_PO_VertColor) != 0)
{
- aSrcVertExtraOut += EOL"THE_SHADER_OUT vec4 VertColor;";
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
aSrcVertExtraMain += EOL" VertColor = occVertColor;";
- aSrcFragGetVertColor = EOL"THE_SHADER_IN vec4 VertColor;"
- EOL"vec4 getVertColor(void) { return VertColor; }";
+ aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
}
int aNbClipPlanes = 0;
if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
{
- if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
+ if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
+ {
+ aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
+ aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
+ ? THE_FRAG_CLIP_CHAINS_N
+ : THE_FRAG_CLIP_PLANES_N;
+ }
+ else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
{
aNbClipPlanes = 1;
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
? THE_FRAG_CLIP_CHAINS_2
: THE_FRAG_CLIP_PLANES_2;
}
- else
- {
- aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
- aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
- ? THE_FRAG_CLIP_CHAINS_N
- : THE_FRAG_CLIP_PLANES_N;
- }
}
if ((theBits & OpenGl_PO_WriteOit) != 0)
{
aProgramSrc->SetWeightOitOutput (true);
}
+ if (isFlatNormal)
+ {
+ aSrcFragExtraOut += EOL"vec3 Normal;";
+ aSrcFragExtraMain += TCollection_AsciiString()
+ + EOL" Normal = " + aDFdxSignReversion + "normalize (cross (dFdx (Position.xyz / Position.w), dFdy (Position.xyz / Position.w)));"
+ EOL" if (!gl_FrontFacing) { Normal = -Normal; }";
+ }
+ else
+ {
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 Normal", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aSrcVertExtraFunc += THE_FUNC_transformNormal;
+ aSrcVertExtraMain += EOL" Normal = transformNormal (occNormal);";
+ }
+
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 View", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
+
aSrcVert = TCollection_AsciiString()
- + (isFlatNormal ? "" : THE_FUNC_transformNormal)
- + EOL
- EOL"THE_SHADER_OUT vec4 PositionWorld;"
- EOL"THE_SHADER_OUT vec4 Position;"
- EOL"THE_SHADER_OUT vec3 View;"
- + (isFlatNormal ? ""
- : EOL"THE_SHADER_OUT vec3 Normal;")
- + EOL
- + aSrcVertExtraOut
+ + aSrcVertExtraFunc
+ EOL"void main()"
EOL"{"
EOL" PositionWorld = occModelWorldMatrix * occVertex;"
EOL" Position = occWorldViewMatrix * PositionWorld;"
- + (isFlatNormal ? ""
- : EOL" Normal = transformNormal (occNormal);")
+ EOL" View = vec3 (0.0, 0.0, 1.0);"
+ aSrcVertExtraMain
- + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + THE_VERT_gl_Position
+ + EOL"}";
+
+ TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
+ aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
+ ? THE_FRAG_WIREFRAME_COLOR
+ : EOL"#define getFinalColor getColor";
Standard_Integer aNbLights = 0;
const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
aSrcFrag = TCollection_AsciiString()
- + EOL"THE_SHADER_IN vec4 PositionWorld;"
- EOL"THE_SHADER_IN vec4 Position;"
- EOL"THE_SHADER_IN vec3 View;"
- + (isFlatNormal
- ? EOL"vec3 Normal;"
- : EOL"THE_SHADER_IN vec3 Normal;")
+ EOL
+ aSrcFragExtraOut
+ aSrcFragGetVertColor
EOL"void main()"
EOL"{"
+ aSrcFragExtraMain
- + (isFlatNormal
- ? EOL" Normal = normalize (cross (dFdx (Position.xyz / Position.w), dFdy (Position.xyz / Position.w)));"
- EOL" if (!gl_FrontFacing) { Normal = -Normal; }"
- : "")
- + EOL" occSetFragColor (getColor());"
- + aSrcFragWriteOit
+ + EOL" occSetFragColor (getFinalColor());"
+ EOL"}";
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
- else if (isFlatNormal)
- {
- if (myContext->IsGlGreaterEqual (3, 0))
- {
- aProgramSrc->SetHeader ("#version 300 es");
- }
- else if (myContext->oesStdDerivatives)
- {
- aProgramSrc->SetHeader ("#extension GL_OES_standard_derivatives : enable");
- }
- else
- {
- myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
- GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
- "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
- }
- }
-#endif
+ const TCollection_AsciiString aProgId = TCollection_AsciiString (theIsFlatNormal ? "flat-" : "phong-") + genLightKey (myLightSourceState.LightSources()) + "-";
+ defaultGlslVersion (aProgramSrc, aProgId, theBits, isFlatNormal);
aProgramSrc->SetNbLightsMax (aNbLights);
aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, theProgram))
{
const Graphic3d_StereoMode theStereoMode)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+
+ aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
TCollection_AsciiString aSrcVert =
- EOL"THE_SHADER_OUT vec2 TexCoord;"
EOL"void main()"
EOL"{"
EOL" TexCoord = occVertex.zw;"
EOL"}";
TCollection_AsciiString aSrcFrag;
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uLeftSampler", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uRightSampler", Graphic3d_TOS_FRAGMENT));
+ const char* aName = "stereo";
switch (theStereoMode)
{
case Graphic3d_StereoMode_Anaglyph:
{
+ aName = "anaglyph";
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultL", Graphic3d_TOS_FRAGMENT));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultR", Graphic3d_TOS_FRAGMENT));
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"uniform mat4 uMultL;"
- EOL"uniform mat4 uMultR;"
- EOL
EOL"const vec4 THE_POW_UP = vec4 (2.2, 2.2, 2.2, 1.0);"
EOL"const vec4 THE_POW_DOWN = 1.0 / vec4 (2.2, 2.2, 2.2, 1.0);"
EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
}
case Graphic3d_StereoMode_RowInterlaced:
{
+ aName = "row-interlaced";
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
}
case Graphic3d_StereoMode_ColumnInterlaced:
{
+ aName = "column-interlaced";
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
}
case Graphic3d_StereoMode_ChessBoard:
{
+ aName = "chessboard";
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
}
case Graphic3d_StereoMode_SideBySide:
{
+ aName = "sidebyside";
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
}
case Graphic3d_StereoMode_OverUnder:
{
+ aName = "overunder";
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
return aProgram->IsValid();
}*/
aSrcFrag =
- EOL"uniform sampler2D uLeftSampler;"
- EOL"uniform sampler2D uRightSampler;"
- EOL
- EOL"THE_SHADER_IN vec2 TexCoord;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
}
}
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
-#endif
-
+ defaultGlslVersion (aProgramSrc, aName, 0);
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, theProgram))
{
Standard_Boolean OpenGl_ShaderManager::prepareStdProgramBoundBox()
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+
+ OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxCenter", Graphic3d_TOS_VERTEX));
+ aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxSize", Graphic3d_TOS_VERTEX));
+
TCollection_AsciiString aSrcVert =
- EOL"uniform vec3 occBBoxCenter;"
- EOL"uniform vec3 occBBoxSize;"
- EOL
EOL"void main()"
EOL"{"
EOL" vec4 aCenter = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
EOL" occSetFragColor (occColor);"
EOL"}";
-#if !defined(GL_ES_VERSION_2_0)
- if (myContext->core32 != NULL)
- {
- aProgramSrc->SetHeader ("#version 150");
- }
-#else
- if (myContext->IsGlGreaterEqual (3, 1))
- {
- // prefer "100 es" on OpenGL ES 3.0 devices
- // and "300 es" on newer devices (3.1+)
- aProgramSrc->SetHeader ("#version 300 es");
- }
-#endif
-
+ defaultGlslVersion (aProgramSrc, "bndbox", 0);
aProgramSrc->SetNbLightsMax (0);
aProgramSrc->SetNbClipPlanesMax (0);
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
- aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
+ aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
TCollection_AsciiString aKey;
if (!Create (aProgramSrc, aKey, myBoundBoxProgram))
{
projects / occt.git / blobdiff