1 // Created on: 2013-09-26
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
5 // This file is part of Open CASCADE Technology software library.
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
18 #include <Graphic3d_TextureParams.hxx>
19 #include <OpenGl_Aspects.hxx>
20 #include <OpenGl_ClippingIterator.hxx>
21 #include <OpenGl_Context.hxx>
22 #include <Graphic3d_CubeMapPacked.hxx>
23 #include <OpenGl_ShaderManager.hxx>
24 #include <OpenGl_ShaderProgram.hxx>
25 #include <OpenGl_VertexBufferCompat.hxx>
26 #include <OpenGl_PointSprite.hxx>
27 #include <OpenGl_Workspace.hxx>
28 #include <TCollection_ExtendedString.hxx>
30 #include "../Shaders/Shaders_PBRDistribution_glsl.pxx"
31 #include "../Shaders/Shaders_PBRGeometry_glsl.pxx"
32 #include "../Shaders/Shaders_PBRFresnel_glsl.pxx"
33 #include "../Shaders/Shaders_PBRCookTorrance_glsl.pxx"
34 #include "../Shaders/Shaders_PBRIllumination_glsl.pxx"
35 #include "../Shaders/Shaders_PBREnvBaking_fs.pxx"
36 #include "../Shaders/Shaders_PBREnvBaking_vs.pxx"
38 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
42 //! Number specifying maximum number of light sources to prepare a GLSL program with unrolled loop.
43 const Standard_Integer THE_NB_UNROLLED_LIGHTS_MAX = 32;
45 //! Compute the size of array storing holding light sources definition.
46 static Standard_Integer roundUpMaxLightSources (Standard_Integer theNbLights)
48 Standard_Integer aMaxLimit = THE_NB_UNROLLED_LIGHTS_MAX;
49 for (; aMaxLimit < theNbLights; aMaxLimit *= 2) {}
55 //! Compute TexCoord value in Vertex Shader
56 const char THE_VARY_TexCoord_Trsf[] =
57 EOL" float aRotSin = occTextureTrsf_RotationSin();"
58 EOL" float aRotCos = occTextureTrsf_RotationCos();"
59 EOL" vec2 aTex2 = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
60 EOL" vec2 aCopy = aTex2;"
61 EOL" aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
62 EOL" aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
63 EOL" TexCoord = vec4(aTex2, occTexCoord.zw);";
65 //! Auxiliary function to flip gl_PointCoord vertically
66 #define THE_VEC2_glPointCoord "vec2 (gl_PointCoord.x, 1.0 - gl_PointCoord.y)"
68 //! Auxiliary function to transform normal from model to view coordinate system.
69 const char THE_FUNC_transformNormal_view[] =
70 EOL"vec3 transformNormal (in vec3 theNormal)"
72 EOL" vec4 aResult = occWorldViewMatrixInverseTranspose"
73 EOL" * occModelWorldMatrixInverseTranspose"
74 EOL" * vec4 (theNormal, 0.0);"
75 EOL" return normalize (aResult.xyz);"
78 //! The same function as THE_FUNC_transformNormal but is used in PBR pipeline.
79 //! The normals are expected to be in world coordinate system in PBR pipeline.
80 const char THE_FUNC_transformNormal_world[] =
81 EOL"vec3 transformNormal (in vec3 theNormal)"
83 EOL" vec4 aResult = occModelWorldMatrixInverseTranspose"
84 EOL" * vec4 (theNormal, 0.0);"
85 EOL" return normalize (aResult.xyz);"
88 //! Global shader variable for color definition with lighting enabled.
89 const char THE_FUNC_lightDef[] =
90 EOL"vec3 Ambient;" //!< Ambient contribution of light sources
91 EOL"vec3 Diffuse;" //!< Diffuse contribution of light sources
92 EOL"vec3 Specular;"; //!< Specular contribution of light sources
94 //! Global shader variable for color definition with lighting enabled.
95 const char THE_FUNC_PBR_lightDef[] =
96 EOL"vec3 DirectLighting;" //!< Accumulator of direct lighting from light sources
97 EOL"vec4 BaseColor;" //!< Base color (albedo) of material for PBR
98 EOL"float Metallic;" //!< Metallic coefficient of material
99 EOL"float Roughness;" //!< Roughness coefficient of material
100 EOL"vec3 Emission;" //!< Light intensity emitted by material
101 EOL"float IOR;"; //!< Material's index of refraction
103 //! Function computes contribution of isotropic point light source
104 const char THE_FUNC_pointLight[] =
105 EOL"void pointLight (in int theId,"
106 EOL" in vec3 theNormal,"
107 EOL" in vec3 theView,"
108 EOL" in vec3 thePoint,"
109 EOL" in bool theIsFront)"
111 EOL" vec3 aLight = occLight_Position (theId).xyz;"
112 EOL" if (!occLight_IsHeadlight (theId))"
114 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
116 EOL" aLight -= thePoint;"
118 EOL" float aDist = length (aLight);"
119 EOL" aLight = aLight * (1.0 / aDist);"
121 EOL" float anAtten = 1.0 / (occLight_ConstAttenuation (theId)"
122 EOL" + occLight_LinearAttenuation (theId) * aDist);"
124 EOL" vec3 aHalf = normalize (aLight + theView);"
126 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
127 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
128 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
130 EOL" float aSpecl = 0.0;"
131 EOL" if (aNdotL > 0.0)"
133 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
136 EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
137 EOL" Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
140 //! Function computes contribution of isotropic point light source
141 const char THE_FUNC_PBR_pointLight[] =
142 EOL"void pointLight (in int theId,"
143 EOL" in vec3 theNormal,"
144 EOL" in vec3 theView,"
145 EOL" in vec3 thePoint,"
146 EOL" in bool theIsFront)"
148 EOL" vec3 aLight = occLight_Position (theId).xyz;"
149 EOL" if (occLight_IsHeadlight (theId))"
151 EOL" aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 1.0));"
153 EOL" aLight -= thePoint;"
155 EOL" float aDist = length (aLight);"
156 EOL" aLight /= aDist;"
158 EOL" float anAtten = 1.0 / max (aDist * aDist, 0.01);"
160 EOL" theNormal = theIsFront ? theNormal : -theNormal;"
161 EOL" DirectLighting += occPBRIllumination (theView,"
168 EOL" occLight_Specular(theId).rgb,"
169 EOL" occLight_Intensity(theId) * anAtten);"
172 //! Function computes contribution of spotlight source
173 const char THE_FUNC_spotLight[] =
174 EOL"void spotLight (in int theId,"
175 EOL" in vec3 theNormal,"
176 EOL" in vec3 theView,"
177 EOL" in vec3 thePoint,"
178 EOL" in bool theIsFront)"
180 EOL" vec3 aLight = occLight_Position (theId).xyz;"
181 EOL" vec3 aSpotDir = occLight_SpotDirection (theId).xyz;"
182 EOL" if (!occLight_IsHeadlight (theId))"
184 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
185 EOL" aSpotDir = vec3 (occWorldViewMatrix * vec4 (aSpotDir, 0.0));"
187 EOL" aLight -= thePoint;"
189 EOL" float aDist = length (aLight);"
190 EOL" aLight = aLight * (1.0 / aDist);"
192 EOL" aSpotDir = normalize (aSpotDir);"
194 EOL" float aCosA = dot (aSpotDir, -aLight);"
195 EOL" if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
200 EOL" float anExponent = occLight_SpotExponent (theId);"
201 EOL" float anAtten = 1.0 / (occLight_ConstAttenuation (theId)"
202 EOL" + occLight_LinearAttenuation (theId) * aDist);"
203 EOL" if (anExponent > 0.0)"
205 EOL" anAtten *= pow (aCosA, anExponent * 128.0);"
208 EOL" vec3 aHalf = normalize (aLight + theView);"
210 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
211 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
212 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
214 EOL" float aSpecl = 0.0;"
215 EOL" if (aNdotL > 0.0)"
217 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
220 EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
221 EOL" Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
224 //! Function computes contribution of spotlight source
225 const char THE_FUNC_PBR_spotLight[] =
226 EOL"void spotLight (in int theId,"
227 EOL" in vec3 theNormal,"
228 EOL" in vec3 theView,"
229 EOL" in vec3 thePoint,"
230 EOL" in bool theIsFront)"
232 EOL" vec3 aLight = occLight_Position (theId).xyz;"
233 EOL" vec3 aSpotDir = occLight_SpotDirection (theId).xyz;"
234 EOL" if (occLight_IsHeadlight (theId))"
236 EOL" aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 1.0));"
237 EOL" aSpotDir = vec3 (occWorldViewMatrixInverse * vec4 (aSpotDir, 0.0));"
239 EOL" aLight -= thePoint;"
241 EOL" float aDist = length (aLight);"
242 EOL" aLight /= aDist;"
244 EOL" aSpotDir = normalize (aSpotDir);"
246 EOL" float aCosA = dot (aSpotDir, -aLight);"
247 EOL" if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
252 EOL" float anExponent = occLight_SpotExponent (theId);"
253 EOL" float anAtten = 1.0 / max (aDist * aDist, 0.01);"
254 EOL" if (anExponent > 0.0)"
256 EOL" anAtten *= pow (aCosA, anExponent * 128.0);"
259 EOL" theNormal = theIsFront ? theNormal : -theNormal;"
260 EOL" DirectLighting += occPBRIllumination (theView,"
267 EOL" occLight_Specular(theId).rgb,"
268 EOL" occLight_Intensity(theId) * anAtten);"
271 //! Function computes contribution of directional light source
272 const char THE_FUNC_directionalLight[] =
273 EOL"void directionalLight (in int theId,"
274 EOL" in vec3 theNormal,"
275 EOL" in vec3 theView,"
276 EOL" in bool theIsFront)"
278 EOL" vec3 aLight = normalize (occLight_Position (theId).xyz);"
279 EOL" if (!occLight_IsHeadlight (theId))"
281 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
284 EOL" vec3 aHalf = normalize (aLight + theView);"
286 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
287 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
288 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
290 EOL" float aSpecl = 0.0;"
291 EOL" if (aNdotL > 0.0)"
293 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
296 EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL;"
297 EOL" Specular += occLight_Specular (theId).rgb * aSpecl;"
300 //! Function computes contribution of directional light source
301 const char THE_FUNC_PBR_directionalLight[] =
302 EOL"void directionalLight (in int theId,"
303 EOL" in vec3 theNormal,"
304 EOL" in vec3 theView,"
305 EOL" in bool theIsFront)"
307 EOL" vec3 aLight = normalize (occLight_Position (theId).xyz);"
308 EOL" if (occLight_IsHeadlight (theId))"
310 EOL" aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 0.0));"
313 EOL" theNormal = theIsFront ? theNormal : -theNormal;"
314 EOL" DirectLighting += occPBRIllumination (theView,"
321 EOL" occLight_Specular(theId).rgb,"
322 EOL" occLight_Intensity(theId));"
325 //! The same as THE_FUNC_directionalLight but for the light with zero index
326 //! (avoids limitations on some mobile devices).
327 const char THE_FUNC_directionalLightFirst[] =
328 EOL"void directionalLightFirst (in vec3 theNormal,"
329 EOL" in vec3 theView,"
330 EOL" in bool theIsFront)"
332 EOL" vec3 aLight = normalize (occLightSources[1].xyz);"
333 EOL" if (!occLight_IsHeadlight (0))"
335 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
338 EOL" vec3 aHalf = normalize (aLight + theView);"
340 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
341 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
342 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
344 EOL" float aSpecl = 0.0;"
345 EOL" if (aNdotL > 0.0)"
347 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
350 EOL" Diffuse += occLightSources[0].rgb * aNdotL;"
351 EOL" Specular += occLightSources[0].rgb * aSpecl;"
354 //! Returns the real cubemap fetching direction considering sides orientation, memory layout and vertical flip.
355 const char THE_FUNC_cubemap_vector_transform[] =
356 EOL"vec3 cubemapVectorTransform (in vec3 theVector,"
357 EOL" in int theYCoeff,"
358 EOL" in int theZCoeff)"
360 EOL" theVector = theVector.yzx;"
361 EOL" theVector.y *= float(theYCoeff);"
362 EOL" theVector.z *= float(theZCoeff);"
363 EOL" return theVector;"
366 //! Process clipping planes in Fragment Shader.
367 //! Should be added at the beginning of the main() function.
368 const char THE_FRAG_CLIP_PLANES_N[] =
369 EOL" for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount; ++aPlaneIter)"
371 EOL" vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
372 EOL" if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
378 //! Process chains of clipping planes in Fragment Shader.
379 const char THE_FRAG_CLIP_CHAINS_N[] =
380 EOL" for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount;)"
382 EOL" vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
383 EOL" if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
385 EOL" if (occClipPlaneChains[aPlaneIter] == 1)"
389 EOL" aPlaneIter += 1;"
393 EOL" aPlaneIter += occClipPlaneChains[aPlaneIter];"
397 //! Process 1 clipping plane in Fragment Shader.
398 const char THE_FRAG_CLIP_PLANES_1[] =
399 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
400 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0)"
405 //! Process 2 clipping planes in Fragment Shader.
406 const char THE_FRAG_CLIP_PLANES_2[] =
407 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
408 EOL" vec4 aClipEquation1 = occClipPlaneEquations[1];"
409 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
410 EOL" || dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
415 //! Process a chain of 2 clipping planes in Fragment Shader (3/4 section).
416 const char THE_FRAG_CLIP_CHAINS_2[] =
417 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
418 EOL" vec4 aClipEquation1 = occClipPlaneEquations[1];"
419 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
420 EOL" && dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
425 //! Modify color for Wireframe presentation.
426 const char THE_FRAG_WIREFRAME_COLOR[] =
427 EOL"vec4 getFinalColor(void)"
429 EOL" float aDistance = min (min (EdgeDistance[0], EdgeDistance[1]), EdgeDistance[2]);"
430 EOL" bool isHollow = occWireframeColor.a < 0.0;"
431 EOL" float aMixVal = smoothstep (occLineWidth - occLineFeather * 0.5, occLineWidth + occLineFeather * 0.5, aDistance);"
432 EOL" vec4 aMixColor = isHollow"
433 EOL" ? vec4 (getColor().rgb, 1.0 - aMixVal)" // edges only (of interior color)
434 EOL" : mix (occWireframeColor, getColor(), aMixVal);" // interior + edges
435 EOL" return aMixColor;"
438 //! Compute gl_Position vertex shader output.
439 const char THE_VERT_gl_Position[] =
440 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;";
442 //! Displace gl_Position alongside vertex normal for outline rendering.
443 //! This code adds silhouette only for smooth surfaces of closed primitive, and produces visual artifacts on sharp edges.
444 const char THE_VERT_gl_Position_OUTLINE[] =
445 EOL" float anOutlineDisp = occOrthoScale > 0.0 ? occOrthoScale : gl_Position.w;"
446 EOL" vec4 anOutlinePos = occVertex + vec4 (occNormal * (occSilhouetteThickness * anOutlineDisp), 0.0);"
447 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * anOutlinePos;";
449 #if !defined(GL_ES_VERSION_2_0)
451 static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
452 static const GLfloat THE_DEFAULT_SPOT_DIR[3] = { 0.0f, 0.0f, -1.0f };
453 static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
454 static const GLfloat THE_DEFAULT_SPOT_CUTOFF = 180.0f;
456 //! Bind FFP light source.
457 static void bindLight (const Graphic3d_CLight& theLight,
458 const GLenum theLightGlId,
459 const OpenGl_Mat4& theModelView,
460 OpenGl_Context* theCtx)
462 // the light is a headlight?
463 if (theLight.IsHeadlight())
465 theCtx->core11->glMatrixMode (GL_MODELVIEW);
466 theCtx->core11->glLoadIdentity();
470 const Graphic3d_Vec4& aLightColor = theLight.PackedColor();
471 switch (theLight.Type())
473 case Graphic3d_TOLS_AMBIENT : break; // handled by separate if-clause at beginning of method
474 case Graphic3d_TOLS_DIRECTIONAL:
476 // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
477 const OpenGl_Vec4 anInfDir = -theLight.PackedDirection();
479 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
480 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
481 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
482 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
483 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, anInfDir.GetData());
484 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
485 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
486 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
489 case Graphic3d_TOLS_POSITIONAL:
491 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
492 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
493 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
494 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
495 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
496 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
497 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
498 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
499 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
500 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
501 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
502 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0);
505 case Graphic3d_TOLS_SPOT:
507 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
508 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
509 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
510 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
511 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
512 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, theLight.PackedDirection().GetData());
513 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, theLight.Concentration() * 128.0f);
514 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, (theLight.Angle() * 180.0f) / GLfloat(M_PI));
515 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
516 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
517 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
522 // restore matrix in case of headlight
523 if (theLight.IsHeadlight())
525 theCtx->core11->glLoadMatrixf (theModelView.GetData());
528 glEnable (theLightGlId);
532 //! Generate map key for light sources configuration.
533 static TCollection_AsciiString genLightKey (const Handle(Graphic3d_LightSet)& theLights)
535 if (theLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
537 return TCollection_AsciiString ("l_") + theLights->KeyEnabledLong();
540 const Standard_Integer aMaxLimit = roundUpMaxLightSources (theLights->NbEnabled());
541 return TCollection_AsciiString ("l_") + theLights->KeyEnabledShort() + aMaxLimit;
545 // =======================================================================
546 // function : OpenGl_ShaderManager
547 // purpose : Creates new empty shader manager
548 // =======================================================================
549 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
550 : myFfpProgram (new OpenGl_ShaderProgramFFP()),
551 myShadingModel (Graphic3d_TOSM_VERTEX),
552 myUnlitPrograms (new OpenGl_SetOfPrograms()),
553 myContext (theContext),
554 mySRgbState (theContext->ToRenderSRGB()),
555 myHasLocalOrigin (Standard_False),
561 // =======================================================================
562 // function : ~OpenGl_ShaderManager
563 // purpose : Releases resources of shader manager
564 // =======================================================================
565 OpenGl_ShaderManager::~OpenGl_ShaderManager()
567 myProgramList.Clear();
568 if (!myPBREnvironment.IsNull())
570 myPBREnvironment->Release (myContext);
574 // =======================================================================
577 // =======================================================================
578 void OpenGl_ShaderManager::clear()
580 myProgramList.Clear();
581 myLightPrograms.Nullify();
582 myUnlitPrograms = new OpenGl_SetOfPrograms();
583 myOutlinePrograms.Nullify();
584 myMapOfLightPrograms.Clear();
585 myFontProgram.Nullify();
586 myBlitPrograms[0].Init (Handle(OpenGl_ShaderProgram)());
587 myBlitPrograms[1].Init (Handle(OpenGl_ShaderProgram)());
588 myBoundBoxProgram.Nullify();
589 myBoundBoxVertBuffer.Nullify();
590 for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
592 myStereoPrograms[aModeIter].Nullify();
594 switchLightPrograms();
597 // =======================================================================
599 // purpose : Creates new shader program
600 // =======================================================================
601 Standard_Boolean OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
602 TCollection_AsciiString& theShareKey,
603 Handle(OpenGl_ShaderProgram)& theProgram)
605 theProgram.Nullify();
606 if (theProxy.IsNull())
608 return Standard_False;
611 theShareKey = theProxy->GetId();
612 if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
614 if (theProgram->Share())
616 myProgramList.Append (theProgram);
618 return Standard_True;
621 theProgram = new OpenGl_ShaderProgram (theProxy);
622 if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
624 theProgram->Release (myContext);
626 theProgram.Nullify();
627 return Standard_False;
630 myProgramList.Append (theProgram);
631 myContext->ShareResource (theShareKey, theProgram);
632 return Standard_True;
635 // =======================================================================
636 // function : Unregister
637 // purpose : Removes specified shader program from the manager
638 // =======================================================================
639 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString& theShareKey,
640 Handle(OpenGl_ShaderProgram)& theProgram)
642 for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
644 if (anIt.Value() == theProgram)
646 if (!theProgram->UnShare())
649 theProgram.Nullify();
653 myProgramList.Remove (anIt);
658 const TCollection_AsciiString anID = theProgram->myProxy->GetId();
661 myContext->DelayedRelease (theProgram);
662 theProgram.Nullify();
666 theProgram.Nullify();
667 myContext->ReleaseResource (anID, Standard_True);
671 // =======================================================================
672 // function : ShaderPrograms
673 // purpose : Returns list of registered shader programs
674 // =======================================================================
675 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
677 return myProgramList;
680 // =======================================================================
682 // purpose : Returns true if no program objects are attached
683 // =======================================================================
684 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
686 return myProgramList.IsEmpty();
689 // =======================================================================
690 // function : switchLightPrograms
692 // =======================================================================
693 void OpenGl_ShaderManager::switchLightPrograms()
695 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
696 if (aLights.IsNull())
698 if (!myMapOfLightPrograms.Find ("unlit", myLightPrograms))
700 myLightPrograms = new OpenGl_SetOfShaderPrograms (myUnlitPrograms);
701 myMapOfLightPrograms.Bind ("unlit", myLightPrograms);
706 const TCollection_AsciiString aKey = genLightKey (aLights);
707 if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
709 myLightPrograms = new OpenGl_SetOfShaderPrograms();
710 myMapOfLightPrograms.Bind (aKey, myLightPrograms);
714 // =======================================================================
715 // function : UpdateSRgbState
717 // =======================================================================
718 void OpenGl_ShaderManager::UpdateSRgbState()
720 if (mySRgbState == myContext->ToRenderSRGB())
725 mySRgbState = myContext->ToRenderSRGB();
727 // special cases - GLSL programs dealing with sRGB/linearRGB internally
728 myStereoPrograms[Graphic3d_StereoMode_Anaglyph].Nullify();
731 // =======================================================================
732 // function : UpdateLightSourceStateTo
733 // purpose : Updates state of OCCT light sources
734 // =======================================================================
735 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights,
736 Standard_Integer theSpecIBLMapLevels)
738 myLightSourceState.Set (theLights);
739 myLightSourceState.SetSpecIBLMapLevels (theSpecIBLMapLevels);
740 myLightSourceState.Update();
741 switchLightPrograms();
744 // =======================================================================
745 // function : UpdateLightSourceState
747 // =======================================================================
748 void OpenGl_ShaderManager::UpdateLightSourceState()
750 myLightSourceState.Update();
753 // =======================================================================
754 // function : SetShadingModel
756 // =======================================================================
757 void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
759 if (theModel == Graphic3d_TOSM_DEFAULT)
761 throw Standard_ProgramError ("OpenGl_ShaderManager::SetShadingModel() - attempt to set invalid Shading Model!");
764 myShadingModel = theModel;
765 switchLightPrograms();
768 // =======================================================================
769 // function : SetProjectionState
770 // purpose : Sets new state of OCCT projection transform
771 // =======================================================================
772 void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
774 myProjectionState.Set (theProjectionMatrix);
775 myProjectionState.Update();
778 // =======================================================================
779 // function : SetModelWorldState
780 // purpose : Sets new state of OCCT model-world transform
781 // =======================================================================
782 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
784 myModelWorldState.Set (theModelWorldMatrix);
785 myModelWorldState.Update();
788 // =======================================================================
789 // function : SetWorldViewState
790 // purpose : Sets new state of OCCT world-view transform
791 // =======================================================================
792 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
794 myWorldViewState.Set (theWorldViewMatrix);
795 myWorldViewState.Update();
798 // =======================================================================
799 // function : pushLightSourceState
801 // =======================================================================
802 void OpenGl_ShaderManager::pushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
804 theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
805 if (theProgram == myFfpProgram)
807 #if !defined(GL_ES_VERSION_2_0)
808 if (myContext->core11 == NULL)
813 GLenum aLightGlId = GL_LIGHT0;
814 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
815 for (Graphic3d_LightSet::Iterator aLightIt (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
816 aLightIt.More(); aLightIt.Next())
818 if (aLightGlId > GL_LIGHT7) // only 8 lights in FFP...
820 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
821 "Warning: light sources limit (8) has been exceeded within Fixed-function pipeline.");
825 bindLight (*aLightIt.Value(), aLightGlId, aModelView, myContext);
829 // apply accumulated ambient color
830 const Graphic3d_Vec4 anAmbient = !myLightSourceState.LightSources().IsNull()
831 ? myLightSourceState.LightSources()->AmbientColor()
832 : Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
833 myContext->core11->glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbient.GetData());
835 // GL_LIGHTING is managed by drawers to switch between shaded / no lighting output,
836 // therefore managing the state here does not have any effect - do it just for consistency.
837 if (aLightGlId != GL_LIGHT0)
839 ::glEnable (GL_LIGHTING);
843 ::glDisable (GL_LIGHTING);
845 // switch off unused lights
846 for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
848 ::glDisable (aLightGlId);
854 const Standard_Integer aNbLightsMax = theProgram->NbLightsMax();
855 const GLint anAmbientLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT);
856 if (aNbLightsMax == 0
857 && anAmbientLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
862 if (myLightTypeArray.Size() < aNbLightsMax)
864 myLightTypeArray .Resize (0, aNbLightsMax - 1, false);
865 myLightParamsArray.Resize (0, aNbLightsMax - 1, false);
867 for (Standard_Integer aLightIt = 0; aLightIt < aNbLightsMax; ++aLightIt)
869 myLightTypeArray.ChangeValue (aLightIt).Type = -1;
872 if (myLightSourceState.LightSources().IsNull()
873 || myLightSourceState.LightSources()->IsEmpty())
875 theProgram->SetUniform (myContext,
876 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
878 theProgram->SetUniform (myContext,
880 OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
881 theProgram->SetUniform (myContext,
882 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
883 aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
884 myLightTypeArray.First().Packed());
888 Standard_Integer aLightsNb = 0;
889 for (Graphic3d_LightSet::Iterator anIter (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
890 anIter.More(); anIter.Next())
892 const Graphic3d_CLight& aLight = *anIter.Value();
893 if (aLightsNb >= aNbLightsMax)
895 if (aNbLightsMax != 0)
897 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
898 TCollection_AsciiString("Warning: light sources limit (") + aNbLightsMax + ") has been exceeded.");
903 OpenGl_ShaderLightType& aLightType = myLightTypeArray.ChangeValue (aLightsNb);
904 OpenGl_ShaderLightParameters& aLightParams = myLightParamsArray.ChangeValue (aLightsNb);
905 if (!aLight.IsEnabled()) // has no affect with Graphic3d_LightSet::IterationFilter_ExcludeDisabled - here just for consistency
907 // if it is desired to keep disabled light in the same order - we can replace it with a black light so that it will have no influence on result
908 aLightType.Type = -1; // Graphic3d_TOLS_AMBIENT can be used instead
909 aLightType.IsHeadlight = false;
910 aLightParams.Color = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f);
915 // ignoring OpenGl_Context::ToRenderSRGB() for light colors,
916 // as non-absolute colors for lights are rare and require tuning anyway
917 aLightType.Type = aLight.Type();
918 aLightType.IsHeadlight = aLight.IsHeadlight();
919 aLightParams.Color = aLight.PackedColor();
920 aLightParams.Color.a() = aLight.Intensity(); // used by PBR and ignored by old shading model
921 if (aLight.Type() == Graphic3d_TOLS_DIRECTIONAL)
923 aLightParams.Position = -aLight.PackedDirection();
925 else if (!aLight.IsHeadlight())
927 aLightParams.Position.x() = static_cast<float>(aLight.Position().X() - myLocalOrigin.X());
928 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y() - myLocalOrigin.Y());
929 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z() - myLocalOrigin.Z());
930 aLightParams.Position.w() = 1.0f;
934 aLightParams.Position.x() = static_cast<float>(aLight.Position().X());
935 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y());
936 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z());
937 aLightParams.Position.w() = 1.0f;
940 if (aLight.Type() == Graphic3d_TOLS_SPOT)
942 aLightParams.Direction = aLight.PackedDirection();
944 aLightParams.Parameters = aLight.PackedParams();
948 const Graphic3d_Vec4& anAmbient = myLightSourceState.LightSources()->AmbientColor();
949 theProgram->SetUniform (myContext,
950 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
952 theProgram->SetUniform (myContext,
955 theProgram->SetUniform (myContext,
956 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
957 aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
958 myLightTypeArray.First().Packed());
961 theProgram->SetUniform (myContext,
962 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
963 aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
964 myLightParamsArray.First().Packed());
967 if (const OpenGl_ShaderUniformLocation aLocation = theProgram->GetStateLocation (OpenGl_OCCT_NB_SPEC_IBL_LEVELS))
969 theProgram->SetUniform (myContext, aLocation, myLightSourceState.SpecIBLMapLevels());
973 // =======================================================================
974 // function : pushProjectionState
976 // =======================================================================
977 void OpenGl_ShaderManager::pushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
979 theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
980 if (theProgram == myFfpProgram)
982 #if !defined(GL_ES_VERSION_2_0)
983 if (myContext->core11 != NULL)
985 myContext->core11->glMatrixMode (GL_PROJECTION);
986 myContext->core11->glLoadMatrixf (myProjectionState.ProjectionMatrix());
992 theProgram->SetUniform (myContext,
993 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
994 myProjectionState.ProjectionMatrix());
996 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
997 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
999 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
1002 theProgram->SetUniform (myContext,
1003 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
1004 myProjectionState.ProjectionMatrix(), true);
1006 aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
1007 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1009 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
1013 // =======================================================================
1014 // function : pushModelWorldState
1016 // =======================================================================
1017 void OpenGl_ShaderManager::pushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1019 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1020 if (theProgram == myFfpProgram)
1022 #if !defined(GL_ES_VERSION_2_0)
1023 if (myContext->core11 != NULL)
1025 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1026 myContext->core11->glMatrixMode (GL_MODELVIEW);
1027 myContext->core11->glLoadMatrixf (aModelView.GetData());
1028 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1034 theProgram->SetUniform (myContext,
1035 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
1036 myModelWorldState.ModelWorldMatrix());
1038 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
1039 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1041 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
1044 theProgram->SetUniform (myContext,
1045 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
1046 myModelWorldState.ModelWorldMatrix(), true);
1048 aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
1049 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1051 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
1055 // =======================================================================
1056 // function : pushWorldViewState
1058 // =======================================================================
1059 void OpenGl_ShaderManager::pushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1061 if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
1066 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1067 if (theProgram == myFfpProgram)
1069 #if !defined(GL_ES_VERSION_2_0)
1070 if (myContext->core11 != NULL)
1072 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1073 myContext->core11->glMatrixMode (GL_MODELVIEW);
1074 myContext->core11->glLoadMatrixf (aModelView.GetData());
1075 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1081 theProgram->SetUniform (myContext,
1082 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
1083 myWorldViewState.WorldViewMatrix());
1085 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
1086 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1088 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
1091 theProgram->SetUniform (myContext,
1092 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
1093 myWorldViewState.WorldViewMatrix(), true);
1095 aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
1096 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1098 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
1102 // =======================================================================
1103 // function : UpdateClippingState
1104 // purpose : Updates state of OCCT clipping planes
1105 // =======================================================================
1106 void OpenGl_ShaderManager::UpdateClippingState()
1108 myClippingState.Update();
1111 // =======================================================================
1112 // function : RevertClippingState
1113 // purpose : Reverts state of OCCT clipping planes
1114 // =======================================================================
1115 void OpenGl_ShaderManager::RevertClippingState()
1117 myClippingState.Revert();
1120 // =======================================================================
1121 // function : pushClippingState
1123 // =======================================================================
1124 void OpenGl_ShaderManager::pushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1126 theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
1127 if (theProgram == myFfpProgram)
1129 #if !defined(GL_ES_VERSION_2_0)
1130 if (myContext->core11 == NULL)
1135 const Standard_Integer aNbMaxPlanes = myContext->MaxClipPlanes();
1136 if (myClipPlaneArrayFfp.Size() < aNbMaxPlanes)
1138 myClipPlaneArrayFfp.Resize (0, aNbMaxPlanes - 1, false);
1141 Standard_Integer aPlaneId = 0;
1142 Standard_Boolean toRestoreModelView = Standard_False;
1143 const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1144 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1146 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1147 if (aPlaneIter.IsDisabled()
1148 || aPlane->IsChain()
1149 || (aPlane == aCappedChain
1150 && myContext->Clipping().IsCappingEnableAllExcept()))
1154 else if (aPlaneId >= aNbMaxPlanes)
1156 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
1157 TCollection_ExtendedString("Warning: clipping planes limit (") + aNbMaxPlanes + ") has been exceeded.");
1161 const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
1162 OpenGl_Vec4d& aPlaneEq = myClipPlaneArrayFfp.ChangeValue (aPlaneId);
1163 aPlaneEq.x() = anEquation.x();
1164 aPlaneEq.y() = anEquation.y();
1165 aPlaneEq.z() = anEquation.z();
1166 aPlaneEq.w() = anEquation.w();
1167 if (myHasLocalOrigin)
1169 const gp_XYZ aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
1170 const Standard_Real aD = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
1174 const GLenum anFfpPlaneID = GL_CLIP_PLANE0 + aPlaneId;
1175 if (anFfpPlaneID == GL_CLIP_PLANE0)
1177 // set either identity or pure view matrix
1178 toRestoreModelView = Standard_True;
1179 myContext->core11->glMatrixMode (GL_MODELVIEW);
1180 myContext->core11->glLoadMatrixf (myWorldViewState.WorldViewMatrix().GetData());
1183 ::glEnable (anFfpPlaneID);
1184 myContext->core11->glClipPlane (anFfpPlaneID, aPlaneEq);
1189 // switch off unused lights
1190 for (; aPlaneId < aNbMaxPlanes; ++aPlaneId)
1192 ::glDisable (GL_CLIP_PLANE0 + aPlaneId);
1195 // restore combined model-view matrix
1196 if (toRestoreModelView)
1198 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1199 myContext->core11->glLoadMatrixf (aModelView.GetData());
1205 const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
1206 if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION)
1211 const Standard_Integer aNbClipPlanesMax = theProgram->NbClipPlanesMax();
1212 const Standard_Integer aNbPlanes = Min (myContext->Clipping().NbClippingOrCappingOn(), aNbClipPlanesMax);
1215 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), 0);
1219 if (myClipPlaneArray.Size() < aNbClipPlanesMax)
1221 myClipPlaneArray.Resize (0, aNbClipPlanesMax - 1, false);
1222 myClipChainArray.Resize (0, aNbClipPlanesMax - 1, false);
1225 Standard_Integer aPlaneId = 0;
1226 const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1227 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1229 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1230 if (aPlaneIter.IsDisabled())
1235 if (myContext->Clipping().IsCappingDisableAllExcept())
1237 // enable only specific (sub) plane
1238 if (aPlane != aCappedChain)
1243 Standard_Integer aSubPlaneIndex = 1;
1244 for (const Graphic3d_ClipPlane* aSubPlaneIter = aCappedChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1246 if (aSubPlaneIndex == myContext->Clipping().CappedSubPlane())
1248 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), 1);
1254 else if (aPlane == aCappedChain) // && myContext->Clipping().IsCappingEnableAllExcept()
1256 // enable sub-planes within processed Chain as reversed and ORed, excluding filtered plane
1257 if (aPlaneId + aPlane->NbChainNextPlanes() - 1 > aNbClipPlanesMax)
1259 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1260 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1264 Standard_Integer aSubPlaneIndex = 1;
1265 for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1267 if (aSubPlaneIndex != -myContext->Clipping().CappedSubPlane())
1269 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->ReversedEquation(), 1);
1276 if (aPlaneId + aPlane->NbChainNextPlanes() > aNbClipPlanesMax)
1278 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1279 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1282 for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get())
1284 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), aSubPlaneIter->NbChainNextPlanes());
1289 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), aPlaneId);
1290 theProgram->SetUniform (myContext, aLocEquations, aNbClipPlanesMax, &myClipPlaneArray.First());
1291 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_CHAINS), aNbClipPlanesMax, &myClipChainArray.First());
1294 // =======================================================================
1295 // function : pushMaterialState
1297 // =======================================================================
1298 void OpenGl_ShaderManager::pushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1300 const OpenGl_Material& aFrontMat = myMaterialState.FrontMaterial();
1301 const OpenGl_Material& aBackMat = myMaterialState.BackMaterial();
1302 theProgram->UpdateState (OpenGl_MATERIAL_STATE, myMaterialState.Index());
1303 if (theProgram == myFfpProgram)
1305 #if !defined(GL_ES_VERSION_2_0)
1306 if (myContext->core11 == NULL)
1311 if (myMaterialState.AlphaCutoff() < ShortRealLast())
1313 glAlphaFunc (GL_GEQUAL, myMaterialState.AlphaCutoff());
1314 glEnable (GL_ALPHA_TEST);
1318 glDisable (GL_ALPHA_TEST);
1321 const GLenum aFrontFace = myMaterialState.ToDistinguish() ? GL_FRONT : GL_FRONT_AND_BACK;
1322 myContext->core11->glMaterialfv(aFrontFace, GL_AMBIENT, aFrontMat.Common.Ambient.GetData());
1323 myContext->core11->glMaterialfv(aFrontFace, GL_DIFFUSE, aFrontMat.Common.Diffuse.GetData());
1324 myContext->core11->glMaterialfv(aFrontFace, GL_SPECULAR, aFrontMat.Common.Specular.GetData());
1325 myContext->core11->glMaterialfv(aFrontFace, GL_EMISSION, aFrontMat.Common.Emission.GetData());
1326 myContext->core11->glMaterialf (aFrontFace, GL_SHININESS, aFrontMat.Common.Shine());
1327 if (myMaterialState.ToDistinguish())
1329 myContext->core11->glMaterialfv(GL_BACK, GL_AMBIENT, aBackMat.Common.Ambient.GetData());
1330 myContext->core11->glMaterialfv(GL_BACK, GL_DIFFUSE, aBackMat.Common.Diffuse.GetData());
1331 myContext->core11->glMaterialfv(GL_BACK, GL_SPECULAR, aBackMat.Common.Specular.GetData());
1332 myContext->core11->glMaterialfv(GL_BACK, GL_EMISSION, aBackMat.Common.Emission.GetData());
1333 myContext->core11->glMaterialf (GL_BACK, GL_SHININESS, aBackMat.Common.Shine());
1339 theProgram->SetUniform (myContext,
1340 theProgram->GetStateLocation (OpenGl_OCCT_ALPHA_CUTOFF),
1341 myMaterialState.AlphaCutoff());
1342 theProgram->SetUniform (myContext,
1343 theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
1344 myMaterialState.ToMapTexture() ? 1 : 0);
1345 theProgram->SetUniform (myContext,
1346 theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
1347 myMaterialState.ToDistinguish() ? 1 : 0);
1349 if (const OpenGl_ShaderUniformLocation& aLocPbrFront = theProgram->GetStateLocation (OpenGl_OCCT_PBR_FRONT_MATERIAL))
1351 theProgram->SetUniform (myContext, aLocPbrFront, OpenGl_MaterialPBR::NbOfVec4(),
1352 aFrontMat.Pbr.Packed());
1354 if (const OpenGl_ShaderUniformLocation aLocPbrBack = theProgram->GetStateLocation (OpenGl_OCCT_PBR_BACK_MATERIAL))
1356 theProgram->SetUniform (myContext, aLocPbrBack, OpenGl_MaterialPBR::NbOfVec4(),
1357 aBackMat.Pbr.Packed());
1359 if (const OpenGl_ShaderUniformLocation aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_FRONT_MATERIAL))
1361 theProgram->SetUniform (myContext, aLocFront, OpenGl_MaterialCommon::NbOfVec4(),
1362 aFrontMat.Common.Packed());
1364 if (const OpenGl_ShaderUniformLocation aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_BACK_MATERIAL))
1366 theProgram->SetUniform (myContext, aLocBack, OpenGl_MaterialCommon::NbOfVec4(),
1367 aBackMat.Common.Packed());
1371 // =======================================================================
1372 // function : pushOitState
1374 // =======================================================================
1375 void OpenGl_ShaderManager::pushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1377 const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
1378 if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
1380 theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
1383 const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
1384 if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
1386 theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
1390 // =======================================================================
1391 // function : PushInteriorState
1393 // =======================================================================
1394 void OpenGl_ShaderManager::PushInteriorState (const Handle(OpenGl_ShaderProgram)& theProgram,
1395 const Handle(Graphic3d_Aspects)& theAspect) const
1397 if (theProgram.IsNull()
1398 || !theProgram->IsValid())
1403 if (const OpenGl_ShaderUniformLocation aLocLineWidth = theProgram->GetStateLocation (OpenGl_OCCT_LINE_WIDTH))
1405 theProgram->SetUniform (myContext, aLocLineWidth, theAspect->EdgeWidth() * myContext->LineWidthScale());
1406 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCCT_LINE_FEATHER), myContext->LineFeather() * myContext->LineWidthScale());
1408 if (const OpenGl_ShaderUniformLocation aLocWireframeColor = theProgram->GetStateLocation (OpenGl_OCCT_WIREFRAME_COLOR))
1410 if (theAspect->InteriorStyle() == Aspect_IS_HOLLOW)
1412 theProgram->SetUniform (myContext, aLocWireframeColor, OpenGl_Vec4 (-1.0f, -1.0f, -1.0f, -1.0f));
1416 theProgram->SetUniform (myContext, aLocWireframeColor, myContext->Vec4FromQuantityColor (theAspect->EdgeColorRGBA()));
1419 if (const OpenGl_ShaderUniformLocation aLocQuadModeState = theProgram->GetStateLocation (OpenGl_OCCT_QUAD_MODE_STATE))
1421 theProgram->SetUniform (myContext, aLocQuadModeState, theAspect->ToSkipFirstEdge() ? 1 : 0);
1425 // =======================================================================
1426 // function : PushState
1427 // purpose : Pushes state of OCCT graphics parameters to the program
1428 // =======================================================================
1429 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1431 const Handle(OpenGl_ShaderProgram)& aProgram = !theProgram.IsNull() ? theProgram : myFfpProgram;
1432 PushClippingState (aProgram);
1433 PushWorldViewState (aProgram);
1434 PushModelWorldState (aProgram);
1435 PushProjectionState (aProgram);
1436 PushLightSourceState (aProgram);
1437 PushMaterialState (aProgram);
1438 PushOitState (aProgram);
1440 if (!theProgram.IsNull())
1442 if (const OpenGl_ShaderUniformLocation& aLocViewPort = theProgram->GetStateLocation (OpenGl_OCCT_VIEWPORT))
1444 theProgram->SetUniform (myContext, aLocViewPort, OpenGl_Vec4 ((float )myContext->Viewport()[0], (float )myContext->Viewport()[1],
1445 (float )myContext->Viewport()[2], (float )myContext->Viewport()[3]));
1450 // =======================================================================
1451 // function : prepareStdProgramFont
1453 // =======================================================================
1454 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
1456 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1457 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
1458 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1460 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
1463 EOL" TexCoord = occTexCoord.st;"
1464 + THE_VERT_gl_Position
1467 TCollection_AsciiString
1468 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
1469 #if !defined(GL_ES_VERSION_2_0)
1470 if (myContext->core11 == NULL)
1472 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
1476 TCollection_AsciiString aSrcFrag =
1480 EOL" vec4 aColor = occColor;"
1481 EOL" aColor.a *= getAlpha();"
1482 EOL" if (aColor.a <= 0.285) discard;"
1483 EOL" occSetFragColor (aColor);"
1486 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1487 defaultGlslVersion (aProgramSrc, "font", 0);
1488 aProgramSrc->SetDefaultSampler (false);
1489 aProgramSrc->SetNbLightsMax (0);
1490 aProgramSrc->SetNbClipPlanesMax (0);
1491 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1492 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1493 TCollection_AsciiString aKey;
1494 if (!Create (aProgramSrc, aKey, myFontProgram))
1496 myFontProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1497 return Standard_False;
1499 return Standard_True;
1502 // =======================================================================
1503 // function : BindFboBlitProgram
1505 // =======================================================================
1506 Standard_Boolean OpenGl_ShaderManager::BindFboBlitProgram (Standard_Integer theNbSamples,
1507 Standard_Boolean theIsFallback_sRGB)
1509 NCollection_Array1<Handle(OpenGl_ShaderProgram)>& aList = myBlitPrograms[theIsFallback_sRGB ? 1 : 0];
1510 Standard_Integer aNbSamples = Max (theNbSamples, 1);
1511 if (aNbSamples > aList.Upper())
1513 aList.Resize (1, aNbSamples, true);
1516 Handle(OpenGl_ShaderProgram)& aProg = aList[aNbSamples];
1519 prepareStdProgramFboBlit (aProg, aNbSamples, theIsFallback_sRGB);
1521 return !aProg.IsNull()
1522 && myContext->BindProgram (aProg);
1525 // =======================================================================
1526 // function : prepareStdProgramFboBlit
1528 // =======================================================================
1529 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit (Handle(OpenGl_ShaderProgram)& theProgram,
1530 Standard_Integer theNbSamples,
1531 Standard_Boolean theIsFallback_sRGB)
1533 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1534 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1536 TCollection_AsciiString aSrcVert =
1539 EOL" TexCoord = occVertex.zw;"
1540 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
1543 TCollection_AsciiString aSrcFrag;
1544 if (theNbSamples > 1)
1546 #if defined(GL_ES_VERSION_2_0)
1547 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1548 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1550 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1551 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1553 aSrcFrag = TCollection_AsciiString()
1554 + EOL"#define THE_NUM_SAMPLES " + theNbSamples
1555 + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1558 EOL" ivec2 aSize = textureSize (uColorSampler);"
1559 EOL" ivec2 anUV = ivec2 (vec2 (aSize) * TexCoord);"
1560 EOL" gl_FragDepth = texelFetch (uDepthSampler, anUV, THE_NUM_SAMPLES / 2 - 1).r;"
1562 EOL" vec4 aColor = vec4 (0.0);"
1563 EOL" for (int aSample = 0; aSample < THE_NUM_SAMPLES; ++aSample)"
1565 EOL" vec4 aVal = texelFetch (uColorSampler, anUV, aSample);"
1566 EOL" aColor += aVal;"
1568 EOL" aColor /= float(THE_NUM_SAMPLES);"
1569 EOL"#ifdef THE_SHIFT_sRGB"
1570 EOL" aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1572 EOL" occSetFragColor (aColor);"
1577 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uColorSampler", Graphic3d_TOS_FRAGMENT));
1578 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uDepthSampler", Graphic3d_TOS_FRAGMENT));
1579 aSrcFrag = TCollection_AsciiString()
1580 + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1583 EOL" gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
1584 EOL" vec4 aColor = occTexture2D (uColorSampler, TexCoord);"
1585 EOL"#ifdef THE_SHIFT_sRGB"
1586 EOL" aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1588 EOL" occSetFragColor (aColor);"
1592 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1593 #if defined(GL_ES_VERSION_2_0)
1594 if (myContext->IsGlGreaterEqual (3, 1))
1596 // required for MSAA sampler
1597 aProgramSrc->SetHeader ("#version 310 es");
1599 else if (myContext->IsGlGreaterEqual (3, 0))
1601 aProgramSrc->SetHeader ("#version 300 es");
1603 else if (myContext->extFragDepth)
1605 aProgramSrc->SetHeader ("#extension GL_EXT_frag_depth : enable"
1606 EOL"#define gl_FragDepth gl_FragDepthEXT");
1610 // there is no way to draw into depth buffer
1614 EOL" occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
1618 if (myContext->core32 != NULL)
1620 aProgramSrc->SetHeader ("#version 150");
1623 TCollection_AsciiString anId = "occt_blit";
1624 if (theNbSamples > 1)
1626 anId += TCollection_AsciiString ("_msaa") + theNbSamples;
1628 if (theIsFallback_sRGB)
1632 aProgramSrc->SetId (anId);
1633 aProgramSrc->SetDefaultSampler (false);
1634 aProgramSrc->SetNbLightsMax (0);
1635 aProgramSrc->SetNbClipPlanesMax (0);
1636 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1637 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1638 TCollection_AsciiString aKey;
1639 if (!Create (aProgramSrc, aKey, theProgram))
1641 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1642 return Standard_False;
1645 myContext->BindProgram (theProgram);
1646 theProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
1647 theProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
1648 myContext->BindProgram (NULL);
1649 return Standard_True;
1652 // =======================================================================
1653 // function : prepareStdProgramOitCompositing
1655 // =======================================================================
1656 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
1658 Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
1659 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1660 TCollection_AsciiString aSrcVert, aSrcFrag;
1662 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1663 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1668 EOL" TexCoord = occVertex.zw;"
1669 EOL" gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
1674 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uAccumTexture", Graphic3d_TOS_FRAGMENT));
1675 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uWeightTexture", Graphic3d_TOS_FRAGMENT));
1679 EOL" vec4 aAccum = occTexture2D (uAccumTexture, TexCoord);"
1680 EOL" float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
1681 EOL" occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1683 #if !defined(GL_ES_VERSION_2_0)
1684 if (myContext->IsGlGreaterEqual (3, 2))
1686 aProgramSrc->SetHeader ("#version 150");
1689 if (myContext->IsGlGreaterEqual (3, 0))
1691 aProgramSrc->SetHeader ("#version 300 es");
1697 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uAccumTexture", Graphic3d_TOS_FRAGMENT));
1698 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uWeightTexture", Graphic3d_TOS_FRAGMENT));
1702 EOL" ivec2 aTexel = ivec2 (vec2 (textureSize (uAccumTexture)) * TexCoord);"
1703 EOL" vec4 aAccum = texelFetch (uAccumTexture, aTexel, gl_SampleID);"
1704 EOL" float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
1705 EOL" occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1707 #if !defined(GL_ES_VERSION_2_0)
1708 if (myContext->IsGlGreaterEqual (4, 0))
1710 aProgramSrc->SetHeader ("#version 400");
1713 if (myContext->IsGlGreaterEqual (3, 2))
1715 aProgramSrc->SetHeader ("#version 320 es");
1717 else if (myContext->IsGlGreaterEqual (3, 0))
1719 aProgramSrc->SetHeader ("#version 300 es"); // with GL_OES_sample_variables extension
1724 aProgramSrc->SetId (theMsaa ? "occt_weight-oit-msaa" : "occt_weight-oit");
1725 aProgramSrc->SetDefaultSampler (false);
1726 aProgramSrc->SetNbLightsMax (0);
1727 aProgramSrc->SetNbClipPlanesMax (0);
1728 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1729 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1730 TCollection_AsciiString aKey;
1731 if (!Create (aProgramSrc, aKey, aProgram))
1733 aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1734 return Standard_False;
1737 myContext->BindProgram (aProgram);
1738 aProgram->SetSampler (myContext, "uAccumTexture", Graphic3d_TextureUnit_0);
1739 aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
1740 myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
1741 return Standard_True;
1744 // =======================================================================
1745 // function : pointSpriteAlphaSrc
1747 // =======================================================================
1748 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (Standard_Integer theBits)
1750 TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").a; }";
1751 #if !defined(GL_ES_VERSION_2_0)
1752 if (myContext->core11 == NULL
1753 && (theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
1755 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").r; }";
1760 return aSrcGetAlpha;
1763 // =======================================================================
1764 // function : defaultGlslVersion
1766 // =======================================================================
1767 int OpenGl_ShaderManager::defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
1768 const TCollection_AsciiString& theName,
1770 bool theUsesDerivates) const
1772 int aBits = theBits;
1773 const bool toUseDerivates = theUsesDerivates
1774 || (theBits & OpenGl_PO_StippleLine) != 0;
1775 #if !defined(GL_ES_VERSION_2_0)
1776 if (myContext->core32 != NULL)
1778 theProgram->SetHeader ("#version 150");
1782 if ((theBits & OpenGl_PO_StippleLine) != 0
1783 || theProgram->IsPBR())
1785 if (myContext->IsGlGreaterEqual (3, 0))
1787 theProgram->SetHeader ("#version 130");
1789 else if (myContext->CheckExtension ("GL_EXT_gpu_shader4")) // myContext->hasGlslBitwiseOps == OpenGl_FeatureInExtensions
1791 // GL_EXT_gpu_shader4 defines GLSL type "unsigned int", while core GLSL specs define type "uint"
1792 theProgram->SetHeader ("#extension GL_EXT_gpu_shader4 : enable\n"
1793 "#define uint unsigned int");
1797 (void )toUseDerivates;
1800 #if defined(__EMSCRIPTEN__)
1801 if (myContext->IsGlGreaterEqual (3, 0))
1803 // consider this is browser responsibility to provide working WebGL 2.0 implementation
1804 // and black-list broken drivers (there is no OpenGL ES greater than 3.0)
1805 theProgram->SetHeader ("#version 300 es");
1808 // prefer "100 es" on OpenGL ES 3.0- devices (save the features unavailable before "300 es")
1809 // and "300 es" on OpenGL ES 3.1+ devices
1810 if (myContext->IsGlGreaterEqual (3, 1))
1812 if ((theBits & OpenGl_PO_NeedsGeomShader) != 0)
1814 theProgram->SetHeader (myContext->hasGeometryStage != OpenGl_FeatureInExtensions ? "#version 320 es" : "#version 310 es");
1818 theProgram->SetHeader ("#version 300 es");
1823 if (theProgram->IsPBR()
1824 && myContext->IsGlGreaterEqual (3, 0))
1826 theProgram->SetHeader ("#version 300 es");
1828 if ((theBits & OpenGl_PO_WriteOit) != 0
1829 || (theBits & OpenGl_PO_StippleLine) != 0)
1831 if (myContext->IsGlGreaterEqual (3, 0))
1833 theProgram->SetHeader ("#version 300 es");
1837 aBits = aBits & ~OpenGl_PO_WriteOit;
1838 if (!myContext->oesStdDerivatives)
1840 aBits = aBits & ~OpenGl_PO_StippleLine;
1846 if (myContext->IsGlGreaterEqual (3, 0))
1848 theProgram->SetHeader ("#version 300 es");
1850 else if (myContext->oesStdDerivatives)
1852 theProgram->SetHeader ("#extension GL_OES_standard_derivatives : enable");
1858 // should fit OpenGl_PO_NB
1860 Sprintf (aBitsStr, "%04x", aBits);
1861 theProgram->SetId (TCollection_AsciiString ("occt_") + theName + aBitsStr);
1865 // =======================================================================
1866 // function : prepareGeomMainSrc
1868 // =======================================================================
1869 TCollection_AsciiString OpenGl_ShaderManager::prepareGeomMainSrc (OpenGl_ShaderObject::ShaderVariableList& theUnifoms,
1870 OpenGl_ShaderObject::ShaderVariableList& theStageInOuts,
1871 Standard_Integer theBits)
1873 if ((theBits & OpenGl_PO_NeedsGeomShader) == 0)
1875 return TCollection_AsciiString();
1878 TCollection_AsciiString aSrcMainGeom =
1882 if ((theBits & OpenGl_PO_MeshEdges) != 0)
1884 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_GEOMETRY));
1885 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("bool occIsQuadMode", Graphic3d_TOS_GEOMETRY));
1886 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_GEOMETRY));
1887 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_FRAGMENT));
1888 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineFeather", Graphic3d_TOS_FRAGMENT));
1889 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occWireframeColor", Graphic3d_TOS_FRAGMENT));
1890 theStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable ("vec3 EdgeDistance", Graphic3d_TOS_GEOMETRY | Graphic3d_TOS_FRAGMENT));
1892 aSrcMainGeom = TCollection_AsciiString()
1893 + EOL"vec3 ViewPortTransform (vec4 theVec)"
1895 EOL" vec3 aWinCoord = theVec.xyz / theVec.w;"
1896 EOL" aWinCoord = aWinCoord * 0.5 + 0.5;"
1897 EOL" aWinCoord.xy = aWinCoord.xy * occViewport.zw + occViewport.xy;"
1898 EOL" return aWinCoord;"
1901 + EOL" vec3 aSideA = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[1].gl_Position);"
1902 EOL" vec3 aSideB = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1903 EOL" vec3 aSideC = ViewPortTransform (gl_in[1].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1904 EOL" float aQuadArea = abs (aSideB.x * aSideC.y - aSideB.y * aSideC.x);"
1905 EOL" vec3 aLenABC = vec3 (length (aSideA), length (aSideB), length (aSideC));"
1906 EOL" vec3 aHeightABC = vec3 (aQuadArea) / aLenABC;"
1907 EOL" aHeightABC = max (aHeightABC, vec3 (10.0 * occLineWidth));" // avoid shrunk presentation disappearing at distance
1908 EOL" float aQuadModeHeightC = occIsQuadMode ? occLineWidth + 1.0 : 0.0;";
1911 for (Standard_Integer aVertIter = 0; aVertIter < 3; ++aVertIter)
1913 const TCollection_AsciiString aVertIndex (aVertIter);
1914 // pass variables from Vertex shader to Fragment shader through Geometry shader
1915 for (OpenGl_ShaderObject::ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
1917 if (aVarListIter.Value().Stages == (Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT))
1919 const TCollection_AsciiString aVarName = aVarListIter.Value().Name.Token (" ", 2);
1920 aSrcMainGeom += TCollection_AsciiString()
1921 + EOL" geomOut." + aVarName + " = geomIn[" + aVertIndex + "]." + aVarName + ";";
1925 if ((theBits & OpenGl_PO_MeshEdges) != 0)
1929 case 0: aSrcMainGeom += EOL" EdgeDistance = vec3 (aHeightABC[0], 0.0, aQuadModeHeightC);"; break;
1930 case 1: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, aHeightABC[1], aQuadModeHeightC);"; break;
1931 case 2: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, 0.0, aHeightABC[2]);"; break;
1934 aSrcMainGeom += TCollection_AsciiString()
1935 + EOL" gl_Position = gl_in[" + aVertIndex + "].gl_Position;"
1936 EOL" EmitVertex();";
1939 EOL" EndPrimitive();"
1942 return aSrcMainGeom;
1945 // =======================================================================
1946 // function : prepareStdProgramUnlit
1948 // =======================================================================
1949 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
1950 Standard_Integer theBits,
1951 Standard_Boolean theIsOutline)
1953 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1954 TCollection_AsciiString aSrcVert, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcVertEndMain;
1955 TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
1956 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
1957 TCollection_AsciiString aSrcFragMainGetColor = EOL" occSetFragColor (getFinalColor());";
1958 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1960 if ((theBits & OpenGl_PO_IsPoint) != 0)
1962 #if defined(GL_ES_VERSION_2_0)
1963 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
1966 if ((theBits & OpenGl_PO_PointSprite) != 0)
1968 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
1969 if ((theBits & OpenGl_PO_PointSpriteA) != OpenGl_PO_PointSpriteA)
1972 EOL"vec4 getColor(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord "); }";
1974 else if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB
1975 && (theBits & OpenGl_PO_VertColor) == 0)
1977 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
1978 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1979 aSrcVertExtraMain +=
1980 EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
1982 EOL"vec4 getColor(void) { return VertColor; }";
1985 aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
1987 #if !defined(GL_ES_VERSION_2_0)
1988 if (myContext->core11 != NULL
1989 && myContext->IsGlGreaterEqual (2, 1))
1991 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1995 aSrcFragMainGetColor =
1996 EOL" vec4 aColor = getColor();"
1997 EOL" aColor.a = getAlpha();"
1998 EOL" if (aColor.a <= 0.1) discard;"
1999 EOL" occSetFragColor (aColor);";
2003 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB
2004 && (theBits & OpenGl_PO_VertColor) == 0)
2006 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2007 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2008 aSrcVertExtraMain +=
2009 EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2011 EOL"vec4 getColor(void) { return VertColor; }";
2014 aSrcFragMainGetColor =
2015 EOL" vec4 aColor = getColor();"
2016 EOL" if (aColor.a <= 0.1) discard;"
2017 EOL" occSetFragColor (aColor);";
2022 if ((theBits & OpenGl_PO_TextureRGB) != 0 || (theBits & OpenGl_PO_TextureEnv) != 0)
2024 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2025 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2028 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
2030 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2033 EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
2035 else if ((theBits & OpenGl_PO_TextureEnv) != 0)
2037 aSrcVertExtraFunc = THE_FUNC_transformNormal_view;
2039 aSrcVertExtraMain +=
2040 EOL" vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2041 EOL" vec3 aNormal = transformNormal (occNormal);"
2042 EOL" vec3 aReflect = reflect (normalize (aPosition.xyz), aNormal);"
2043 EOL" aReflect.z += 1.0;"
2044 EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
2047 EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
2050 if ((theBits & OpenGl_PO_VertColor) != 0)
2052 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2053 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
2054 aSrcFragGetColor = EOL"vec4 getColor(void) { return VertColor; }";
2057 int aNbClipPlanes = 0;
2058 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2060 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2061 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2062 aSrcVertExtraMain +=
2063 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
2064 EOL" Position = occWorldViewMatrix * PositionWorld;";
2066 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2068 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2069 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2070 ? THE_FRAG_CLIP_CHAINS_N
2071 : THE_FRAG_CLIP_PLANES_N;
2073 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2076 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2078 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2081 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2082 ? THE_FRAG_CLIP_CHAINS_2
2083 : THE_FRAG_CLIP_PLANES_2;
2086 if ((theBits & OpenGl_PO_WriteOit) != 0)
2088 aProgramSrc->SetNbFragmentOutputs (2);
2089 aProgramSrc->SetWeightOitOutput (true);
2094 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occOrthoScale", Graphic3d_TOS_VERTEX));
2095 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occSilhouetteThickness", Graphic3d_TOS_VERTEX));
2096 aSrcVertEndMain = THE_VERT_gl_Position_OUTLINE;
2098 else if ((theBits & OpenGl_PO_StippleLine) != 0)
2100 const Standard_Integer aBits = defaultGlslVersion (aProgramSrc, "unlit", theBits);
2101 if ((aBits & OpenGl_PO_StippleLine) != 0)
2103 if (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable)
2105 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int occStipplePattern", Graphic3d_TOS_FRAGMENT));
2109 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("bool occStipplePattern[16]", Graphic3d_TOS_FRAGMENT));
2111 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occStippleFactor", Graphic3d_TOS_FRAGMENT));
2112 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_VERTEX));
2113 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 ScreenSpaceCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2115 EOL" vec2 aPosition = gl_Position.xy / gl_Position.w;"
2116 EOL" aPosition = aPosition * 0.5 + 0.5;"
2117 EOL" ScreenSpaceCoord = aPosition.xy * occViewport.zw + occViewport.xy;";
2118 aSrcFragMainGetColor = TCollection_AsciiString()
2119 + EOL" vec2 anAxis = vec2 (0.0, 1.0);"
2120 EOL" if (abs (dFdx (ScreenSpaceCoord.x)) - abs (dFdy (ScreenSpaceCoord.y)) > 0.001)"
2122 EOL" anAxis = vec2 (1.0, 0.0);"
2124 EOL" float aRotatePoint = dot (gl_FragCoord.xy, anAxis);"
2125 + (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable
2126 ? EOL" uint aBit = uint (floor (aRotatePoint / occStippleFactor + 0.5)) & 15U;"
2127 EOL" if ((uint (occStipplePattern) & (1U << aBit)) == 0U) discard;"
2128 : EOL" int aBit = int (mod (floor (aRotatePoint / occStippleFactor + 0.5), 16.0));"
2129 EOL" if (!occStipplePattern[aBit]) discard;")
2130 + EOL" vec4 aColor = getFinalColor();"
2131 EOL" if (aColor.a <= 0.1) discard;"
2132 EOL" occSetFragColor (aColor);";
2136 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, "Warning: stipple lines in GLSL will be ignored.");
2145 + THE_VERT_gl_Position
2149 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2150 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2151 ? THE_FRAG_WIREFRAME_COLOR
2152 : EOL"#define getFinalColor getColor";
2160 + aSrcFragMainGetColor
2163 defaultGlslVersion (aProgramSrc, theIsOutline ? "outline" : "unlit", theBits);
2164 aProgramSrc->SetDefaultSampler (false);
2165 aProgramSrc->SetNbLightsMax (0);
2166 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2167 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2168 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2169 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2170 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2171 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2172 TCollection_AsciiString aKey;
2173 if (!Create (aProgramSrc, aKey, theProgram))
2175 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2176 return Standard_False;
2178 return Standard_True;
2181 // =======================================================================
2182 // function : pointSpriteShadingSrc
2184 // =======================================================================
2185 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString& theBaseColorSrc,
2186 Standard_Integer theBits)
2188 TCollection_AsciiString aSrcFragGetColor;
2189 if ((theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
2191 aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
2192 EOL"vec4 getColor(void)"
2194 EOL" vec4 aColor = " + theBaseColorSrc + ";"
2195 EOL" aColor.a = getAlpha();"
2196 EOL" if (aColor.a <= 0.1) discard;"
2197 EOL" return aColor;"
2200 else if ((theBits & OpenGl_PO_PointSprite) == OpenGl_PO_PointSprite)
2202 aSrcFragGetColor = TCollection_AsciiString() +
2203 EOL"vec4 getColor(void)"
2205 EOL" vec4 aColor = " + theBaseColorSrc + ";"
2206 EOL" aColor = occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ") * aColor;"
2207 EOL" if (aColor.a <= 0.1) discard;"
2208 EOL" return aColor;"
2212 return aSrcFragGetColor;
2215 // =======================================================================
2216 // function : stdComputeLighting
2218 // =======================================================================
2219 TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (Standard_Integer& theNbLights,
2220 Standard_Boolean theHasVertColor,
2221 Standard_Boolean theIsPBR)
2223 TCollection_AsciiString aLightsFunc, aLightsLoop;
2225 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
2226 if (!aLights.IsNull())
2228 theNbLights = aLights->NbEnabled();
2229 if (theNbLights <= THE_NB_UNROLLED_LIGHTS_MAX)
2231 Standard_Integer anIndex = 0;
2232 for (Graphic3d_LightSet::Iterator aLightIter (aLights, Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
2233 aLightIter.More(); aLightIter.Next(), ++anIndex)
2235 switch (aLightIter.Value()->Type())
2237 case Graphic3d_TOLS_AMBIENT:
2239 break; // skip ambient
2240 case Graphic3d_TOLS_DIRECTIONAL:
2241 aLightsLoop = aLightsLoop + EOL" directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
2243 case Graphic3d_TOLS_POSITIONAL:
2244 aLightsLoop = aLightsLoop + EOL" pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2246 case Graphic3d_TOLS_SPOT:
2247 aLightsLoop = aLightsLoop + EOL" spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2254 theNbLights = roundUpMaxLightSources (theNbLights);
2255 bool isFirstInLoop = true;
2256 aLightsLoop = aLightsLoop +
2257 EOL" for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)"
2259 EOL" int aType = occLight_Type (anIndex);";
2260 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2262 isFirstInLoop = false;
2264 EOL" if (aType == OccLightType_Direct)"
2266 EOL" directionalLight (anIndex, theNormal, theView, theIsFront);"
2269 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2273 aLightsLoop += EOL" else ";
2275 isFirstInLoop = false;
2277 EOL" if (aType == OccLightType_Point)"
2279 EOL" pointLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2282 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2286 aLightsLoop += EOL" else ";
2288 isFirstInLoop = false;
2290 EOL" if (aType == OccLightType_Spot)"
2292 EOL" spotLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2295 aLightsLoop += EOL" }";
2300 aLightsFunc += Shaders_PBRDistribution_glsl;
2301 aLightsFunc += Shaders_PBRGeometry_glsl;
2302 aLightsFunc += Shaders_PBRFresnel_glsl;
2303 aLightsFunc += Shaders_PBRCookTorrance_glsl;
2304 aLightsFunc += Shaders_PBRIllumination_glsl;
2307 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) == 1
2311 // use the version with hard-coded first index
2312 aLightsLoop = EOL" directionalLightFirst(theNormal, theView, theIsFront);";
2313 aLightsFunc += THE_FUNC_directionalLightFirst;
2315 else if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2317 aLightsFunc += theIsPBR ? THE_FUNC_PBR_directionalLight : THE_FUNC_directionalLight;
2319 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2321 aLightsFunc += theIsPBR ? THE_FUNC_PBR_pointLight : THE_FUNC_pointLight;
2323 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2325 aLightsFunc += theIsPBR ? THE_FUNC_PBR_spotLight : THE_FUNC_spotLight;
2329 TCollection_AsciiString aGetMatAmbient = "theIsFront ? occFrontMaterial_Ambient() : occBackMaterial_Ambient();";
2330 TCollection_AsciiString aGetMatDiffuse = "theIsFront ? occFrontMaterial_Diffuse() : occBackMaterial_Diffuse();";
2331 if (theHasVertColor)
2333 aGetMatAmbient = "getVertColor();";
2334 aGetMatDiffuse = "getVertColor();";
2339 return TCollection_AsciiString()
2343 EOL"vec4 computeLighting (in vec3 theNormal,"
2344 EOL" in vec3 theView,"
2345 EOL" in vec4 thePoint,"
2346 EOL" in bool theIsFront)"
2348 EOL" Ambient = occLightAmbient.rgb;"
2349 EOL" Diffuse = vec3 (0.0);"
2350 EOL" Specular = vec3 (0.0);"
2351 EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
2353 + EOL" vec4 aMatAmbient = " + aGetMatAmbient
2354 + EOL" vec4 aMatDiffuse = " + aGetMatDiffuse
2355 + EOL" vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
2356 EOL" vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
2357 EOL" vec3 aColor = Ambient * aMatAmbient.rgb"
2358 EOL" + Diffuse * aMatDiffuse.rgb"
2359 EOL" + Specular * aMatSpecular.rgb"
2360 EOL" + aMatEmission.rgb;"
2361 EOL" return vec4 (aColor, aMatDiffuse.a);"
2366 return TCollection_AsciiString()
2367 + THE_FUNC_PBR_lightDef
2370 EOL"vec4 computeLighting (in vec3 theNormal,"
2371 EOL" in vec3 theView,"
2372 EOL" in vec4 thePoint,"
2373 EOL" in bool theIsFront)"
2375 EOL" DirectLighting = vec3(0.0);"
2376 EOL" BaseColor = " + (theHasVertColor ? "getVertColor();" : "getBaseColor (theIsFront);")
2377 + EOL" Metallic = theIsFront ? occPBRFrontMaterial_Metallic() : occPBRBackMaterial_Metallic();"
2378 EOL" Roughness = theIsFront ? occPBRFrontMaterial_Roughness() : occPBRBackMaterial_Roughness();"
2379 EOL" IOR = theIsFront ? occPBRFrontMaterial_IOR() : occPBRBackMaterial_IOR();"
2380 EOL" Emission = theIsFront ? occPBRFrontMaterial_Emission() : occPBRBackMaterial_Emission();"
2381 EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
2383 + EOL" vec3 aColor = DirectLighting;"
2384 EOL" vec3 anIndirectLightingSpec = occPBRFresnel (BaseColor.rgb, Metallic, IOR);"
2385 EOL" Roughness = theIsFront ? occPBRFrontMaterial_NormalizedRoughness() : occPBRBackMaterial_NormalizedRoughness();"
2386 EOL" vec2 aCoeff = occTexture2D (occEnvLUT, vec2(abs(dot(theView, theNormal)), Roughness)).xy;"
2387 EOL" anIndirectLightingSpec *= aCoeff.x;"
2388 EOL" anIndirectLightingSpec += aCoeff.y;"
2389 EOL" anIndirectLightingSpec *= occTextureCubeLod (occSpecIBLMap, -reflect (theView, theNormal), Roughness * float (occNbSpecIBLLevels - 1)).rgb;"
2390 EOL" vec3 aRefractionCoeff = 1.0 - occPBRFresnel (BaseColor.rgb, Metallic, Roughness, IOR, abs(dot(theView, theNormal)));"
2391 EOL" aRefractionCoeff *= (1.0 - Metallic);"
2392 EOL" vec3 anIndirectLightingDiff = aRefractionCoeff * BaseColor.rgb * BaseColor.a;"
2393 EOL" anIndirectLightingDiff *= occDiffIBLMap (theNormal).rgb;"
2394 EOL" aColor += occLightAmbient.rgb * (anIndirectLightingDiff + anIndirectLightingSpec);"
2395 EOL" aColor += Emission;"
2396 EOL" return vec4 (aColor, mix(1.0, BaseColor.a, aRefractionCoeff.x));"
2401 // =======================================================================
2402 // function : prepareStdProgramGouraud
2404 // =======================================================================
2405 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
2406 const Standard_Integer theBits)
2408 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2409 TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraMain;
2410 TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
2411 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
2412 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2414 if ((theBits & OpenGl_PO_IsPoint) != 0)
2416 #if defined(GL_ES_VERSION_2_0)
2417 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
2420 if ((theBits & OpenGl_PO_PointSprite) != 0)
2422 #if !defined(GL_ES_VERSION_2_0)
2423 if (myContext->core11 != NULL
2424 && myContext->IsGlGreaterEqual (2, 1))
2426 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2430 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2431 aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
2434 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB
2435 && (theBits & OpenGl_PO_VertColor) == 0)
2437 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2438 aSrcVertColor = EOL"vec4 getVertColor(void) { return occTexture2D (occSamplerBaseColor, occTexCoord.xy); }";
2443 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
2445 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2446 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2447 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2450 EOL"vec4 getColor(void)"
2452 EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
2453 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2458 if ((theBits & OpenGl_PO_VertColor) != 0)
2460 aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
2463 int aNbClipPlanes = 0;
2464 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2466 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2467 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2468 aSrcVertExtraMain +=
2469 EOL" PositionWorld = aPositionWorld;"
2470 EOL" Position = aPosition;";
2472 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2474 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2475 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2476 ? THE_FRAG_CLIP_CHAINS_N
2477 : THE_FRAG_CLIP_PLANES_N;
2479 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2482 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2484 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2487 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2488 ? THE_FRAG_CLIP_CHAINS_2
2489 : THE_FRAG_CLIP_PLANES_2;
2492 if ((theBits & OpenGl_PO_WriteOit) != 0)
2494 aProgramSrc->SetNbFragmentOutputs (2);
2495 aProgramSrc->SetWeightOitOutput (true);
2498 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 FrontColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2499 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 BackColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2501 Standard_Integer aNbLights = 0;
2502 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcVertColor.IsEmpty(), false);
2503 aSrcVert = TCollection_AsciiString()
2504 + THE_FUNC_transformNormal_view
2510 EOL" vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
2511 EOL" vec4 aPosition = occWorldViewMatrix * aPositionWorld;"
2512 EOL" vec3 aNormal = transformNormal (occNormal);"
2513 EOL" vec3 aView = vec3 (0.0, 0.0, 1.0);"
2514 EOL" FrontColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
2515 EOL" BackColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
2517 + THE_VERT_gl_Position
2520 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2521 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2522 ? THE_FRAG_WIREFRAME_COLOR
2523 : EOL"#define getFinalColor getColor";
2525 aSrcFrag = TCollection_AsciiString()
2530 + EOL" occSetFragColor (getFinalColor());"
2533 const TCollection_AsciiString aProgId = TCollection_AsciiString ("gouraud-") + genLightKey (myLightSourceState.LightSources()) + "-";
2534 defaultGlslVersion (aProgramSrc, aProgId, theBits);
2535 aProgramSrc->SetDefaultSampler (false);
2536 aProgramSrc->SetNbLightsMax (aNbLights);
2537 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2538 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2539 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2540 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2541 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2542 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2543 TCollection_AsciiString aKey;
2544 if (!Create (aProgramSrc, aKey, theProgram))
2546 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2547 return Standard_False;
2549 return Standard_True;
2552 // =======================================================================
2553 // function : prepareStdProgramPhong
2555 // =======================================================================
2556 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
2557 const Standard_Integer theBits,
2558 const Standard_Boolean theIsFlatNormal,
2559 const Standard_Boolean theIsPBR)
2561 TCollection_AsciiString aPosition = theIsPBR ? "PositionWorld" : "Position";
2562 TCollection_AsciiString aPhongCompLight = TCollection_AsciiString() +
2563 "computeLighting (normalize (Normal), normalize (View), " + aPosition + ", gl_FrontFacing)";
2564 const bool isFlatNormal = theIsFlatNormal
2565 && myContext->hasFlatShading != OpenGl_FeatureNotAvailable;
2566 const char* aDFdxSignReversion = "";
2567 #if defined(GL_ES_VERSION_2_0)
2568 if (isFlatNormal != theIsFlatNormal)
2570 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
2571 GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2572 "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
2574 else if (isFlatNormal
2575 && myContext->Vendor().Search("qualcomm") != -1)
2577 // workaround Adreno driver bug computing reversed normal using dFdx/dFdy
2578 aDFdxSignReversion = "-";
2579 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2580 "Warning: applied workaround for flat shading normal computation using dFdx/dFdy on Adreno");
2583 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2584 aProgramSrc->SetPBR (theIsPBR);
2586 TCollection_AsciiString aSrcVert, aSrcVertExtraFunc, aSrcVertExtraMain;
2587 TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain;
2588 TCollection_AsciiString aSrcFragGetColor = TCollection_AsciiString() + EOL"vec4 getColor(void) { return " + aPhongCompLight + "; }";
2589 TCollection_AsciiString aSrcFragPBRGetBaseColor = TCollection_AsciiString() +
2590 EOL"vec4 getBaseColor(in bool theIsFront)"
2592 EOL" return theIsFront ? occPBRFrontMaterial_Color() : occPBRBackMaterial_Color();"
2594 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2595 if ((theBits & OpenGl_PO_IsPoint) != 0)
2597 #if defined(GL_ES_VERSION_2_0)
2598 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
2601 if ((theBits & OpenGl_PO_PointSprite) != 0)
2603 #if !defined(GL_ES_VERSION_2_0)
2604 if (myContext->core11 != NULL
2605 && myContext->IsGlGreaterEqual (2, 1))
2607 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2611 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2612 aSrcFragGetColor = pointSpriteShadingSrc (aPhongCompLight, theBits);
2615 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB
2616 && (theBits & OpenGl_PO_VertColor) == 0)
2618 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2619 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2621 aSrcVertExtraMain += EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2622 aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2627 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureRGB)
2629 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2630 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2631 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2635 aSrcFragGetColor = TCollection_AsciiString() +
2636 EOL"vec4 getColor(void)"
2638 EOL" vec4 aColor = " + aPhongCompLight + ";"
2639 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2644 aSrcFragPBRGetBaseColor = TCollection_AsciiString() +
2645 EOL"vec4 getBaseColor (in bool theIsFront)"
2647 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) *"
2648 EOL" (theIsFront ? occPBRFrontMaterial_Color() : occPBRBackMaterial_Color());"
2654 if ((theBits & OpenGl_PO_VertColor) != 0)
2656 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2657 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
2658 aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2661 int aNbClipPlanes = 0;
2662 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2664 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2666 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2667 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2668 ? THE_FRAG_CLIP_CHAINS_N
2669 : THE_FRAG_CLIP_PLANES_N;
2671 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2674 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2676 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2679 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2680 ? THE_FRAG_CLIP_CHAINS_2
2681 : THE_FRAG_CLIP_PLANES_2;
2684 if ((theBits & OpenGl_PO_WriteOit) != 0)
2686 aProgramSrc->SetNbFragmentOutputs (2);
2687 aProgramSrc->SetWeightOitOutput (true);
2692 aSrcFragExtraOut += EOL"vec3 Normal;";
2693 aSrcFragExtraMain += TCollection_AsciiString()
2694 + EOL" Normal = " + aDFdxSignReversion + "normalize (cross (dFdx (" + aPosition + ".xyz / " + aPosition + ".w), dFdy (" + aPosition + ".xyz / " + aPosition + ".w)));"
2695 EOL" if (!gl_FrontFacing) { Normal = -Normal; }";
2699 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 Normal", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2700 aSrcVertExtraFunc += theIsPBR ? THE_FUNC_transformNormal_world : THE_FUNC_transformNormal_view;
2701 aSrcVertExtraMain += EOL" Normal = transformNormal (occNormal);";
2704 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2705 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2706 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 View", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2708 aSrcVert = TCollection_AsciiString()
2712 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
2713 EOL" Position = occWorldViewMatrix * PositionWorld;"
2714 EOL" if (occProjectionMatrix[3][3] == 1.0)"
2716 EOL" View = vec3(0.0, 0.0, 1.0);"
2720 EOL" View = -Position.xyz;"
2722 + (theIsPBR ? EOL" View = (occWorldViewMatrixInverse * vec4(View, 0.0)).xyz;" : "")
2724 + THE_VERT_gl_Position
2727 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2728 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2729 ? THE_FRAG_WIREFRAME_COLOR
2730 : EOL"#define getFinalColor getColor";
2732 Standard_Integer aNbLights = 0;
2733 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcFragGetVertColor.IsEmpty(), theIsPBR);
2734 aSrcFrag = TCollection_AsciiString()
2737 + aSrcFragGetVertColor
2738 + (theIsPBR ? aSrcFragPBRGetBaseColor : "")
2745 + EOL" occSetFragColor (getFinalColor());"
2748 const TCollection_AsciiString aProgId = TCollection_AsciiString (theIsFlatNormal ? "flat-" : "phong-") + (theIsPBR ? "pbr-" : "") + genLightKey (myLightSourceState.LightSources()) + "-";
2749 defaultGlslVersion (aProgramSrc, aProgId, theBits, isFlatNormal);
2750 aProgramSrc->SetDefaultSampler (false);
2751 aProgramSrc->SetNbLightsMax (aNbLights);
2752 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2753 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2755 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2756 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2757 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2758 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2759 TCollection_AsciiString aKey;
2760 if (!Create (aProgramSrc, aKey, theProgram))
2762 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2763 return Standard_False;
2765 return Standard_True;
2768 // =======================================================================
2769 // function : prepareStdProgramStereo
2771 // =======================================================================
2772 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
2773 const Graphic3d_StereoMode theStereoMode)
2775 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2776 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2778 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2779 TCollection_AsciiString aSrcVert =
2782 EOL" TexCoord = occVertex.zw;"
2783 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
2786 TCollection_AsciiString aSrcFrag;
2787 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uLeftSampler", Graphic3d_TOS_FRAGMENT));
2788 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uRightSampler", Graphic3d_TOS_FRAGMENT));
2789 const char* aName = "stereo";
2790 switch (theStereoMode)
2792 case Graphic3d_StereoMode_Anaglyph:
2795 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultL", Graphic3d_TOS_FRAGMENT));
2796 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultR", Graphic3d_TOS_FRAGMENT));
2797 const TCollection_AsciiString aNormalize = mySRgbState
2798 ? EOL"#define sRgb2linear(theColor) theColor"
2799 EOL"#define linear2sRgb(theColor) theColor"
2800 : EOL"#define sRgb2linear(theColor) pow(theColor, vec4(2.2, 2.2, 2.2, 1.0))"
2801 EOL"#define linear2sRgb(theColor) pow(theColor, 1.0 / vec4(2.2, 2.2, 2.2, 1.0))";
2802 aSrcFrag = aNormalize
2805 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2806 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2807 EOL" aColorL = sRgb2linear (aColorL);"
2808 EOL" aColorR = sRgb2linear (aColorR);"
2809 EOL" vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
2810 EOL" occSetFragColor (linear2sRgb (aColor));"
2814 case Graphic3d_StereoMode_RowInterlaced:
2816 aName = "row-interlaced";
2820 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2821 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2822 EOL" if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
2824 EOL" occSetFragColor (aColorL);"
2828 EOL" occSetFragColor (aColorR);"
2833 case Graphic3d_StereoMode_ColumnInterlaced:
2835 aName = "column-interlaced";
2839 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2840 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2841 EOL" if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
2843 EOL" occSetFragColor (aColorL);"
2847 EOL" occSetFragColor (aColorR);"
2852 case Graphic3d_StereoMode_ChessBoard:
2854 aName = "chessboard";
2858 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2859 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2860 EOL" bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
2861 EOL" bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
2862 EOL" if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
2864 EOL" occSetFragColor (aColorL);"
2868 EOL" occSetFragColor (aColorR);"
2873 case Graphic3d_StereoMode_SideBySide:
2875 aName = "sidebyside";
2879 EOL" vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
2880 EOL" if (TexCoord.x > 0.5)"
2882 EOL" aTexCoord.x -= 1.0;"
2884 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2885 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2886 EOL" if (TexCoord.x <= 0.5)"
2888 EOL" occSetFragColor (aColorL);"
2892 EOL" occSetFragColor (aColorR);"
2897 case Graphic3d_StereoMode_OverUnder:
2899 aName = "overunder";
2903 EOL" vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
2904 EOL" if (TexCoord.y > 0.5)"
2906 EOL" aTexCoord.y -= 1.0;"
2908 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2909 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2910 EOL" if (TexCoord.y <= 0.5)"
2912 EOL" occSetFragColor (aColorL);"
2916 EOL" occSetFragColor (aColorR);"
2921 case Graphic3d_StereoMode_QuadBuffer:
2922 case Graphic3d_StereoMode_SoftPageFlip:
2925 /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
2926 if (!aProgram.IsNull())
2928 return aProgram->IsValid();
2933 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2934 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2935 EOL" aColorL.b = 0.0;"
2936 EOL" aColorL.g = 0.0;"
2937 EOL" aColorR.r = 0.0;"
2938 EOL" occSetFragColor (aColorL + aColorR);"
2944 defaultGlslVersion (aProgramSrc, aName, 0);
2945 aProgramSrc->SetDefaultSampler (false);
2946 aProgramSrc->SetNbLightsMax (0);
2947 aProgramSrc->SetNbClipPlanesMax (0);
2948 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
2949 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
2950 TCollection_AsciiString aKey;
2951 if (!Create (aProgramSrc, aKey, theProgram))
2953 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2954 return Standard_False;
2957 myContext->BindProgram (theProgram);
2958 theProgram->SetSampler (myContext, "uLeftSampler", Graphic3d_TextureUnit_0);
2959 theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
2960 myContext->BindProgram (NULL);
2961 return Standard_True;
2964 // =======================================================================
2965 // function : prepareStdProgramBoundBox
2967 // =======================================================================
2968 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramBoundBox()
2970 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2972 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2973 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxCenter", Graphic3d_TOS_VERTEX));
2974 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxSize", Graphic3d_TOS_VERTEX));
2976 TCollection_AsciiString aSrcVert =
2979 EOL" vec4 aCenter = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
2980 EOL" vec4 aPos = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
2981 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * aPos;"
2984 TCollection_AsciiString aSrcFrag =
2987 EOL" occSetFragColor (occColor);"
2990 defaultGlslVersion (aProgramSrc, "bndbox", 0);
2991 aProgramSrc->SetDefaultSampler (false);
2992 aProgramSrc->SetNbLightsMax (0);
2993 aProgramSrc->SetNbClipPlanesMax (0);
2994 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
2995 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
2996 TCollection_AsciiString aKey;
2997 if (!Create (aProgramSrc, aKey, myBoundBoxProgram))
2999 myBoundBoxProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3000 return Standard_False;
3003 const OpenGl_Vec4 aMin (-0.5f, -0.5f, -0.5f, 1.0f);
3004 const OpenGl_Vec4 anAxisShifts[3] =
3006 OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
3007 OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 0.0f),
3008 OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 0.0f)
3011 const OpenGl_Vec4 aLookup1 (0.0f, 1.0f, 0.0f, 1.0f);
3012 const OpenGl_Vec4 aLookup2 (0.0f, 0.0f, 1.0f, 1.0f);
3013 OpenGl_Vec4 aLinesVertices[24];
3014 for (int anAxis = 0, aVertex = 0; anAxis < 3; ++anAxis)
3016 for (int aCompIter = 0; aCompIter < 4; ++aCompIter)
3018 aLinesVertices[aVertex++] = aMin
3019 + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3020 + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3022 aLinesVertices[aVertex++] = aMin
3023 + anAxisShifts[anAxis]
3024 + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3025 + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3028 if (myContext->ToUseVbo())
3030 myBoundBoxVertBuffer = new OpenGl_VertexBuffer();
3031 if (myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData()))
3033 myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3034 return Standard_True;
3037 myBoundBoxVertBuffer = new OpenGl_VertexBufferCompat();
3038 myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData());
3039 myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3040 return Standard_True;
3043 // =======================================================================
3044 // function : preparePBREnvBakingProgram
3046 // =======================================================================
3047 Standard_Boolean OpenGl_ShaderManager::preparePBREnvBakingProgram()
3049 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
3050 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3052 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3053 + THE_FUNC_cubemap_vector_transform
3054 + Shaders_PBREnvBaking_vs;
3056 TCollection_AsciiString aSrcFrag = TCollection_AsciiString()
3057 + THE_FUNC_cubemap_vector_transform
3058 + Shaders_PBRDistribution_glsl
3059 + Shaders_PBREnvBaking_fs;
3061 // constant array definition requires OpenGL 2.1+ or OpenGL ES 3.0+
3062 #if defined(GL_ES_VERSION_2_0)
3063 aProgramSrc->SetHeader ("#version 300 es");
3065 aProgramSrc->SetHeader ("#version 120");
3068 defaultGlslVersion (aProgramSrc, "pbr_env_baking", 0);
3069 aProgramSrc->SetDefaultSampler (false);
3070 aProgramSrc->SetNbLightsMax (0);
3071 aProgramSrc->SetNbClipPlanesMax (0);
3072 aProgramSrc->SetPBR (true);
3073 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3074 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3075 TCollection_AsciiString aKey;
3076 if (!Create (aProgramSrc, aKey, myPBREnvBakingProgram))
3078 myPBREnvBakingProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3079 return Standard_False;
3082 return Standard_True;
3085 // =======================================================================
3086 // function : GetBgCubeMapProgram
3088 // =======================================================================
3089 const Handle(Graphic3d_ShaderProgram)& OpenGl_ShaderManager::GetBgCubeMapProgram ()
3091 if (myBgCubeMapProgram.IsNull())
3093 myBgCubeMapProgram = new Graphic3d_ShaderProgram();
3095 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3096 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable("vec3 ViewDirection", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
3097 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("samplerCube occSampler0", Graphic3d_TOS_FRAGMENT));
3098 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uYCoeff", Graphic3d_TOS_VERTEX));
3099 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uZCoeff", Graphic3d_TOS_VERTEX));
3101 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3102 + THE_FUNC_cubemap_vector_transform
3105 EOL" vec4 aViewDirection = occProjectionMatrixInverse * vec4(occVertex.xy, 0.0, 1.0);"
3106 EOL" aViewDirection /= aViewDirection.w;"
3107 EOL" aViewDirection.w = 0.0;"
3108 EOL" ViewDirection = normalize((occWorldViewMatrixInverse * aViewDirection).xyz);"
3109 EOL" ViewDirection = cubemapVectorTransform (ViewDirection, uYCoeff, uZCoeff);"
3110 EOL" gl_Position = vec4(occVertex.xy, 0.0, 1.0);"
3113 TCollection_AsciiString aSrcFrag =
3114 EOL"#define occEnvCubemap occSampler0"
3117 EOL" occSetFragColor (vec4(occTextureCube (occEnvCubemap, ViewDirection).rgb, 1.0));"
3120 defaultGlslVersion (myBgCubeMapProgram, "background_cubemap", 0);
3121 myBgCubeMapProgram->SetDefaultSampler (false);
3122 myBgCubeMapProgram->SetNbLightsMax (0);
3123 myBgCubeMapProgram->SetNbClipPlanesMax (0);
3124 myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3125 myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3128 return myBgCubeMapProgram;
3131 // =======================================================================
3132 // function : bindProgramWithState
3134 // =======================================================================
3135 Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
3137 const Standard_Boolean isBound = myContext->BindProgram (theProgram);
3139 && !theProgram.IsNull())
3141 theProgram->ApplyVariables (myContext);
3143 PushState (theProgram);
3147 // =======================================================================
3148 // function : BindMarkerProgram
3150 // =======================================================================
3151 Standard_Boolean OpenGl_ShaderManager::BindMarkerProgram (const Handle(OpenGl_TextureSet)& theTextures,
3152 Graphic3d_TypeOfShadingModel theShadingModel,
3153 Graphic3d_AlphaMode theAlphaMode,
3154 Standard_Boolean theHasVertColor,
3155 const Handle(OpenGl_ShaderProgram)& theCustomProgram)
3157 if (!theCustomProgram.IsNull()
3158 || myContext->caps->ffpEnable)
3160 return bindProgramWithState (theCustomProgram);
3163 Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, false, false);
3164 if (!theTextures.IsNull()
3165 && theTextures->HasPointSprite())
3167 aBits |= theTextures->Last()->IsAlpha() ? OpenGl_PO_PointSpriteA : OpenGl_PO_PointSprite;
3171 aBits |= OpenGl_PO_PointSimple;
3173 Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theShadingModel, aBits);
3174 return bindProgramWithState (aProgram);