#include <typeinfo>
+#include <Graphic3d_TextureParams.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_Workspace.hxx>
-IMPLEMENT_STANDARD_HANDLE (OpenGl_SetOfShaderPrograms, Standard_Transient)
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_SetOfShaderPrograms, Standard_Transient)
+#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_HANDLE (OpenGl_ShaderManager, Standard_Transient)
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager, Standard_Transient)
+
+
+
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
namespace
{
#define EOL "\n"
-//! Definition of VertColor varying.
+//! Definition of TexCoord varying.
const char THE_VARY_TexCoord_OUT[] =
- EOL"THE_SHADER_OUT vec2 TexCoord;";
+ EOL"THE_SHADER_OUT vec4 TexCoord;";
const char THE_VARY_TexCoord_IN[] =
- EOL"THE_SHADER_IN vec2 TexCoord;";
+ EOL"THE_SHADER_IN vec4 TexCoord;";
+//! Compute TexCoord value in Vertex Shader
+const char THE_VARY_TexCoord_Trsf[] =
+ EOL" float aRotSin = occTextureTrsf_RotationSin();"
+ EOL" float aRotCos = occTextureTrsf_RotationCos();"
+ EOL" vec2 aTex2 = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
+ EOL" vec2 aCopy = aTex2;"
+ EOL" aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
+ EOL" aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
+ EOL" TexCoord = vec4(aTex2, occTexCoord.zw);";
//! Auxiliary function to transform normal
const char THE_FUNC_transformNormal[] =
EOL" Specular += occLight_Specular (theId).rgb * aSpecl;"
EOL"}";
+//! The same as THE_FUNC_directionalLight but for the light with zero index
+//! (avoids limitations on some mobile devices).
+const char THE_FUNC_directionalLightFirst[] =
+ EOL"void directionalLightFirst (in vec3 theNormal,"
+ EOL" in vec3 theView,"
+ EOL" in bool theIsFront)"
+ EOL"{"
+ EOL" vec3 aLight = normalize (occLightSources[1].xyz);"
+ EOL" if (occLight_IsHeadlight (0) == 0)"
+ EOL" {"
+ EOL" aLight = vec3 (occWorldViewMatrix * occModelWorldMatrix * vec4 (aLight, 0.0));"
+ EOL" }"
+ EOL
+ EOL" vec3 aHalf = normalize (aLight + theView);"
+ EOL
+ EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
+ EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
+ EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
+ EOL
+ EOL" float aSpecl = 0.0;"
+ EOL" if (aNdotL > 0.0)"
+ EOL" {"
+ EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
+ EOL" }"
+ EOL
+ EOL" Diffuse += occLightSources[0].rgb * aNdotL;"
+ EOL" Specular += occLightSources[0].rgb * aSpecl;"
+ EOL"}";
+
//! Process clipping planes in Fragment Shader.
//! Should be added at the beginning of the main() function.
const char THE_FRAG_CLIP_PLANES[] =
// purpose : Creates new empty shader manager
// =======================================================================
OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
-: myShadingModel (Visual3d_TOM_VERTEX),
+: myShadingModel (Graphic3d_TOSM_VERTEX),
myContext (theContext),
myLastView (NULL)
{
myMapOfLightPrograms.Clear();
myFontProgram.Nullify();
myBlitProgram.Nullify();
+ for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
+ {
+ myStereoPrograms[aModeIter].Nullify();
+ }
switchLightPrograms();
}
// =======================================================================
void OpenGl_ShaderManager::switchLightPrograms()
{
- TCollection_AsciiString aKey (myShadingModel == Visual3d_TOM_FRAGMENT ? "p_" : "g_");
+ TCollection_AsciiString aKey (myShadingModel == Graphic3d_TOSM_FRAGMENT ? "p_" : "g_");
const OpenGl_ListOfLight* aLights = myLightSourceState.LightSources();
if (aLights != NULL)
{
{
switch (aLightIter.Value().Type)
{
- case Visual3d_TOLS_AMBIENT:
+ case Graphic3d_TOLS_AMBIENT:
break; // skip ambient
- case Visual3d_TOLS_DIRECTIONAL:
+ case Graphic3d_TOLS_DIRECTIONAL:
aKey += "d";
break;
- case Visual3d_TOLS_POSITIONAL:
+ case Graphic3d_TOLS_POSITIONAL:
aKey += "p";
break;
- case Visual3d_TOLS_SPOT:
+ case Graphic3d_TOLS_SPOT:
aKey += "s";
break;
}
// function : SetShadingModel
// purpose :
// =======================================================================
-void OpenGl_ShaderManager::SetShadingModel (const Visual3d_TypeOfModel theModel)
+void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
{
myShadingModel = theModel;
switchLightPrograms();
for (OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources()); anIter.More(); anIter.Next())
{
const OpenGl_Light& aLight = anIter.Value();
- if (aLight.Type == Visual3d_TOLS_AMBIENT)
+ if (aLight.Type == Graphic3d_TOLS_AMBIENT)
{
anAmbient += aLight.Color;
continue;
OpenGl_ShaderLightParameters& aLightParams = aLightParamsArray[aLightsNb];
aLightParams.Color = aLight.Color;
- aLightParams.Position = aLight.Type == Visual3d_TOLS_DIRECTIONAL
+ aLightParams.Position = aLight.Type == Graphic3d_TOLS_DIRECTIONAL
? -aLight.Direction
: aLight.Position;
- if (aLight.Type == Visual3d_TOLS_SPOT)
+ if (aLight.Type == Graphic3d_TOLS_SPOT)
{
aLightParams.Direction = aLight.Direction;
}
return &myMaterialStates.Find (theProgram);
}
+// =======================================================================
+// function : SurfaceDetailState
+// purpose : Returns current state of OCCT surface detail
+// =======================================================================
+const OpenGl_SurfaceDetailState& OpenGl_ShaderManager::SurfaceDetailState() const
+{
+ return mySurfaceDetailState;
+}
+
+// =======================================================================
+// function : UpdateSurfaceDetailStateTo
+// purpose : Updates state of OCCT surface detail
+// =======================================================================
+void OpenGl_ShaderManager::UpdateSurfaceDetailStateTo (const Graphic3d_TypeOfSurfaceDetail theDetail)
+{
+ mySurfaceDetailState.Set (theDetail);
+ mySurfaceDetailState.Update();
+}
+
namespace
{
continue;
}
- aParams.Init (anIndex == 0 || theAspect->DistinguishingMode() != TOn
- ? theAspect->IntFront()
- : theAspect->IntBack());
+ 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());
}
5, aParams);
}
-}; // nameless namespace
+} // nameless namespace
// =======================================================================
// function : PushMaterialState
return;
}
- if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectFace))
+ const OpenGl_Element* anAspect = aState.Aspect();
+ if (typeid (*anAspect) == typeid (OpenGl_AspectFace))
{
- PushAspectFace (myContext, theProgram, dynamic_cast<const OpenGl_AspectFace*> (aState.Aspect()));
+ PushAspectFace (myContext, theProgram, dynamic_cast<const OpenGl_AspectFace*> (anAspect));
}
- else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectLine))
+ else if (typeid (*anAspect) == typeid (OpenGl_AspectLine))
{
- PushAspectLine (myContext, theProgram, dynamic_cast<const OpenGl_AspectLine*> (aState.Aspect()));
+ PushAspectLine (myContext, theProgram, dynamic_cast<const OpenGl_AspectLine*> (anAspect));
}
- else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectText))
+ else if (typeid (*anAspect) == typeid (OpenGl_AspectText))
{
- PushAspectText (myContext, theProgram, dynamic_cast<const OpenGl_AspectText*> (aState.Aspect()));
+ PushAspectText (myContext, theProgram, dynamic_cast<const OpenGl_AspectText*> (anAspect));
}
- else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectMarker))
+ else if (typeid (*anAspect) == typeid (OpenGl_AspectMarker))
{
- PushAspectMarker (myContext, theProgram, dynamic_cast<const OpenGl_AspectMarker*> (aState.Aspect()));
+ PushAspectMarker (myContext, theProgram, dynamic_cast<const OpenGl_AspectMarker*> (anAspect));
}
theProgram->UpdateState (OpenGl_MATERIALS_STATE, aState.Index());
}
// =======================================================================
-// function : PushWorldViewState
+// function : PushState
// purpose : Pushes state of OCCT graphics parameters to the program
// =======================================================================
void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
TCollection_AsciiString aSrcVert = TCollection_AsciiString()
- + THE_VARY_TexCoord_OUT
- + EOL"void main()"
+ + EOL"THE_SHADER_OUT vec2 TexCoord;"
+ EOL"void main()"
EOL"{"
EOL" TexCoord = occTexCoord.st;"
EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
#endif
TCollection_AsciiString aSrcFrag = TCollection_AsciiString() +
- + THE_VARY_TexCoord_IN
+ + EOL"THE_SHADER_IN vec2 TexCoord;"
+ aSrcGetAlpha
+ EOL"void main()"
EOL"{"
const Standard_Integer theBits)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+ TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
TCollection_AsciiString aSrcFragMainGetColor = EOL" occFragColor = getColor();";
if ((theBits & OpenGl_PO_Point) != 0)
{
aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, gl_PointCoord).r; }";
}
+ else if (myContext->IsGlGreaterEqual (2, 1))
+ {
+ aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
+ }
#endif
aSrcFragGetColor = aSrcGetAlpha
EOL" vec4 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
{
aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
aSrcFragExtraOut += THE_VARY_TexCoord_IN;
+ aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
+
+ aSrcFragGetColor =
+ EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w); }";
+ }
+ else if ((theBits & OpenGl_PO_TextureEnv) != 0)
+ {
+ aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
+ aSrcFragExtraOut += THE_VARY_TexCoord_IN;
+
+ aSrcVertExtraFunc = THE_FUNC_transformNormal;
+
aSrcVertExtraMain +=
- EOL" TexCoord = occTexCoord.st;";
+ EOL" vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
+ EOL" vec3 aNormal = transformNormal (occNormal);"
+ EOL" vec3 aReflect = reflect (normalize (aPosition.xyz), aNormal);"
+ EOL" aReflect.z += 1.0;"
+ EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, TexCoord.st); }";
+ EOL"vec4 getColor(void) { return occTexture2D (occActiveSampler, TexCoord.st); }";
}
}
if ((theBits & OpenGl_PO_VertColor) != 0)
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES;
}
+ TCollection_AsciiString aSrcVertEndMain;
+ if ((theBits & OpenGl_PO_StippleLine) != 0)
+ {
+ 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)
+ {
+ aSrcVertExtraOut +=
+ EOL"THE_SHADER_OUT vec2 ScreenSpaceCoord;";
+ aSrcFragExtraOut +=
+ EOL"THE_SHADER_IN vec2 ScreenSpaceCoord;"
+ EOL"uniform int uPattern;"
+ EOL"uniform float uFactor;";
+ aSrcVertEndMain =
+ EOL" ScreenSpaceCoord = gl_Position.xy / gl_Position.w;";
+ aSrcFragMainGetColor =
+ EOL" float anAngle = atan (dFdx (ScreenSpaceCoord.x), dFdy (ScreenSpaceCoord.y));"
+ 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" if (aColor.a <= 0.1) discard;"
+ EOL" occFragColor = 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);
+ }
+ }
+
aSrcVert =
- aSrcVertExtraOut
+ aSrcVertExtraFunc
+ + aSrcVertExtraOut
+ EOL"void main()"
EOL"{"
+ aSrcVertExtraMain
+ EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
- EOL"}";
+ + aSrcVertEndMain
+ + EOL"}";
aSrcFrag =
aSrcFragExtraOut
// =======================================================================
TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (const Standard_Boolean theHasVertColor)
{
- bool aLightsMap[Visual3d_TOLS_SPOT + 1] = { false, false, false, false };
+ Standard_Integer aLightsMap[Graphic3d_TOLS_SPOT + 1] = { 0, 0, 0, 0 };
TCollection_AsciiString aLightsFunc, aLightsLoop;
const OpenGl_ListOfLight* aLights = myLightSourceState.LightSources();
if (aLights != NULL)
{
switch (aLightIter.Value().Type)
{
- case Visual3d_TOLS_AMBIENT:
+ case Graphic3d_TOLS_AMBIENT:
--anIndex;
break; // skip ambient
- case Visual3d_TOLS_DIRECTIONAL:
+ case Graphic3d_TOLS_DIRECTIONAL:
aLightsLoop = aLightsLoop + EOL" directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
break;
- case Visual3d_TOLS_POSITIONAL:
+ case Graphic3d_TOLS_POSITIONAL:
aLightsLoop = aLightsLoop + EOL" pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
break;
- case Visual3d_TOLS_SPOT:
+ case Graphic3d_TOLS_SPOT:
aLightsLoop = aLightsLoop + EOL" spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
break;
}
-
- bool& aTypeBit = aLightsMap[aLightIter.Value().Type];
- if (aTypeBit)
- {
- continue;
- }
-
- aTypeBit = true;
- switch (aLightIter.Value().Type)
- {
- case Visual3d_TOLS_AMBIENT: break;
- case Visual3d_TOLS_DIRECTIONAL: aLightsFunc += THE_FUNC_directionalLight; break;
- case Visual3d_TOLS_POSITIONAL: aLightsFunc += THE_FUNC_pointLight; break;
- case Visual3d_TOLS_SPOT: aLightsFunc += THE_FUNC_spotLight; break;
- }
+ aLightsMap[aLightIter.Value().Type] += 1;
+ }
+ const Standard_Integer aNbLoopLights = aLightsMap[Graphic3d_TOLS_DIRECTIONAL]
+ + aLightsMap[Graphic3d_TOLS_POSITIONAL]
+ + aLightsMap[Graphic3d_TOLS_SPOT];
+ if (aLightsMap[Graphic3d_TOLS_DIRECTIONAL] == 1
+ && aNbLoopLights == 1)
+ {
+ // use the version with hard-coded first index
+ aLightsLoop = EOL" directionalLightFirst(theNormal, theView, theIsFront);";
+ aLightsFunc += THE_FUNC_directionalLightFirst;
+ }
+ else if (aLightsMap[Graphic3d_TOLS_DIRECTIONAL] > 0)
+ {
+ aLightsFunc += THE_FUNC_directionalLight;
+ }
+ if (aLightsMap[Graphic3d_TOLS_POSITIONAL] > 0)
+ {
+ aLightsFunc += THE_FUNC_pointLight;
+ }
+ if (aLightsMap[Graphic3d_TOLS_SPOT] > 0)
+ {
+ aLightsFunc += THE_FUNC_spotLight;
}
}
EOL" Specular = vec3 (0.0);"
EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
+ aLightsLoop
- + EOL" vec4 aMaterialAmbient = " + aGetMatAmbient
- + EOL" vec4 aMaterialDiffuse = " + aGetMatDiffuse
- + EOL" vec4 aMaterialSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
- EOL" vec4 aMaterialEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
- EOL" return vec4 (Ambient, 1.0) * aMaterialAmbient"
- EOL" + vec4 (Diffuse, 1.0) * aMaterialDiffuse"
- EOL" + vec4 (Specular, 1.0) * aMaterialSpecular"
- EOL" + aMaterialEmission;"
+ + EOL" vec4 aMatAmbient = " + aGetMatAmbient
+ + EOL" vec4 aMatDiffuse = " + aGetMatDiffuse
+ + EOL" vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
+ EOL" vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
+ EOL" vec3 aColor = Ambient * aMatAmbient.rgb"
+ EOL" + Diffuse * aMatDiffuse.rgb"
+ EOL" + Specular * aMatSpecular.rgb"
+ EOL" + aMatEmission.rgb;"
+ EOL" return vec4 (aColor, aMatDiffuse.a);"
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
}
}
else
{
aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
aSrcFragExtraOut += THE_VARY_TexCoord_IN;
- aSrcVertExtraMain +=
- EOL" TexCoord = occTexCoord.st;";
+ aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
EOL"vec4 getColor(void)"
EOL"{"
EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
- EOL" return occTexture2D(occActiveSampler, TexCoord.st) * aColor;"
+ EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;"
EOL"}";
}
}
}
if ((theBits & OpenGl_PO_VertColor) != 0)
{
- aSrcVertExtraOut += EOL"THE_SHADER_OUT vec4 VertColor;";
- aSrcVertExtraMain += EOL" VertColor = occVertColor;";
- aSrcFragGetColor = EOL"THE_SHADER_IN vec4 VertColor;"
- EOL"vec4 getVertColor(void) { return VertColor; }";
+ 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)
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
}
}
else
{
aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
aSrcFragExtraOut += THE_VARY_TexCoord_IN;
- aSrcVertExtraMain +=
- EOL" TexCoord = occTexCoord.st;";
+ aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
EOL"vec4 getColor(void)"
EOL"{"
EOL" vec4 aColor = " thePhongCompLight ";"
- EOL" return occTexture2D(occActiveSampler, TexCoord.st) * aColor;"
+ EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;"
EOL"}";
}
}
return Standard_True;
}
+// =======================================================================
+// function : prepareStdProgramStereo
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
+ const Graphic3d_StereoMode theStereoMode)
+{
+ Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ 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"}";
+
+ TCollection_AsciiString aSrcFrag;
+ switch (theStereoMode)
+ {
+ case Graphic3d_StereoMode_Anaglyph:
+ {
+ aSrcFrag =
+ EOL"uniform sampler2D uLeftSampler;"
+ EOL"uniform sampler2D uRightSampler;"
+ EOL
+ EOL"uniform mat4 uMultL;"
+ EOL"uniform mat4 uMultR;"
+ EOL
+ EOL"vec4 THE_POW_UP = vec4 (2.2, 2.2, 2.2, 1.0);"
+ EOL"vec4 THE_POW_DOWN = 1.0 / THE_POW_UP;"
+ EOL
+ EOL"THE_SHADER_IN vec2 TexCoord;"
+ EOL
+ EOL"void main()"
+ EOL"{"
+ EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
+ EOL" aColorL = pow (aColorL, THE_POW_UP);" // normalize
+ EOL" aColorR = pow (aColorR, THE_POW_UP);"
+ EOL" vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
+ EOL" occFragColor = pow (aColor, THE_POW_DOWN);"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_RowInterlaced:
+ {
+ 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);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
+ EOL" if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
+ EOL" {"
+ EOL" occFragColor = aColorL;"
+ EOL" }"
+ EOL" else"
+ EOL" {"
+ EOL" occFragColor = aColorR;"
+ EOL" }"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_ColumnInterlaced:
+ {
+ 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);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
+ EOL" if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
+ EOL" {"
+ EOL" occFragColor = aColorL;"
+ EOL" }"
+ EOL" else"
+ EOL" {"
+ EOL" occFragColor = aColorR;"
+ EOL" }"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_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);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
+ EOL" bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
+ EOL" bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
+ EOL" if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
+ EOL" {"
+ EOL" occFragColor = aColorL;"
+ EOL" }"
+ EOL" else"
+ EOL" {"
+ EOL" occFragColor = aColorR;"
+ EOL" }"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_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);"
+ EOL" if (TexCoord.x > 0.5)"
+ EOL" {"
+ EOL" aTexCoord.x -= 1.0;"
+ EOL" }"
+ EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
+ EOL" if (TexCoord.x <= 0.5)"
+ EOL" {"
+ EOL" occFragColor = aColorL;"
+ EOL" }"
+ EOL" else"
+ EOL" {"
+ EOL" occFragColor = aColorR;"
+ EOL" }"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_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);"
+ EOL" if (TexCoord.y > 0.5)"
+ EOL" {"
+ EOL" aTexCoord.y -= 1.0;"
+ EOL" }"
+ EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
+ EOL" if (TexCoord.y <= 0.5)"
+ EOL" {"
+ EOL" occFragColor = aColorL;"
+ EOL" }"
+ EOL" else"
+ EOL" {"
+ EOL" occFragColor = aColorR;"
+ EOL" }"
+ EOL"}";
+ break;
+ }
+ case Graphic3d_StereoMode_QuadBuffer:
+ case Graphic3d_StereoMode_SoftPageFlip:
+ default:
+ {
+ /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
+ if (!aProgram.IsNull())
+ {
+ 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);"
+ EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
+ EOL" aColorL.b = 0.0;"
+ EOL" aColorL.g = 0.0;"
+ EOL" aColorR.r = 0.0;"
+ EOL" occFragColor = aColorL + aColorR;"
+ EOL"}";
+ break;
+ }
+ }
+
+#if !defined(GL_ES_VERSION_2_0)
+ if (myContext->core32 != NULL)
+ {
+ aProgramSrc->SetHeader ("#version 150");
+ }
+#endif
+
+ aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
+ aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ TCollection_AsciiString aKey;
+ if (!Create (aProgramSrc, aKey, theProgram))
+ {
+ theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
+ return Standard_False;
+ }
+
+ myContext->BindProgram (theProgram);
+ theProgram->SetSampler (myContext, "uLeftSampler", 0);
+ theProgram->SetSampler (myContext, "uRightSampler", 1);
+ myContext->BindProgram (NULL);
+ return Standard_True;
+}
+
// =======================================================================
// function : bindProgramWithState
// purpose :
projects / occt.git / blobdiff