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"
37 #include "../Shaders/Shaders_PointLightAttenuation_glsl.pxx"
38 #include "../Shaders/Shaders_TangentSpaceNormal_glsl.pxx"
40 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
44 //! Number specifying maximum number of light sources to prepare a GLSL program with unrolled loop.
45 const Standard_Integer THE_NB_UNROLLED_LIGHTS_MAX = 32;
47 //! Compute the size of array storing holding light sources definition.
48 static Standard_Integer roundUpMaxLightSources (Standard_Integer theNbLights)
50 Standard_Integer aMaxLimit = THE_NB_UNROLLED_LIGHTS_MAX;
51 for (; aMaxLimit < theNbLights; aMaxLimit *= 2) {}
57 //! Compute TexCoord value in Vertex Shader
58 const char THE_VARY_TexCoord_Trsf[] =
59 EOL" float aRotSin = occTextureTrsf_RotationSin();"
60 EOL" float aRotCos = occTextureTrsf_RotationCos();"
61 EOL" vec2 aTex2 = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
62 EOL" vec2 aCopy = aTex2;"
63 EOL" aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
64 EOL" aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
65 EOL" TexCoord = vec4(aTex2, occTexCoord.zw);";
67 //! Auxiliary function to flip gl_PointCoord vertically
68 #define THE_VEC2_glPointCoord "vec2 (gl_PointCoord.x, 1.0 - gl_PointCoord.y)"
70 //! Auxiliary function to transform normal from model to view coordinate system.
71 const char THE_FUNC_transformNormal_view[] =
72 EOL"vec3 transformNormal (in vec3 theNormal)"
74 EOL" vec4 aResult = occWorldViewMatrixInverseTranspose"
75 EOL" * occModelWorldMatrixInverseTranspose"
76 EOL" * vec4 (theNormal, 0.0);"
77 EOL" return normalize (aResult.xyz);"
80 //! The same function as THE_FUNC_transformNormal but is used in PBR pipeline.
81 //! The normals are expected to be in world coordinate system in PBR pipeline.
82 const char THE_FUNC_transformNormal_world[] =
83 EOL"vec3 transformNormal (in vec3 theNormal)"
85 EOL" vec4 aResult = occModelWorldMatrixInverseTranspose"
86 EOL" * vec4 (theNormal, 0.0);"
87 EOL" return normalize (aResult.xyz);"
90 //! Global shader variable for color definition with lighting enabled.
91 const char THE_FUNC_lightDef[] =
92 EOL"vec3 Ambient;" //!< Ambient contribution of light sources
93 EOL"vec3 Diffuse;" //!< Diffuse contribution of light sources
94 EOL"vec3 Specular;"; //!< Specular contribution of light sources
96 //! Global shader variable for color definition with lighting enabled.
97 const char THE_FUNC_PBR_lightDef[] =
98 EOL"vec3 DirectLighting;" //!< Accumulator of direct lighting from light sources
99 EOL"vec4 BaseColor;" //!< Base color (albedo) of material for PBR
100 EOL"float Metallic;" //!< Metallic coefficient of material
101 EOL"float NormalizedRoughness;" //!< Normalized roughness coefficient of material
102 EOL"float Roughness;" //!< Roughness coefficient of material
103 EOL"vec3 Emission;" //!< Light intensity emitted by material
104 EOL"float IOR;"; //!< Material's index of refraction
106 //! Function computes contribution of isotropic point light source
107 const char THE_FUNC_pointLight[] =
108 EOL"void pointLight (in int theId,"
109 EOL" in vec3 theNormal,"
110 EOL" in vec3 theView,"
111 EOL" in vec3 thePoint,"
112 EOL" in bool theIsFront)"
114 EOL" vec3 aLight = occLight_Position (theId);"
115 EOL" if (!occLight_IsHeadlight (theId))"
117 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
119 EOL" aLight -= thePoint;"
121 EOL" float aDist = length (aLight);"
122 EOL" float aRange = occLight_Range (theId);"
123 EOL" float anAtten = occPointLightAttenuation (aDist, aRange, occLight_LinearAttenuation (theId), occLight_ConstAttenuation (theId));"
124 EOL" if (anAtten <= 0.0) return;"
125 EOL" aLight /= aDist;"
127 EOL" vec3 aHalf = normalize (aLight + theView);"
129 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
130 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
131 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
133 EOL" float aSpecl = 0.0;"
134 EOL" if (aNdotL > 0.0)"
136 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
139 EOL" Diffuse += occLight_Diffuse (theId) * aNdotL * anAtten;"
140 EOL" Specular += occLight_Specular(theId) * aSpecl * anAtten;"
143 //! Function computes contribution of isotropic point light source
144 const char THE_FUNC_PBR_pointLight[] =
145 EOL"void pointLight (in int theId,"
146 EOL" in vec3 theNormal,"
147 EOL" in vec3 theView,"
148 EOL" in vec3 thePoint,"
149 EOL" in bool theIsFront)"
151 EOL" vec3 aLight = occLight_Position (theId);"
152 EOL" if (occLight_IsHeadlight (theId))"
154 EOL" aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 1.0));"
156 EOL" aLight -= thePoint;"
158 EOL" float aDist = length (aLight);"
159 EOL" float aRange = occLight_Range (theId);"
160 EOL" float anAtten = occPointLightAttenuation (aDist, aRange);"
161 EOL" if (anAtten <= 0.0) return;"
162 EOL" aLight /= aDist;"
164 EOL" theNormal = theIsFront ? theNormal : -theNormal;"
165 EOL" DirectLighting += occPBRIllumination (theView, aLight, theNormal,"
166 EOL" BaseColor, Metallic, Roughness, IOR,"
167 EOL" occLight_Specular (theId),"
168 EOL" occLight_Intensity(theId) * anAtten);"
171 //! Function computes contribution of spotlight source
172 const char THE_FUNC_spotLight[] =
173 EOL"void spotLight (in int theId,"
174 EOL" in vec3 theNormal,"
175 EOL" in vec3 theView,"
176 EOL" in vec3 thePoint,"
177 EOL" in bool theIsFront)"
179 EOL" vec3 aLight = occLight_Position (theId);"
180 EOL" vec3 aSpotDir = occLight_SpotDirection (theId);"
181 EOL" if (!occLight_IsHeadlight (theId))"
183 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
184 EOL" aSpotDir = vec3 (occWorldViewMatrix * vec4 (aSpotDir, 0.0));"
186 EOL" aLight -= thePoint;"
188 EOL" float aDist = length (aLight);"
189 EOL" float aRange = occLight_Range (theId);"
190 EOL" float anAtten = occPointLightAttenuation (aDist, aRange, occLight_LinearAttenuation (theId), occLight_ConstAttenuation (theId));"
191 EOL" if (anAtten <= 0.0) return;"
192 EOL" aLight /= aDist;"
194 EOL" aSpotDir = normalize (aSpotDir);"
196 EOL" float aCosA = dot (aSpotDir, -aLight);"
197 EOL" if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
202 EOL" float anExponent = occLight_SpotExponent (theId);"
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) * aNdotL * anAtten;"
221 EOL" Specular += occLight_Specular(theId) * 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);"
233 EOL" vec3 aSpotDir = occLight_SpotDirection (theId);"
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" float aRange = occLight_Range (theId);"
243 EOL" float anAtten = occPointLightAttenuation (aDist, aRange);"
244 EOL" if (anAtten <= 0.0) return;"
245 EOL" aLight /= aDist;"
247 EOL" aSpotDir = normalize (aSpotDir);"
249 EOL" float aCosA = dot (aSpotDir, -aLight);"
250 EOL" float aRelativeAngle = 2.0 * acos(aCosA) / occLight_SpotCutOff(theId);"
251 EOL" if (aCosA >= 1.0 || aRelativeAngle > 1.0)"
255 EOL" float anExponent = occLight_SpotExponent (theId);"
256 EOL" if ((1.0 - aRelativeAngle) <= anExponent)"
258 EOL" float anAngularAttenuationOffset = cos(0.5 * occLight_SpotCutOff(theId));"
259 EOL" float anAngularAttenuationScale = 1.0 / max(0.001, cos(0.5 * occLight_SpotCutOff(theId) * (1.0 - anExponent)) - anAngularAttenuationOffset);"
260 EOL" anAngularAttenuationOffset *= -anAngularAttenuationScale;"
261 EOL" float anAngularAttenuantion = clamp(aCosA * anAngularAttenuationScale + anAngularAttenuationOffset, 0.0, 1.0);"
262 EOL" anAtten *= anAngularAttenuantion * anAngularAttenuantion;"
264 EOL" theNormal = theIsFront ? theNormal : -theNormal;"
265 EOL" DirectLighting += occPBRIllumination (theView, aLight, theNormal,"
266 EOL" BaseColor, Metallic, Roughness, IOR,"
267 EOL" occLight_Specular(theId),"
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));"
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) * aNdotL;"
297 EOL" Specular += occLight_Specular (theId) * 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));"
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, aLight, theNormal,"
315 EOL" BaseColor, Metallic, Roughness, IOR,"
316 EOL" occLight_Specular (theId),"
317 EOL" occLight_Intensity(theId));"
320 //! The same as THE_FUNC_directionalLight but for the light with zero index
321 //! (avoids limitations on some mobile devices).
322 const char THE_FUNC_directionalLightFirst[] =
323 EOL"void directionalLightFirst (in vec3 theNormal,"
324 EOL" in vec3 theView,"
325 EOL" in bool theIsFront)"
327 EOL" vec3 aLight = normalize (occLight_Position(0));"
328 EOL" if (!occLight_IsHeadlight (0))"
330 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
333 EOL" vec3 aHalf = normalize (aLight + theView);"
335 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
336 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
337 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
339 EOL" float aSpecl = 0.0;"
340 EOL" if (aNdotL > 0.0)"
342 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
345 EOL" Diffuse += occLight_Diffuse(0) * aNdotL;"
346 EOL" Specular += occLight_Specular(0) * aSpecl;"
349 //! Returns the real cubemap fetching direction considering sides orientation, memory layout and vertical flip.
350 const char THE_FUNC_cubemap_vector_transform[] =
351 EOL"vec3 cubemapVectorTransform (in vec3 theVector,"
352 EOL" in int theYCoeff,"
353 EOL" in int theZCoeff)"
355 EOL" theVector = theVector.yzx;"
356 EOL" theVector.y *= float(theYCoeff);"
357 EOL" theVector.z *= float(theZCoeff);"
358 EOL" return theVector;"
361 //! Process clipping planes in Fragment Shader.
362 //! Should be added at the beginning of the main() function.
363 const char THE_FRAG_CLIP_PLANES_N[] =
364 EOL" for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount; ++aPlaneIter)"
366 EOL" vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
367 EOL" if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
373 //! Process chains of clipping planes in Fragment Shader.
374 const char THE_FRAG_CLIP_CHAINS_N[] =
375 EOL" for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount;)"
377 EOL" vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
378 EOL" if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
380 EOL" if (occClipPlaneChains[aPlaneIter] == 1)"
384 EOL" aPlaneIter += 1;"
388 EOL" aPlaneIter += occClipPlaneChains[aPlaneIter];"
392 //! Process 1 clipping plane in Fragment Shader.
393 const char THE_FRAG_CLIP_PLANES_1[] =
394 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
395 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0)"
400 //! Process 2 clipping planes in Fragment Shader.
401 const char THE_FRAG_CLIP_PLANES_2[] =
402 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
403 EOL" vec4 aClipEquation1 = occClipPlaneEquations[1];"
404 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
405 EOL" || dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
410 //! Process a chain of 2 clipping planes in Fragment Shader (3/4 section).
411 const char THE_FRAG_CLIP_CHAINS_2[] =
412 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
413 EOL" vec4 aClipEquation1 = occClipPlaneEquations[1];"
414 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
415 EOL" && dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
420 //! Modify color for Wireframe presentation.
421 const char THE_FRAG_WIREFRAME_COLOR[] =
422 EOL"vec4 getFinalColor(void)"
424 EOL" float aDistance = min (min (EdgeDistance[0], EdgeDistance[1]), EdgeDistance[2]);"
425 EOL" bool isHollow = occWireframeColor.a < 0.0;"
426 EOL" float aMixVal = smoothstep (occLineWidth - occLineFeather * 0.5, occLineWidth + occLineFeather * 0.5, aDistance);"
427 EOL" vec4 aMixColor = isHollow"
428 EOL" ? vec4 (getColor().rgb, 1.0 - aMixVal)" // edges only (of interior color)
429 EOL" : mix (occWireframeColor, getColor(), aMixVal);" // interior + edges
430 EOL" return aMixColor;"
433 //! Compute gl_Position vertex shader output.
434 const char THE_VERT_gl_Position[] =
435 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;";
437 //! Displace gl_Position alongside vertex normal for outline rendering.
438 //! This code adds silhouette only for smooth surfaces of closed primitive, and produces visual artifacts on sharp edges.
439 const char THE_VERT_gl_Position_OUTLINE[] =
440 EOL" float anOutlineDisp = occOrthoScale > 0.0 ? occOrthoScale : gl_Position.w;"
441 EOL" vec4 anOutlinePos = occVertex + vec4 (occNormal * (occSilhouetteThickness * anOutlineDisp), 0.0);"
442 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * anOutlinePos;";
444 #if !defined(GL_ES_VERSION_2_0)
446 static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
447 static const GLfloat THE_DEFAULT_SPOT_DIR[3] = { 0.0f, 0.0f, -1.0f };
448 static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
449 static const GLfloat THE_DEFAULT_SPOT_CUTOFF = 180.0f;
451 //! Bind FFP light source.
452 static void bindLight (const Graphic3d_CLight& theLight,
453 const GLenum theLightGlId,
454 const OpenGl_Mat4& theModelView,
455 OpenGl_Context* theCtx)
457 // the light is a headlight?
458 if (theLight.IsHeadlight())
460 theCtx->core11->glMatrixMode (GL_MODELVIEW);
461 theCtx->core11->glLoadIdentity();
465 const Graphic3d_Vec4& aLightColor = theLight.PackedColor();
466 switch (theLight.Type())
468 case Graphic3d_TOLS_AMBIENT : break; // handled by separate if-clause at beginning of method
469 case Graphic3d_TOLS_DIRECTIONAL:
471 // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
472 const OpenGl_Vec4 anInfDir = -theLight.PackedDirectionRange();
474 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
475 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
476 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
477 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
478 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, anInfDir.GetData());
479 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
480 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
481 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
484 case Graphic3d_TOLS_POSITIONAL:
486 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
487 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
488 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
489 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
490 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
491 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
492 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
493 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
494 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
495 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
496 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
497 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
500 case Graphic3d_TOLS_SPOT:
502 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
503 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
504 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
505 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
506 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
507 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, theLight.PackedDirectionRange().GetData());
508 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, theLight.Concentration() * 128.0f);
509 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, (theLight.Angle() * 180.0f) / GLfloat(M_PI));
510 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
511 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
512 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
517 // restore matrix in case of headlight
518 if (theLight.IsHeadlight())
520 theCtx->core11->glLoadMatrixf (theModelView.GetData());
523 glEnable (theLightGlId);
527 //! Generate map key for light sources configuration.
528 static TCollection_AsciiString genLightKey (const Handle(Graphic3d_LightSet)& theLights)
530 if (theLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
532 return TCollection_AsciiString ("l_") + theLights->KeyEnabledLong();
535 const Standard_Integer aMaxLimit = roundUpMaxLightSources (theLights->NbEnabled());
536 return TCollection_AsciiString ("l_") + theLights->KeyEnabledShort() + aMaxLimit;
540 // =======================================================================
541 // function : OpenGl_ShaderManager
542 // purpose : Creates new empty shader manager
543 // =======================================================================
544 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
545 : myFfpProgram (new OpenGl_ShaderProgramFFP()),
546 myShadingModel (Graphic3d_TOSM_VERTEX),
547 myUnlitPrograms (new OpenGl_SetOfPrograms()),
548 myContext (theContext),
549 mySRgbState (theContext->ToRenderSRGB()),
550 myHasLocalOrigin (Standard_False),
556 // =======================================================================
557 // function : ~OpenGl_ShaderManager
558 // purpose : Releases resources of shader manager
559 // =======================================================================
560 OpenGl_ShaderManager::~OpenGl_ShaderManager()
562 myProgramList.Clear();
563 if (!myPBREnvironment.IsNull())
565 myPBREnvironment->Release (myContext);
569 // =======================================================================
572 // =======================================================================
573 void OpenGl_ShaderManager::clear()
575 myProgramList.Clear();
576 myLightPrograms.Nullify();
577 myUnlitPrograms = new OpenGl_SetOfPrograms();
578 myOutlinePrograms.Nullify();
579 myMapOfLightPrograms.Clear();
580 myFontProgram.Nullify();
581 myBlitPrograms[0].Init (Handle(OpenGl_ShaderProgram)());
582 myBlitPrograms[1].Init (Handle(OpenGl_ShaderProgram)());
583 myBoundBoxProgram.Nullify();
584 myBoundBoxVertBuffer.Nullify();
585 for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
587 myStereoPrograms[aModeIter].Nullify();
589 switchLightPrograms();
592 // =======================================================================
594 // purpose : Creates new shader program
595 // =======================================================================
596 Standard_Boolean OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
597 TCollection_AsciiString& theShareKey,
598 Handle(OpenGl_ShaderProgram)& theProgram)
600 theProgram.Nullify();
601 if (theProxy.IsNull())
603 return Standard_False;
606 theShareKey = theProxy->GetId();
607 if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
609 if (theProgram->Share())
611 myProgramList.Append (theProgram);
613 return Standard_True;
616 theProgram = new OpenGl_ShaderProgram (theProxy);
617 if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
619 theProgram->Release (myContext);
621 theProgram.Nullify();
622 return Standard_False;
625 myProgramList.Append (theProgram);
626 myContext->ShareResource (theShareKey, theProgram);
627 return Standard_True;
630 // =======================================================================
631 // function : Unregister
632 // purpose : Removes specified shader program from the manager
633 // =======================================================================
634 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString& theShareKey,
635 Handle(OpenGl_ShaderProgram)& theProgram)
637 for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
639 if (anIt.Value() == theProgram)
641 if (!theProgram->UnShare())
644 theProgram.Nullify();
648 myProgramList.Remove (anIt);
653 const TCollection_AsciiString anID = theProgram->myProxy->GetId();
656 myContext->DelayedRelease (theProgram);
657 theProgram.Nullify();
661 theProgram.Nullify();
662 myContext->ReleaseResource (anID, Standard_True);
666 // =======================================================================
667 // function : ShaderPrograms
668 // purpose : Returns list of registered shader programs
669 // =======================================================================
670 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
672 return myProgramList;
675 // =======================================================================
677 // purpose : Returns true if no program objects are attached
678 // =======================================================================
679 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
681 return myProgramList.IsEmpty();
684 // =======================================================================
685 // function : switchLightPrograms
687 // =======================================================================
688 void OpenGl_ShaderManager::switchLightPrograms()
690 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
691 if (aLights.IsNull())
693 if (!myMapOfLightPrograms.Find ("unlit", myLightPrograms))
695 myLightPrograms = new OpenGl_SetOfShaderPrograms (myUnlitPrograms);
696 myMapOfLightPrograms.Bind ("unlit", myLightPrograms);
701 const TCollection_AsciiString aKey = genLightKey (aLights);
702 if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
704 myLightPrograms = new OpenGl_SetOfShaderPrograms();
705 myMapOfLightPrograms.Bind (aKey, myLightPrograms);
709 // =======================================================================
710 // function : UpdateSRgbState
712 // =======================================================================
713 void OpenGl_ShaderManager::UpdateSRgbState()
715 if (mySRgbState == myContext->ToRenderSRGB())
720 mySRgbState = myContext->ToRenderSRGB();
722 // special cases - GLSL programs dealing with sRGB/linearRGB internally
723 myStereoPrograms[Graphic3d_StereoMode_Anaglyph].Nullify();
726 // =======================================================================
727 // function : UpdateLightSourceStateTo
728 // purpose : Updates state of OCCT light sources
729 // =======================================================================
730 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights,
731 Standard_Integer theSpecIBLMapLevels)
733 myLightSourceState.Set (theLights);
734 myLightSourceState.SetSpecIBLMapLevels (theSpecIBLMapLevels);
735 myLightSourceState.Update();
736 switchLightPrograms();
739 // =======================================================================
740 // function : UpdateLightSourceState
742 // =======================================================================
743 void OpenGl_ShaderManager::UpdateLightSourceState()
745 myLightSourceState.Update();
748 // =======================================================================
749 // function : SetShadingModel
751 // =======================================================================
752 void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
754 if (theModel == Graphic3d_TOSM_DEFAULT)
756 throw Standard_ProgramError ("OpenGl_ShaderManager::SetShadingModel() - attempt to set invalid Shading Model!");
759 myShadingModel = theModel;
760 switchLightPrograms();
763 // =======================================================================
764 // function : SetProjectionState
765 // purpose : Sets new state of OCCT projection transform
766 // =======================================================================
767 void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
769 myProjectionState.Set (theProjectionMatrix);
770 myProjectionState.Update();
773 // =======================================================================
774 // function : SetModelWorldState
775 // purpose : Sets new state of OCCT model-world transform
776 // =======================================================================
777 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
779 myModelWorldState.Set (theModelWorldMatrix);
780 myModelWorldState.Update();
783 // =======================================================================
784 // function : SetWorldViewState
785 // purpose : Sets new state of OCCT world-view transform
786 // =======================================================================
787 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
789 myWorldViewState.Set (theWorldViewMatrix);
790 myWorldViewState.Update();
793 // =======================================================================
794 // function : pushLightSourceState
796 // =======================================================================
797 void OpenGl_ShaderManager::pushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
799 theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
800 if (theProgram == myFfpProgram)
802 #if !defined(GL_ES_VERSION_2_0)
803 if (myContext->core11 == NULL)
808 GLenum aLightGlId = GL_LIGHT0;
809 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
810 for (Graphic3d_LightSet::Iterator aLightIt (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
811 aLightIt.More(); aLightIt.Next())
813 if (aLightGlId > GL_LIGHT7) // only 8 lights in FFP...
815 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
816 "Warning: light sources limit (8) has been exceeded within Fixed-function pipeline.");
820 bindLight (*aLightIt.Value(), aLightGlId, aModelView, myContext);
824 // apply accumulated ambient color
825 const Graphic3d_Vec4 anAmbient = !myLightSourceState.LightSources().IsNull()
826 ? myLightSourceState.LightSources()->AmbientColor()
827 : Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
828 myContext->core11->glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbient.GetData());
830 // GL_LIGHTING is managed by drawers to switch between shaded / no lighting output,
831 // therefore managing the state here does not have any effect - do it just for consistency.
832 if (aLightGlId != GL_LIGHT0)
834 ::glEnable (GL_LIGHTING);
838 ::glDisable (GL_LIGHTING);
840 // switch off unused lights
841 for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
843 ::glDisable (aLightGlId);
849 const Standard_Integer aNbLightsMax = theProgram->NbLightsMax();
850 const GLint anAmbientLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT);
851 if (aNbLightsMax == 0
852 && anAmbientLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
857 if (myLightTypeArray.Size() < aNbLightsMax)
859 myLightTypeArray .Resize (0, aNbLightsMax - 1, false);
860 myLightParamsArray.Resize (0, aNbLightsMax - 1, false);
862 for (Standard_Integer aLightIt = 0; aLightIt < aNbLightsMax; ++aLightIt)
864 myLightTypeArray.SetValue (aLightIt, -1);
867 if (myLightSourceState.LightSources().IsNull()
868 || myLightSourceState.LightSources()->IsEmpty())
870 theProgram->SetUniform (myContext,
871 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
873 theProgram->SetUniform (myContext,
875 OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
876 theProgram->SetUniform (myContext,
877 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
879 &myLightTypeArray.First());
883 Standard_Integer aLightsNb = 0;
884 for (Graphic3d_LightSet::Iterator anIter (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
885 anIter.More(); anIter.Next())
887 const Graphic3d_CLight& aLight = *anIter.Value();
888 if (aLightsNb >= aNbLightsMax)
890 if (aNbLightsMax != 0)
892 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
893 TCollection_AsciiString("Warning: light sources limit (") + aNbLightsMax + ") has been exceeded.");
898 Standard_Integer& aLightType = myLightTypeArray .ChangeValue (aLightsNb);
899 OpenGl_ShaderLightParameters& aLightParams = myLightParamsArray.ChangeValue (aLightsNb);
900 if (!aLight.IsEnabled()) // has no affect with Graphic3d_LightSet::IterationFilter_ExcludeDisabled - here just for consistency
902 // 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
903 aLightType = -1; // Graphic3d_TOLS_AMBIENT can be used instead
904 aLightParams.Color = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f);
909 // ignoring OpenGl_Context::ToRenderSRGB() for light colors,
910 // as non-absolute colors for lights are rare and require tuning anyway
911 aLightType = aLight.Type();
912 aLightParams.Color = aLight.PackedColor();
913 aLightParams.Color.a() = aLight.Intensity(); // used by PBR and ignored by old shading model
914 if (aLight.Type() == Graphic3d_TOLS_DIRECTIONAL)
916 aLightParams.Position = -aLight.PackedDirectionRange();
918 else if (!aLight.IsHeadlight())
920 aLightParams.Position.x() = static_cast<float>(aLight.Position().X() - myLocalOrigin.X());
921 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y() - myLocalOrigin.Y());
922 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z() - myLocalOrigin.Z());
926 aLightParams.Position.x() = static_cast<float>(aLight.Position().X());
927 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y());
928 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z());
930 aLightParams.Position.w() = aLight.IsHeadlight() ? 1.0f : 0.0f;
932 if (aLight.Type() == Graphic3d_TOLS_SPOT)
934 aLightParams.Direction = aLight.PackedDirectionRange();
936 if (aLight.Type() == Graphic3d_TOLS_POSITIONAL)
938 aLightParams.Direction.w() = aLight.Range();
940 aLightParams.Parameters = aLight.PackedParams();
944 const Graphic3d_Vec4& anAmbient = myLightSourceState.LightSources()->AmbientColor();
945 theProgram->SetUniform (myContext,
946 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
948 theProgram->SetUniform (myContext,
951 theProgram->SetUniform (myContext,
952 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
954 &myLightTypeArray.First());
957 theProgram->SetUniform (myContext,
958 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
959 aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
960 myLightParamsArray.First().Packed());
963 if (const OpenGl_ShaderUniformLocation aLocation = theProgram->GetStateLocation (OpenGl_OCCT_NB_SPEC_IBL_LEVELS))
965 theProgram->SetUniform (myContext, aLocation, myLightSourceState.SpecIBLMapLevels());
969 // =======================================================================
970 // function : pushProjectionState
972 // =======================================================================
973 void OpenGl_ShaderManager::pushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
975 theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
976 if (theProgram == myFfpProgram)
978 #if !defined(GL_ES_VERSION_2_0)
979 if (myContext->core11 != NULL)
981 myContext->core11->glMatrixMode (GL_PROJECTION);
982 myContext->core11->glLoadMatrixf (myProjectionState.ProjectionMatrix());
988 theProgram->SetUniform (myContext,
989 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
990 myProjectionState.ProjectionMatrix());
992 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
993 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
995 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
998 theProgram->SetUniform (myContext,
999 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
1000 myProjectionState.ProjectionMatrix(), true);
1002 aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
1003 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1005 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
1009 // =======================================================================
1010 // function : pushModelWorldState
1012 // =======================================================================
1013 void OpenGl_ShaderManager::pushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1015 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1016 if (theProgram == myFfpProgram)
1018 #if !defined(GL_ES_VERSION_2_0)
1019 if (myContext->core11 != NULL)
1021 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1022 myContext->core11->glMatrixMode (GL_MODELVIEW);
1023 myContext->core11->glLoadMatrixf (aModelView.GetData());
1024 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1030 theProgram->SetUniform (myContext,
1031 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
1032 myModelWorldState.ModelWorldMatrix());
1034 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
1035 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1037 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
1040 theProgram->SetUniform (myContext,
1041 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
1042 myModelWorldState.ModelWorldMatrix(), true);
1044 aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
1045 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1047 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
1051 // =======================================================================
1052 // function : pushWorldViewState
1054 // =======================================================================
1055 void OpenGl_ShaderManager::pushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1057 if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
1062 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1063 if (theProgram == myFfpProgram)
1065 #if !defined(GL_ES_VERSION_2_0)
1066 if (myContext->core11 != NULL)
1068 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1069 myContext->core11->glMatrixMode (GL_MODELVIEW);
1070 myContext->core11->glLoadMatrixf (aModelView.GetData());
1071 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1077 theProgram->SetUniform (myContext,
1078 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
1079 myWorldViewState.WorldViewMatrix());
1081 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
1082 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1084 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
1087 theProgram->SetUniform (myContext,
1088 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
1089 myWorldViewState.WorldViewMatrix(), true);
1091 aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
1092 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1094 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
1098 // =======================================================================
1099 // function : UpdateClippingState
1100 // purpose : Updates state of OCCT clipping planes
1101 // =======================================================================
1102 void OpenGl_ShaderManager::UpdateClippingState()
1104 myClippingState.Update();
1107 // =======================================================================
1108 // function : RevertClippingState
1109 // purpose : Reverts state of OCCT clipping planes
1110 // =======================================================================
1111 void OpenGl_ShaderManager::RevertClippingState()
1113 myClippingState.Revert();
1116 // =======================================================================
1117 // function : pushClippingState
1119 // =======================================================================
1120 void OpenGl_ShaderManager::pushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1122 theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
1123 if (theProgram == myFfpProgram)
1125 #if !defined(GL_ES_VERSION_2_0)
1126 if (myContext->core11 == NULL)
1131 const Standard_Integer aNbMaxPlanes = myContext->MaxClipPlanes();
1132 if (myClipPlaneArrayFfp.Size() < aNbMaxPlanes)
1134 myClipPlaneArrayFfp.Resize (0, aNbMaxPlanes - 1, false);
1137 Standard_Integer aPlaneId = 0;
1138 Standard_Boolean toRestoreModelView = Standard_False;
1139 const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1140 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1142 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1143 if (aPlaneIter.IsDisabled()
1144 || aPlane->IsChain()
1145 || (aPlane == aCappedChain
1146 && myContext->Clipping().IsCappingEnableAllExcept()))
1150 else if (aPlaneId >= aNbMaxPlanes)
1152 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
1153 TCollection_ExtendedString("Warning: clipping planes limit (") + aNbMaxPlanes + ") has been exceeded.");
1157 const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
1158 OpenGl_Vec4d& aPlaneEq = myClipPlaneArrayFfp.ChangeValue (aPlaneId);
1159 aPlaneEq.x() = anEquation.x();
1160 aPlaneEq.y() = anEquation.y();
1161 aPlaneEq.z() = anEquation.z();
1162 aPlaneEq.w() = anEquation.w();
1163 if (myHasLocalOrigin)
1165 const gp_XYZ aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
1166 const Standard_Real aD = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
1170 const GLenum anFfpPlaneID = GL_CLIP_PLANE0 + aPlaneId;
1171 if (anFfpPlaneID == GL_CLIP_PLANE0)
1173 // set either identity or pure view matrix
1174 toRestoreModelView = Standard_True;
1175 myContext->core11->glMatrixMode (GL_MODELVIEW);
1176 myContext->core11->glLoadMatrixf (myWorldViewState.WorldViewMatrix().GetData());
1179 ::glEnable (anFfpPlaneID);
1180 myContext->core11->glClipPlane (anFfpPlaneID, aPlaneEq);
1185 // switch off unused lights
1186 for (; aPlaneId < aNbMaxPlanes; ++aPlaneId)
1188 ::glDisable (GL_CLIP_PLANE0 + aPlaneId);
1191 // restore combined model-view matrix
1192 if (toRestoreModelView)
1194 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1195 myContext->core11->glLoadMatrixf (aModelView.GetData());
1201 const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
1202 if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION)
1207 const Standard_Integer aNbClipPlanesMax = theProgram->NbClipPlanesMax();
1208 const Standard_Integer aNbPlanes = Min (myContext->Clipping().NbClippingOrCappingOn(), aNbClipPlanesMax);
1211 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), 0);
1215 if (myClipPlaneArray.Size() < aNbClipPlanesMax)
1217 myClipPlaneArray.Resize (0, aNbClipPlanesMax - 1, false);
1218 myClipChainArray.Resize (0, aNbClipPlanesMax - 1, false);
1221 Standard_Integer aPlaneId = 0;
1222 const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1223 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1225 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1226 if (aPlaneIter.IsDisabled())
1231 if (myContext->Clipping().IsCappingDisableAllExcept())
1233 // enable only specific (sub) plane
1234 if (aPlane != aCappedChain)
1239 Standard_Integer aSubPlaneIndex = 1;
1240 for (const Graphic3d_ClipPlane* aSubPlaneIter = aCappedChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1242 if (aSubPlaneIndex == myContext->Clipping().CappedSubPlane())
1244 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), 1);
1250 else if (aPlane == aCappedChain) // && myContext->Clipping().IsCappingEnableAllExcept()
1252 // enable sub-planes within processed Chain as reversed and ORed, excluding filtered plane
1253 if (aPlaneId + aPlane->NbChainNextPlanes() - 1 > aNbClipPlanesMax)
1255 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1256 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1260 Standard_Integer aSubPlaneIndex = 1;
1261 for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1263 if (aSubPlaneIndex != -myContext->Clipping().CappedSubPlane())
1265 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->ReversedEquation(), 1);
1272 if (aPlaneId + aPlane->NbChainNextPlanes() > aNbClipPlanesMax)
1274 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1275 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1278 for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get())
1280 addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), aSubPlaneIter->NbChainNextPlanes());
1285 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), aPlaneId);
1286 theProgram->SetUniform (myContext, aLocEquations, aNbClipPlanesMax, &myClipPlaneArray.First());
1287 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_CHAINS), aNbClipPlanesMax, &myClipChainArray.First());
1290 // =======================================================================
1291 // function : pushMaterialState
1293 // =======================================================================
1294 void OpenGl_ShaderManager::pushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1296 const OpenGl_Material& aFrontMat = myMaterialState.FrontMaterial();
1297 const OpenGl_Material& aBackMat = myMaterialState.BackMaterial();
1298 theProgram->UpdateState (OpenGl_MATERIAL_STATE, myMaterialState.Index());
1299 if (theProgram == myFfpProgram)
1301 #if !defined(GL_ES_VERSION_2_0)
1302 if (myContext->core11 == NULL)
1307 if (myMaterialState.AlphaCutoff() < ShortRealLast())
1309 glAlphaFunc (GL_GEQUAL, myMaterialState.AlphaCutoff());
1310 glEnable (GL_ALPHA_TEST);
1314 glDisable (GL_ALPHA_TEST);
1317 const GLenum aFrontFace = myMaterialState.ToDistinguish() ? GL_FRONT : GL_FRONT_AND_BACK;
1318 myContext->core11->glMaterialfv(aFrontFace, GL_AMBIENT, aFrontMat.Common.Ambient.GetData());
1319 myContext->core11->glMaterialfv(aFrontFace, GL_DIFFUSE, aFrontMat.Common.Diffuse.GetData());
1320 myContext->core11->glMaterialfv(aFrontFace, GL_SPECULAR, aFrontMat.Common.Specular.GetData());
1321 myContext->core11->glMaterialfv(aFrontFace, GL_EMISSION, aFrontMat.Common.Emission.GetData());
1322 myContext->core11->glMaterialf (aFrontFace, GL_SHININESS, aFrontMat.Common.Shine());
1323 if (myMaterialState.ToDistinguish())
1325 myContext->core11->glMaterialfv(GL_BACK, GL_AMBIENT, aBackMat.Common.Ambient.GetData());
1326 myContext->core11->glMaterialfv(GL_BACK, GL_DIFFUSE, aBackMat.Common.Diffuse.GetData());
1327 myContext->core11->glMaterialfv(GL_BACK, GL_SPECULAR, aBackMat.Common.Specular.GetData());
1328 myContext->core11->glMaterialfv(GL_BACK, GL_EMISSION, aBackMat.Common.Emission.GetData());
1329 myContext->core11->glMaterialf (GL_BACK, GL_SHININESS, aBackMat.Common.Shine());
1335 theProgram->SetUniform (myContext,
1336 theProgram->GetStateLocation (OpenGl_OCCT_ALPHA_CUTOFF),
1337 myMaterialState.AlphaCutoff());
1338 theProgram->SetUniform (myContext,
1339 theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
1340 myMaterialState.ToMapTexture() ? 1 : 0);
1341 theProgram->SetUniform (myContext,
1342 theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
1343 myMaterialState.ToDistinguish() ? 1 : 0);
1345 if (const OpenGl_ShaderUniformLocation& aLocPbrFront = theProgram->GetStateLocation (OpenGl_OCCT_PBR_FRONT_MATERIAL))
1347 theProgram->SetUniform (myContext, aLocPbrFront, OpenGl_MaterialPBR::NbOfVec4(),
1348 aFrontMat.Pbr.Packed());
1350 if (const OpenGl_ShaderUniformLocation aLocPbrBack = theProgram->GetStateLocation (OpenGl_OCCT_PBR_BACK_MATERIAL))
1352 theProgram->SetUniform (myContext, aLocPbrBack, OpenGl_MaterialPBR::NbOfVec4(),
1353 aBackMat.Pbr.Packed());
1355 if (const OpenGl_ShaderUniformLocation aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_FRONT_MATERIAL))
1357 theProgram->SetUniform (myContext, aLocFront, OpenGl_MaterialCommon::NbOfVec4(),
1358 aFrontMat.Common.Packed());
1360 if (const OpenGl_ShaderUniformLocation aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_BACK_MATERIAL))
1362 theProgram->SetUniform (myContext, aLocBack, OpenGl_MaterialCommon::NbOfVec4(),
1363 aBackMat.Common.Packed());
1367 // =======================================================================
1368 // function : pushOitState
1370 // =======================================================================
1371 void OpenGl_ShaderManager::pushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1373 const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
1374 if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
1376 theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
1379 const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
1380 if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
1382 theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
1386 // =======================================================================
1387 // function : PushInteriorState
1389 // =======================================================================
1390 void OpenGl_ShaderManager::PushInteriorState (const Handle(OpenGl_ShaderProgram)& theProgram,
1391 const Handle(Graphic3d_Aspects)& theAspect) const
1393 if (theProgram.IsNull()
1394 || !theProgram->IsValid())
1399 if (const OpenGl_ShaderUniformLocation aLocLineWidth = theProgram->GetStateLocation (OpenGl_OCCT_LINE_WIDTH))
1401 theProgram->SetUniform (myContext, aLocLineWidth, theAspect->EdgeWidth() * myContext->LineWidthScale());
1402 theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCCT_LINE_FEATHER), myContext->LineFeather() * myContext->LineWidthScale());
1404 if (const OpenGl_ShaderUniformLocation aLocWireframeColor = theProgram->GetStateLocation (OpenGl_OCCT_WIREFRAME_COLOR))
1406 if (theAspect->InteriorStyle() == Aspect_IS_HOLLOW)
1408 theProgram->SetUniform (myContext, aLocWireframeColor, OpenGl_Vec4 (-1.0f, -1.0f, -1.0f, -1.0f));
1412 theProgram->SetUniform (myContext, aLocWireframeColor, myContext->Vec4FromQuantityColor (theAspect->EdgeColorRGBA()));
1415 if (const OpenGl_ShaderUniformLocation aLocQuadModeState = theProgram->GetStateLocation (OpenGl_OCCT_QUAD_MODE_STATE))
1417 theProgram->SetUniform (myContext, aLocQuadModeState, theAspect->ToSkipFirstEdge() ? 1 : 0);
1421 // =======================================================================
1422 // function : PushState
1423 // purpose : Pushes state of OCCT graphics parameters to the program
1424 // =======================================================================
1425 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram,
1426 Graphic3d_TypeOfShadingModel theShadingModel) const
1428 const Handle(OpenGl_ShaderProgram)& aProgram = !theProgram.IsNull() ? theProgram : myFfpProgram;
1429 PushClippingState (aProgram);
1430 PushWorldViewState (aProgram);
1431 PushModelWorldState (aProgram);
1432 PushProjectionState (aProgram);
1433 PushLightSourceState (aProgram);
1434 PushMaterialState (aProgram);
1435 PushOitState (aProgram);
1437 if (!theProgram.IsNull())
1439 if (const OpenGl_ShaderUniformLocation& aLocViewPort = theProgram->GetStateLocation (OpenGl_OCCT_VIEWPORT))
1441 theProgram->SetUniform (myContext, aLocViewPort, OpenGl_Vec4 ((float )myContext->Viewport()[0], (float )myContext->Viewport()[1],
1442 (float )myContext->Viewport()[2], (float )myContext->Viewport()[3]));
1445 #if !defined(GL_ES_VERSION_2_0)
1446 else if (myContext->core11 != NULL)
1448 // manage FFP lighting
1449 myContext->SetShadeModel (theShadingModel);
1450 if (theShadingModel == Graphic3d_TOSM_UNLIT)
1452 glDisable (GL_LIGHTING);
1456 glEnable (GL_LIGHTING);
1460 (void )theShadingModel;
1464 // =======================================================================
1465 // function : prepareStdProgramFont
1467 // =======================================================================
1468 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
1470 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1471 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
1472 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1474 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
1477 EOL" TexCoord = occTexCoord.st;"
1478 + THE_VERT_gl_Position
1481 TCollection_AsciiString
1482 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
1483 #if !defined(GL_ES_VERSION_2_0)
1484 if (myContext->core11 == NULL)
1486 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
1490 TCollection_AsciiString aSrcFrag =
1494 EOL" vec4 aColor = occColor;"
1495 EOL" aColor.a *= getAlpha();"
1496 EOL" if (aColor.a <= 0.285) discard;"
1497 EOL" occSetFragColor (aColor);"
1500 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1501 defaultGlslVersion (aProgramSrc, "font", 0);
1502 aProgramSrc->SetDefaultSampler (false);
1503 aProgramSrc->SetNbLightsMax (0);
1504 aProgramSrc->SetNbClipPlanesMax (0);
1505 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1506 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1507 TCollection_AsciiString aKey;
1508 if (!Create (aProgramSrc, aKey, myFontProgram))
1510 myFontProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1511 return Standard_False;
1513 return Standard_True;
1516 // =======================================================================
1517 // function : BindFboBlitProgram
1519 // =======================================================================
1520 Standard_Boolean OpenGl_ShaderManager::BindFboBlitProgram (Standard_Integer theNbSamples,
1521 Standard_Boolean theIsFallback_sRGB)
1523 NCollection_Array1<Handle(OpenGl_ShaderProgram)>& aList = myBlitPrograms[theIsFallback_sRGB ? 1 : 0];
1524 Standard_Integer aNbSamples = Max (theNbSamples, 1);
1525 if (aNbSamples > aList.Upper())
1527 aList.Resize (1, aNbSamples, true);
1530 Handle(OpenGl_ShaderProgram)& aProg = aList[aNbSamples];
1533 prepareStdProgramFboBlit (aProg, aNbSamples, theIsFallback_sRGB);
1535 return !aProg.IsNull()
1536 && myContext->BindProgram (aProg);
1539 // =======================================================================
1540 // function : prepareStdProgramFboBlit
1542 // =======================================================================
1543 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit (Handle(OpenGl_ShaderProgram)& theProgram,
1544 Standard_Integer theNbSamples,
1545 Standard_Boolean theIsFallback_sRGB)
1547 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1548 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1550 TCollection_AsciiString aSrcVert =
1553 EOL" TexCoord = occVertex.zw;"
1554 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
1557 TCollection_AsciiString aSrcFrag;
1558 if (theNbSamples > 1)
1560 #if defined(GL_ES_VERSION_2_0)
1561 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1562 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1564 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1565 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1567 aSrcFrag = TCollection_AsciiString()
1568 + EOL"#define THE_NUM_SAMPLES " + theNbSamples
1569 + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1572 EOL" ivec2 aSize = textureSize (uColorSampler);"
1573 EOL" ivec2 anUV = ivec2 (vec2 (aSize) * TexCoord);"
1574 EOL" gl_FragDepth = texelFetch (uDepthSampler, anUV, THE_NUM_SAMPLES / 2 - 1).r;"
1576 EOL" vec4 aColor = vec4 (0.0);"
1577 EOL" for (int aSample = 0; aSample < THE_NUM_SAMPLES; ++aSample)"
1579 EOL" vec4 aVal = texelFetch (uColorSampler, anUV, aSample);"
1580 EOL" aColor += aVal;"
1582 EOL" aColor /= float(THE_NUM_SAMPLES);"
1583 EOL"#ifdef THE_SHIFT_sRGB"
1584 EOL" aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1586 EOL" occSetFragColor (aColor);"
1591 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uColorSampler", Graphic3d_TOS_FRAGMENT));
1592 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uDepthSampler", Graphic3d_TOS_FRAGMENT));
1593 aSrcFrag = TCollection_AsciiString()
1594 + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1597 EOL" gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
1598 EOL" vec4 aColor = occTexture2D (uColorSampler, TexCoord);"
1599 EOL"#ifdef THE_SHIFT_sRGB"
1600 EOL" aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1602 EOL" occSetFragColor (aColor);"
1606 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1607 #if defined(GL_ES_VERSION_2_0)
1608 if (myContext->IsGlGreaterEqual (3, 1))
1610 // required for MSAA sampler
1611 aProgramSrc->SetHeader ("#version 310 es");
1613 else if (myContext->IsGlGreaterEqual (3, 0))
1615 aProgramSrc->SetHeader ("#version 300 es");
1617 else if (myContext->extFragDepth)
1619 aProgramSrc->SetHeader ("#extension GL_EXT_frag_depth : enable"
1620 EOL"#define gl_FragDepth gl_FragDepthEXT");
1624 // there is no way to draw into depth buffer
1628 EOL" occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
1632 if (myContext->core32 != NULL)
1634 aProgramSrc->SetHeader ("#version 150");
1637 TCollection_AsciiString anId = "occt_blit";
1638 if (theNbSamples > 1)
1640 anId += TCollection_AsciiString ("_msaa") + theNbSamples;
1642 if (theIsFallback_sRGB)
1646 aProgramSrc->SetId (anId);
1647 aProgramSrc->SetDefaultSampler (false);
1648 aProgramSrc->SetNbLightsMax (0);
1649 aProgramSrc->SetNbClipPlanesMax (0);
1650 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1651 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1652 TCollection_AsciiString aKey;
1653 if (!Create (aProgramSrc, aKey, theProgram))
1655 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1656 return Standard_False;
1659 myContext->BindProgram (theProgram);
1660 theProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
1661 theProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
1662 myContext->BindProgram (NULL);
1663 return Standard_True;
1666 // =======================================================================
1667 // function : prepareStdProgramOitCompositing
1669 // =======================================================================
1670 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
1672 Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
1673 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1674 TCollection_AsciiString aSrcVert, aSrcFrag;
1676 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1677 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1682 EOL" TexCoord = occVertex.zw;"
1683 EOL" gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
1688 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uAccumTexture", Graphic3d_TOS_FRAGMENT));
1689 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uWeightTexture", Graphic3d_TOS_FRAGMENT));
1693 EOL" vec4 aAccum = occTexture2D (uAccumTexture, TexCoord);"
1694 EOL" float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
1695 EOL" occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1697 #if !defined(GL_ES_VERSION_2_0)
1698 if (myContext->IsGlGreaterEqual (3, 2))
1700 aProgramSrc->SetHeader ("#version 150");
1703 if (myContext->IsGlGreaterEqual (3, 0))
1705 aProgramSrc->SetHeader ("#version 300 es");
1711 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uAccumTexture", Graphic3d_TOS_FRAGMENT));
1712 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uWeightTexture", Graphic3d_TOS_FRAGMENT));
1716 EOL" ivec2 aTexel = ivec2 (vec2 (textureSize (uAccumTexture)) * TexCoord);"
1717 EOL" vec4 aAccum = texelFetch (uAccumTexture, aTexel, gl_SampleID);"
1718 EOL" float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
1719 EOL" occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1721 #if !defined(GL_ES_VERSION_2_0)
1722 if (myContext->IsGlGreaterEqual (4, 0))
1724 aProgramSrc->SetHeader ("#version 400");
1727 if (myContext->IsGlGreaterEqual (3, 2))
1729 aProgramSrc->SetHeader ("#version 320 es");
1731 else if (myContext->IsGlGreaterEqual (3, 0))
1733 aProgramSrc->SetHeader ("#version 300 es"); // with GL_OES_sample_variables extension
1738 aProgramSrc->SetId (theMsaa ? "occt_weight-oit-msaa" : "occt_weight-oit");
1739 aProgramSrc->SetDefaultSampler (false);
1740 aProgramSrc->SetNbLightsMax (0);
1741 aProgramSrc->SetNbClipPlanesMax (0);
1742 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
1743 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1744 TCollection_AsciiString aKey;
1745 if (!Create (aProgramSrc, aKey, aProgram))
1747 aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1748 return Standard_False;
1751 myContext->BindProgram (aProgram);
1752 aProgram->SetSampler (myContext, "uAccumTexture", Graphic3d_TextureUnit_0);
1753 aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
1754 myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
1755 return Standard_True;
1758 // =======================================================================
1759 // function : pointSpriteAlphaSrc
1761 // =======================================================================
1762 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (Standard_Integer theBits)
1764 TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").a; }";
1765 #if !defined(GL_ES_VERSION_2_0)
1766 if (myContext->core11 == NULL
1767 && (theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
1769 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").r; }";
1774 return aSrcGetAlpha;
1777 // =======================================================================
1778 // function : defaultGlslVersion
1780 // =======================================================================
1781 int OpenGl_ShaderManager::defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
1782 const TCollection_AsciiString& theName,
1784 bool theUsesDerivates) const
1786 int aBits = theBits;
1787 const bool toUseDerivates = theUsesDerivates
1788 || (theBits & OpenGl_PO_StippleLine) != 0
1789 || (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal;
1790 #if !defined(GL_ES_VERSION_2_0)
1791 if (myContext->core32 != NULL)
1793 theProgram->SetHeader ("#version 150");
1797 if ((theBits & OpenGl_PO_StippleLine) != 0
1798 || theProgram->IsPBR())
1800 if (myContext->IsGlGreaterEqual (3, 0))
1802 theProgram->SetHeader ("#version 130");
1804 else if (myContext->CheckExtension ("GL_EXT_gpu_shader4")) // myContext->hasGlslBitwiseOps == OpenGl_FeatureInExtensions
1806 // GL_EXT_gpu_shader4 defines GLSL type "unsigned int", while core GLSL specs define type "uint"
1807 theProgram->SetHeader ("#extension GL_EXT_gpu_shader4 : enable\n"
1808 "#define uint unsigned int");
1812 (void )toUseDerivates;
1815 #if defined(__EMSCRIPTEN__)
1816 if (myContext->IsGlGreaterEqual (3, 0))
1818 // consider this is browser responsibility to provide working WebGL 2.0 implementation
1819 // and black-list broken drivers (there is no OpenGL ES greater than 3.0)
1820 theProgram->SetHeader ("#version 300 es");
1823 // prefer "100 es" on OpenGL ES 3.0- devices (save the features unavailable before "300 es")
1824 // and "300 es" on OpenGL ES 3.1+ devices
1825 if (myContext->IsGlGreaterEqual (3, 1))
1827 if ((theBits & OpenGl_PO_NeedsGeomShader) != 0)
1829 theProgram->SetHeader (myContext->hasGeometryStage != OpenGl_FeatureInExtensions ? "#version 320 es" : "#version 310 es");
1833 theProgram->SetHeader ("#version 300 es");
1838 if (theProgram->IsPBR()
1839 && myContext->IsGlGreaterEqual (3, 0))
1841 theProgram->SetHeader ("#version 300 es");
1843 if ((theBits & OpenGl_PO_WriteOit) != 0
1844 || (theBits & OpenGl_PO_StippleLine) != 0)
1846 if (myContext->IsGlGreaterEqual (3, 0))
1848 theProgram->SetHeader ("#version 300 es");
1852 aBits = aBits & ~OpenGl_PO_WriteOit;
1853 if (!myContext->oesStdDerivatives)
1855 aBits = aBits & ~OpenGl_PO_StippleLine;
1861 if (myContext->IsGlGreaterEqual (3, 0))
1863 theProgram->SetHeader ("#version 300 es");
1865 else if (myContext->oesStdDerivatives)
1867 theProgram->SetHeader ("#extension GL_OES_standard_derivatives : enable");
1873 // should fit OpenGl_PO_NB
1875 Sprintf (aBitsStr, "%04x", aBits);
1876 theProgram->SetId (TCollection_AsciiString ("occt_") + theName + aBitsStr);
1880 // =======================================================================
1881 // function : prepareGeomMainSrc
1883 // =======================================================================
1884 TCollection_AsciiString OpenGl_ShaderManager::prepareGeomMainSrc (OpenGl_ShaderObject::ShaderVariableList& theUnifoms,
1885 OpenGl_ShaderObject::ShaderVariableList& theStageInOuts,
1886 Standard_Integer theBits)
1888 if ((theBits & OpenGl_PO_NeedsGeomShader) == 0)
1890 return TCollection_AsciiString();
1893 TCollection_AsciiString aSrcMainGeom =
1897 if ((theBits & OpenGl_PO_MeshEdges) != 0)
1899 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_GEOMETRY));
1900 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("bool occIsQuadMode", Graphic3d_TOS_GEOMETRY));
1901 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_GEOMETRY));
1902 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth", Graphic3d_TOS_FRAGMENT));
1903 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("float occLineFeather", Graphic3d_TOS_FRAGMENT));
1904 theUnifoms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occWireframeColor", Graphic3d_TOS_FRAGMENT));
1905 theStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable ("vec3 EdgeDistance", Graphic3d_TOS_GEOMETRY | Graphic3d_TOS_FRAGMENT));
1907 aSrcMainGeom = TCollection_AsciiString()
1908 + EOL"vec3 ViewPortTransform (vec4 theVec)"
1910 EOL" vec3 aWinCoord = theVec.xyz / theVec.w;"
1911 EOL" aWinCoord = aWinCoord * 0.5 + 0.5;"
1912 EOL" aWinCoord.xy = aWinCoord.xy * occViewport.zw + occViewport.xy;"
1913 EOL" return aWinCoord;"
1916 + EOL" vec3 aSideA = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[1].gl_Position);"
1917 EOL" vec3 aSideB = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1918 EOL" vec3 aSideC = ViewPortTransform (gl_in[1].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1919 EOL" float aQuadArea = abs (aSideB.x * aSideC.y - aSideB.y * aSideC.x);"
1920 EOL" vec3 aLenABC = vec3 (length (aSideA), length (aSideB), length (aSideC));"
1921 EOL" vec3 aHeightABC = vec3 (aQuadArea) / aLenABC;"
1922 EOL" aHeightABC = max (aHeightABC, vec3 (10.0 * occLineWidth));" // avoid shrunk presentation disappearing at distance
1923 EOL" float aQuadModeHeightC = occIsQuadMode ? occLineWidth + 1.0 : 0.0;";
1926 for (Standard_Integer aVertIter = 0; aVertIter < 3; ++aVertIter)
1928 const TCollection_AsciiString aVertIndex (aVertIter);
1929 // pass variables from Vertex shader to Fragment shader through Geometry shader
1930 for (OpenGl_ShaderObject::ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
1932 if (aVarListIter.Value().Stages == (Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT))
1934 const TCollection_AsciiString aVarName = aVarListIter.Value().Name.Token (" ", 2);
1935 aSrcMainGeom += TCollection_AsciiString()
1936 + EOL" geomOut." + aVarName + " = geomIn[" + aVertIndex + "]." + aVarName + ";";
1940 if ((theBits & OpenGl_PO_MeshEdges) != 0)
1944 case 0: aSrcMainGeom += EOL" EdgeDistance = vec3 (aHeightABC[0], 0.0, aQuadModeHeightC);"; break;
1945 case 1: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, aHeightABC[1], aQuadModeHeightC);"; break;
1946 case 2: aSrcMainGeom += EOL" EdgeDistance = vec3 (0.0, 0.0, aHeightABC[2]);"; break;
1949 aSrcMainGeom += TCollection_AsciiString()
1950 + EOL" gl_Position = gl_in[" + aVertIndex + "].gl_Position;"
1951 EOL" EmitVertex();";
1954 EOL" EndPrimitive();"
1957 return aSrcMainGeom;
1960 // =======================================================================
1961 // function : prepareStdProgramUnlit
1963 // =======================================================================
1964 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
1965 Standard_Integer theBits,
1966 Standard_Boolean theIsOutline)
1968 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1969 TCollection_AsciiString aSrcVert, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcVertEndMain;
1970 TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
1971 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
1972 TCollection_AsciiString aSrcFragMainGetColor = EOL" occSetFragColor (getFinalColor());";
1973 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1975 if ((theBits & OpenGl_PO_IsPoint) != 0)
1977 #if defined(GL_ES_VERSION_2_0)
1978 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
1981 if ((theBits & OpenGl_PO_PointSprite) != 0)
1983 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
1984 if ((theBits & OpenGl_PO_PointSpriteA) != OpenGl_PO_PointSpriteA)
1987 EOL"vec4 getColor(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord "); }";
1989 else if ((theBits & OpenGl_PO_TextureRGB) != 0
1990 && (theBits & OpenGl_PO_VertColor) == 0)
1992 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
1993 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
1994 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1995 aSrcVertExtraMain +=
1996 EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
1998 EOL"vec4 getColor(void) { return VertColor; }";
2001 aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
2003 #if !defined(GL_ES_VERSION_2_0)
2004 if (myContext->core11 != NULL
2005 && myContext->IsGlGreaterEqual (2, 1))
2007 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2011 aSrcFragMainGetColor =
2012 EOL" vec4 aColor = getColor();"
2013 EOL" aColor.a = getAlpha();"
2014 EOL" if (aColor.a <= 0.1) discard;"
2015 EOL" occSetFragColor (aColor);";
2019 if ((theBits & OpenGl_PO_TextureRGB) != 0
2020 && (theBits & OpenGl_PO_VertColor) == 0)
2022 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2023 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2024 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2025 aSrcVertExtraMain +=
2026 EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2028 EOL"vec4 getColor(void) { return VertColor; }";
2031 aSrcFragMainGetColor =
2032 EOL" vec4 aColor = getColor();"
2033 EOL" if (aColor.a <= 0.1) discard;"
2034 EOL" occSetFragColor (aColor);";
2039 if ((theBits & OpenGl_PO_HasTextures) != 0)
2041 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2042 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2044 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureEnv)
2046 aSrcVertExtraFunc = THE_FUNC_transformNormal_view;
2048 aSrcVertExtraMain +=
2049 EOL" vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2050 EOL" vec3 aNormal = transformNormal (occNormal);"
2051 EOL" vec3 aReflect = reflect (normalize (aPosition.xyz), aNormal);"
2052 EOL" aReflect.z += 1.0;"
2053 EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
2056 EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
2060 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2061 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2064 EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
2068 if ((theBits & OpenGl_PO_VertColor) != 0)
2070 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2071 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
2072 aSrcFragGetColor = EOL"vec4 getColor(void) { return VertColor; }";
2075 int aNbClipPlanes = 0;
2076 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2078 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2079 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2080 aSrcVertExtraMain +=
2081 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
2082 EOL" Position = occWorldViewMatrix * PositionWorld;";
2084 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2086 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2087 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2088 ? THE_FRAG_CLIP_CHAINS_N
2089 : THE_FRAG_CLIP_PLANES_N;
2091 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2094 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2096 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2099 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2100 ? THE_FRAG_CLIP_CHAINS_2
2101 : THE_FRAG_CLIP_PLANES_2;
2104 if ((theBits & OpenGl_PO_WriteOit) != 0)
2106 aProgramSrc->SetNbFragmentOutputs (2);
2107 aProgramSrc->SetWeightOitOutput (true);
2112 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occOrthoScale", Graphic3d_TOS_VERTEX));
2113 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occSilhouetteThickness", Graphic3d_TOS_VERTEX));
2114 aSrcVertEndMain = THE_VERT_gl_Position_OUTLINE;
2116 else if ((theBits & OpenGl_PO_StippleLine) != 0)
2118 const Standard_Integer aBits = defaultGlslVersion (aProgramSrc, "unlit", theBits);
2119 if ((aBits & OpenGl_PO_StippleLine) != 0)
2121 if (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable)
2123 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int occStipplePattern", Graphic3d_TOS_FRAGMENT));
2127 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("bool occStipplePattern[16]", Graphic3d_TOS_FRAGMENT));
2129 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occStippleFactor", Graphic3d_TOS_FRAGMENT));
2130 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_VERTEX));
2131 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 ScreenSpaceCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2133 EOL" vec2 aPosition = gl_Position.xy / gl_Position.w;"
2134 EOL" aPosition = aPosition * 0.5 + 0.5;"
2135 EOL" ScreenSpaceCoord = aPosition.xy * occViewport.zw + occViewport.xy;";
2136 aSrcFragMainGetColor = TCollection_AsciiString()
2137 + EOL" vec2 anAxis = vec2 (0.0, 1.0);"
2138 EOL" if (abs (dFdx (ScreenSpaceCoord.x)) - abs (dFdy (ScreenSpaceCoord.y)) > 0.001)"
2140 EOL" anAxis = vec2 (1.0, 0.0);"
2142 EOL" float aRotatePoint = dot (gl_FragCoord.xy, anAxis);"
2143 + (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable
2144 ? EOL" uint aBit = uint (floor (aRotatePoint / occStippleFactor + 0.5)) & 15U;"
2145 EOL" if ((uint (occStipplePattern) & (1U << aBit)) == 0U) discard;"
2146 : EOL" int aBit = int (mod (floor (aRotatePoint / occStippleFactor + 0.5), 16.0));"
2147 EOL" if (!occStipplePattern[aBit]) discard;")
2148 + EOL" vec4 aColor = getFinalColor();"
2149 EOL" if (aColor.a <= 0.1) discard;"
2150 EOL" occSetFragColor (aColor);";
2154 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, "Warning: stipple lines in GLSL will be ignored.");
2163 + THE_VERT_gl_Position
2167 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2168 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2169 ? THE_FRAG_WIREFRAME_COLOR
2170 : EOL"#define getFinalColor getColor";
2178 + aSrcFragMainGetColor
2181 defaultGlslVersion (aProgramSrc, theIsOutline ? "outline" : "unlit", theBits);
2182 aProgramSrc->SetDefaultSampler (false);
2183 aProgramSrc->SetNbLightsMax (0);
2184 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2185 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2186 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2187 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2188 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2189 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2190 TCollection_AsciiString aKey;
2191 if (!Create (aProgramSrc, aKey, theProgram))
2193 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2194 return Standard_False;
2196 return Standard_True;
2199 // =======================================================================
2200 // function : pointSpriteShadingSrc
2202 // =======================================================================
2203 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString& theBaseColorSrc,
2204 Standard_Integer theBits)
2206 TCollection_AsciiString aSrcFragGetColor;
2207 if ((theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
2209 aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
2210 EOL"vec4 getColor(void)"
2212 EOL" vec4 aColor = " + theBaseColorSrc + ";"
2213 EOL" aColor.a = getAlpha();"
2214 EOL" if (aColor.a <= 0.1) discard;"
2215 EOL" return aColor;"
2218 else if ((theBits & OpenGl_PO_PointSprite) == OpenGl_PO_PointSprite)
2220 aSrcFragGetColor = TCollection_AsciiString() +
2221 EOL"vec4 getColor(void)"
2223 EOL" vec4 aColor = " + theBaseColorSrc + ";"
2224 EOL" aColor = occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ") * aColor;"
2225 EOL" if (aColor.a <= 0.1) discard;"
2226 EOL" return aColor;"
2230 return aSrcFragGetColor;
2233 // =======================================================================
2234 // function : stdComputeLighting
2236 // =======================================================================
2237 TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (Standard_Integer& theNbLights,
2238 Standard_Boolean theHasVertColor,
2239 Standard_Boolean theIsPBR,
2240 Standard_Boolean theHasEmissive)
2242 TCollection_AsciiString aLightsFunc, aLightsLoop;
2244 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
2245 if (!aLights.IsNull())
2247 theNbLights = aLights->NbEnabled();
2248 if (theNbLights <= THE_NB_UNROLLED_LIGHTS_MAX)
2250 Standard_Integer anIndex = 0;
2251 for (Graphic3d_LightSet::Iterator aLightIter (aLights, Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
2252 aLightIter.More(); aLightIter.Next(), ++anIndex)
2254 switch (aLightIter.Value()->Type())
2256 case Graphic3d_TOLS_AMBIENT:
2258 break; // skip ambient
2259 case Graphic3d_TOLS_DIRECTIONAL:
2260 aLightsLoop = aLightsLoop + EOL" directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
2262 case Graphic3d_TOLS_POSITIONAL:
2263 aLightsLoop = aLightsLoop + EOL" pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2265 case Graphic3d_TOLS_SPOT:
2266 aLightsLoop = aLightsLoop + EOL" spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2273 theNbLights = roundUpMaxLightSources (theNbLights);
2274 bool isFirstInLoop = true;
2275 aLightsLoop = aLightsLoop +
2276 EOL" for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)"
2278 EOL" int aType = occLight_Type (anIndex);";
2279 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2281 isFirstInLoop = false;
2283 EOL" if (aType == OccLightType_Direct)"
2285 EOL" directionalLight (anIndex, theNormal, theView, theIsFront);"
2288 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2292 aLightsLoop += EOL" else ";
2294 isFirstInLoop = false;
2296 EOL" if (aType == OccLightType_Point)"
2298 EOL" pointLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2301 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2305 aLightsLoop += EOL" else ";
2307 isFirstInLoop = false;
2309 EOL" if (aType == OccLightType_Spot)"
2311 EOL" spotLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2314 aLightsLoop += EOL" }";
2319 aLightsFunc += Shaders_PBRDistribution_glsl;
2320 aLightsFunc += Shaders_PBRGeometry_glsl;
2321 aLightsFunc += Shaders_PBRFresnel_glsl;
2322 aLightsFunc += Shaders_PBRCookTorrance_glsl;
2323 aLightsFunc += Shaders_PBRIllumination_glsl;
2326 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) == 1
2330 // use the version with hard-coded first index
2331 aLightsLoop = EOL" directionalLightFirst(theNormal, theView, theIsFront);";
2332 aLightsFunc += THE_FUNC_directionalLightFirst;
2334 else if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2336 aLightsFunc += theIsPBR ? THE_FUNC_PBR_directionalLight : THE_FUNC_directionalLight;
2338 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2340 aLightsFunc += theIsPBR ? THE_FUNC_PBR_pointLight : THE_FUNC_pointLight;
2342 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2344 aLightsFunc += theIsPBR ? THE_FUNC_PBR_spotLight : THE_FUNC_spotLight;
2348 TCollection_AsciiString aGetMatAmbient = "theIsFront ? occFrontMaterial_Ambient() : occBackMaterial_Ambient();";
2349 TCollection_AsciiString aGetMatDiffuse = "theIsFront ? occFrontMaterial_Diffuse() : occBackMaterial_Diffuse();";
2350 if (theHasVertColor)
2352 aGetMatAmbient = "getVertColor();";
2353 aGetMatDiffuse = "getVertColor();";
2358 return TCollection_AsciiString()
2360 + Shaders_PointLightAttenuation_glsl
2363 EOL"vec4 computeLighting (in vec3 theNormal,"
2364 EOL" in vec3 theView,"
2365 EOL" in vec4 thePoint,"
2366 EOL" in bool theIsFront)"
2368 EOL" Ambient = occLightAmbient.rgb;"
2369 EOL" Diffuse = vec3 (0.0);"
2370 EOL" Specular = vec3 (0.0);"
2371 EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
2373 + EOL" vec4 aMatAmbient = " + aGetMatAmbient
2374 + EOL" vec4 aMatDiffuse = " + aGetMatDiffuse
2375 + EOL" vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
2376 EOL" vec3 aColor = Ambient * aMatAmbient.rgb + Diffuse * aMatDiffuse.rgb + Specular * aMatSpecular.rgb;"
2377 EOL" occTextureOcclusion(aColor, TexCoord.st);"
2379 ? EOL" vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
2380 EOL" aColor += aMatEmission.rgb;" : "")
2381 + EOL" return vec4 (aColor, aMatDiffuse.a);"
2386 return TCollection_AsciiString()
2387 + THE_FUNC_PBR_lightDef
2388 + Shaders_PointLightAttenuation_glsl
2391 EOL"vec4 computeLighting (in vec3 theNormal,"
2392 EOL" in vec3 theView,"
2393 EOL" in vec4 thePoint,"
2394 EOL" in bool theIsFront)"
2396 EOL" DirectLighting = vec3(0.0);"
2397 EOL" BaseColor = " + (theHasVertColor ? "getVertColor();" : "occTextureColor(occPBRMaterial_Color (theIsFront), TexCoord.st / TexCoord.w);")
2398 + EOL" Emission = occTextureEmissive(occPBRMaterial_Emission (theIsFront), TexCoord.st / TexCoord.w);"
2399 EOL" Metallic = occTextureMetallic(occPBRMaterial_Metallic (theIsFront), TexCoord.st / TexCoord.w);"
2400 EOL" NormalizedRoughness = occTextureRoughness(occPBRMaterial_NormalizedRoughness (theIsFront), TexCoord.st / TexCoord.w);"
2401 EOL" Roughness = occRoughness (NormalizedRoughness);"
2402 EOL" IOR = occPBRMaterial_IOR (theIsFront);"
2403 EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
2405 + EOL" vec3 aColor = DirectLighting;"
2406 EOL" vec3 anIndirectLightingSpec = occPBRFresnel (BaseColor.rgb, Metallic, IOR);"
2407 EOL" vec2 aCoeff = occTexture2D (occEnvLUT, vec2(abs(dot(theView, theNormal)), NormalizedRoughness)).xy;"
2408 EOL" anIndirectLightingSpec *= aCoeff.x;"
2409 EOL" anIndirectLightingSpec += aCoeff.y;"
2410 EOL" anIndirectLightingSpec *= occTextureCubeLod (occSpecIBLMap, -reflect (theView, theNormal), NormalizedRoughness * float (occNbSpecIBLLevels - 1)).rgb;"
2411 EOL" vec3 aRefractionCoeff = 1.0 - occPBRFresnel (BaseColor.rgb, Metallic, NormalizedRoughness, IOR, abs(dot(theView, theNormal)));"
2412 EOL" aRefractionCoeff *= (1.0 - Metallic);"
2413 EOL" vec3 anIndirectLightingDiff = aRefractionCoeff * BaseColor.rgb * BaseColor.a;"
2414 EOL" anIndirectLightingDiff *= occDiffIBLMap (theNormal).rgb;"
2415 EOL" aColor += occLightAmbient.rgb * (anIndirectLightingDiff + anIndirectLightingSpec);"
2416 EOL" aColor += Emission;"
2417 EOL" occTextureOcclusion(aColor, TexCoord.st / TexCoord.w);"
2418 EOL" return vec4 (aColor, mix(1.0, BaseColor.a, aRefractionCoeff.x));"
2423 // =======================================================================
2424 // function : prepareStdProgramGouraud
2426 // =======================================================================
2427 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
2428 const Standard_Integer theBits)
2430 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2431 TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraMain;
2432 TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
2433 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
2434 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2436 if ((theBits & OpenGl_PO_IsPoint) != 0)
2438 #if defined(GL_ES_VERSION_2_0)
2439 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
2442 if ((theBits & OpenGl_PO_PointSprite) != 0)
2444 #if !defined(GL_ES_VERSION_2_0)
2445 if (myContext->core11 != NULL
2446 && myContext->IsGlGreaterEqual (2, 1))
2448 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2452 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2453 aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
2456 if ((theBits & OpenGl_PO_TextureRGB) != 0
2457 && (theBits & OpenGl_PO_VertColor) == 0)
2459 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2460 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2461 aSrcVertColor = EOL"vec4 getVertColor(void) { return occTexture2D (occSamplerBaseColor, occTexCoord.xy); }";
2466 if ((theBits & OpenGl_PO_TextureRGB) != 0)
2468 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2469 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2470 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2471 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2474 EOL"vec4 getColor(void)"
2476 EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
2477 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2482 if ((theBits & OpenGl_PO_VertColor) != 0)
2484 aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
2487 int aNbClipPlanes = 0;
2488 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2490 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2491 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2492 aSrcVertExtraMain +=
2493 EOL" PositionWorld = aPositionWorld;"
2494 EOL" Position = aPosition;";
2496 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2498 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2499 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2500 ? THE_FRAG_CLIP_CHAINS_N
2501 : THE_FRAG_CLIP_PLANES_N;
2503 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2506 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2508 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2511 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2512 ? THE_FRAG_CLIP_CHAINS_2
2513 : THE_FRAG_CLIP_PLANES_2;
2516 if ((theBits & OpenGl_PO_WriteOit) != 0)
2518 aProgramSrc->SetNbFragmentOutputs (2);
2519 aProgramSrc->SetWeightOitOutput (true);
2522 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 FrontColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2523 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 BackColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2525 Standard_Integer aNbLights = 0;
2526 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcVertColor.IsEmpty(), false, true);
2527 aSrcVert = TCollection_AsciiString()
2528 + THE_FUNC_transformNormal_view
2534 EOL" vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
2535 EOL" vec4 aPosition = occWorldViewMatrix * aPositionWorld;"
2536 EOL" vec3 aNormal = transformNormal (occNormal);"
2537 EOL" vec3 aView = vec3 (0.0, 0.0, 1.0);"
2538 EOL" FrontColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
2539 EOL" BackColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
2541 + THE_VERT_gl_Position
2544 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2545 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2546 ? THE_FRAG_WIREFRAME_COLOR
2547 : EOL"#define getFinalColor getColor";
2549 aSrcFrag = TCollection_AsciiString()
2554 + EOL" occSetFragColor (getFinalColor());"
2557 const TCollection_AsciiString aProgId = TCollection_AsciiString ("gouraud-") + genLightKey (myLightSourceState.LightSources()) + "-";
2558 defaultGlslVersion (aProgramSrc, aProgId, theBits);
2559 aProgramSrc->SetDefaultSampler (false);
2560 aProgramSrc->SetNbLightsMax (aNbLights);
2561 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2562 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2563 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2564 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2565 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2566 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2567 TCollection_AsciiString aKey;
2568 if (!Create (aProgramSrc, aKey, theProgram))
2570 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2571 return Standard_False;
2573 return Standard_True;
2576 // =======================================================================
2577 // function : prepareStdProgramPhong
2579 // =======================================================================
2580 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
2581 const Standard_Integer theBits,
2582 const Standard_Boolean theIsFlatNormal,
2583 const Standard_Boolean theIsPBR)
2585 TCollection_AsciiString aPosition = theIsPBR ? "PositionWorld" : "Position";
2586 TCollection_AsciiString aPhongCompLight = TCollection_AsciiString() +
2587 "computeLighting (normalize (Normal), normalize (View), " + aPosition + ", gl_FrontFacing)";
2588 const bool isFlatNormal = theIsFlatNormal
2589 && myContext->hasFlatShading != OpenGl_FeatureNotAvailable;
2590 const char* aDFdxSignReversion = "";
2591 #if defined(GL_ES_VERSION_2_0)
2592 if (isFlatNormal != theIsFlatNormal)
2594 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
2595 GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2596 "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
2598 else if (isFlatNormal
2599 && myContext->Vendor().Search("qualcomm") != -1)
2601 // workaround Adreno driver bug computing reversed normal using dFdx/dFdy
2602 aDFdxSignReversion = "-";
2603 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2604 "Warning: applied workaround for flat shading normal computation using dFdx/dFdy on Adreno");
2607 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2608 aProgramSrc->SetPBR (theIsPBR);
2610 TCollection_AsciiString aSrcVert, aSrcVertExtraFunc, aSrcVertExtraMain;
2611 TCollection_AsciiString aSrcFrag, aSrcFragGetVertColor, aSrcFragExtraMain;
2612 TCollection_AsciiString aSrcFragGetColor = TCollection_AsciiString() + EOL"vec4 getColor(void) { return " + aPhongCompLight + "; }";
2613 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2614 if ((theBits & OpenGl_PO_IsPoint) != 0)
2616 #if defined(GL_ES_VERSION_2_0)
2617 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
2620 if ((theBits & OpenGl_PO_PointSprite) != 0)
2622 #if !defined(GL_ES_VERSION_2_0)
2623 if (myContext->core11 != NULL
2624 && myContext->IsGlGreaterEqual (2, 1))
2626 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2630 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2631 aSrcFragGetColor = pointSpriteShadingSrc (aPhongCompLight, theBits);
2634 if ((theBits & OpenGl_PO_TextureRGB) != 0
2635 && (theBits & OpenGl_PO_VertColor) == 0)
2637 aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2638 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2639 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2641 aSrcVertExtraMain += EOL" VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2642 aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2647 if ((theBits & OpenGl_PO_TextureRGB) != 0)
2649 aUniforms .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2650 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2651 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2653 Standard_Integer aTextureBits = Graphic3d_TextureSetBits_BaseColor | Graphic3d_TextureSetBits_Occlusion | Graphic3d_TextureSetBits_Emissive;
2656 aSrcFragGetColor = TCollection_AsciiString() +
2657 EOL"vec4 getColor(void)"
2659 EOL" vec2 aTexUV = TexCoord.st / TexCoord.w;"
2660 EOL" vec4 aColor = " + aPhongCompLight + ";"
2661 EOL" aColor *= occTexture2D(occSamplerBaseColor, aTexUV);"
2662 EOL" vec3 anEmission = occTextureEmissive((gl_FrontFacing ? occFrontMaterial_Emission() : occBackMaterial_Emission()).rgb, aTexUV);"
2663 EOL" aColor.rgb += anEmission;"
2664 EOL" return aColor;"
2669 aTextureBits |= Graphic3d_TextureSetBits_MetallicRoughness;
2671 if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal
2674 if (myContext->hasFlatShading != OpenGl_FeatureNotAvailable)
2676 aTextureBits |= Graphic3d_TextureSetBits_Normal;
2680 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2681 "Warning: ignoring Normal Map texture due to hardware capabilities");
2684 aProgramSrc->SetTextureSetBits (aTextureBits);
2688 if ((theBits & OpenGl_PO_VertColor) != 0)
2690 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2691 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
2692 aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2695 int aNbClipPlanes = 0;
2696 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2698 if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2700 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2701 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2702 ? THE_FRAG_CLIP_CHAINS_N
2703 : THE_FRAG_CLIP_PLANES_N;
2705 else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2708 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2710 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2713 aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2714 ? THE_FRAG_CLIP_CHAINS_2
2715 : THE_FRAG_CLIP_PLANES_2;
2718 if ((theBits & OpenGl_PO_WriteOit) != 0)
2720 aProgramSrc->SetNbFragmentOutputs (2);
2721 aProgramSrc->SetWeightOitOutput (true);
2726 aSrcFragExtraMain += TCollection_AsciiString()
2727 + EOL" Normal = " + aDFdxSignReversion + "normalize (cross (dFdx (" + aPosition + ".xyz / " + aPosition + ".w), dFdy (" + aPosition + ".xyz / " + aPosition + ".w)));"
2728 EOL" if (!gl_FrontFacing) { Normal = -Normal; }";
2732 aStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable("vec3 vNormal", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2733 aSrcVertExtraFunc += THE_FUNC_transformNormal_world;
2734 aSrcVertExtraMain += EOL" vNormal = transformNormal (occNormal);";
2735 aSrcFragExtraMain += EOL" Normal = vNormal;";
2737 if ((theBits & OpenGl_PO_IsPoint) == 0
2738 && (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal
2739 && myContext->hasFlatShading != OpenGl_FeatureNotAvailable)
2741 aSrcFrag += Shaders_TangentSpaceNormal_glsl;
2742 // apply normal map texture
2743 aSrcFragExtraMain +=
2744 EOL"#if defined(THE_HAS_TEXTURE_NORMAL)"
2745 EOL" vec2 aTexCoord = TexCoord.st / TexCoord.w;"
2746 EOL" vec4 aMapNormalValue = occTextureNormal(aTexCoord);"
2747 EOL" if (aMapNormalValue.w > 0.5)"
2749 EOL" mat2 aDeltaUVMatrix = mat2 (dFdx(aTexCoord), dFdy(aTexCoord));"
2750 EOL" mat2x3 aDeltaVectorMatrix = mat2x3 (dFdx (PositionWorld.xyz), dFdy (PositionWorld.xyz));"
2751 EOL" Normal = TangentSpaceNormal (aDeltaUVMatrix, aDeltaVectorMatrix, aMapNormalValue.xyz, Normal, !gl_FrontFacing);"
2757 aSrcFragExtraMain +=
2758 EOL" Normal = normalize ((occWorldViewMatrixInverseTranspose * vec4 (Normal, 0.0)).xyz);";
2762 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2763 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2764 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 View", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2766 aSrcVert = TCollection_AsciiString()
2770 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
2771 EOL" Position = occWorldViewMatrix * PositionWorld;"
2772 EOL" if (occProjectionMatrix[3][3] == 1.0)"
2774 EOL" View = vec3(0.0, 0.0, 1.0);"
2778 EOL" View = -Position.xyz;"
2780 + (theIsPBR ? EOL" View = (occWorldViewMatrixInverse * vec4(View, 0.0)).xyz;" : "")
2782 + THE_VERT_gl_Position
2785 TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2786 aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2787 ? THE_FRAG_WIREFRAME_COLOR
2788 : EOL"#define getFinalColor getColor";
2790 Standard_Integer aNbLights = 0;
2791 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcFragGetVertColor.IsEmpty(), theIsPBR,
2792 (theBits & OpenGl_PO_TextureRGB) == 0
2793 || (theBits & OpenGl_PO_IsPoint) != 0);
2794 aSrcFrag += TCollection_AsciiString()
2796 + aSrcFragGetVertColor
2804 + EOL" occSetFragColor (getFinalColor());"
2807 const TCollection_AsciiString aProgId = TCollection_AsciiString (theIsFlatNormal ? "flat-" : "phong-") + (theIsPBR ? "pbr-" : "") + genLightKey (myLightSourceState.LightSources()) + "-";
2808 defaultGlslVersion (aProgramSrc, aProgId, theBits, isFlatNormal);
2809 aProgramSrc->SetDefaultSampler (false);
2810 aProgramSrc->SetNbLightsMax (aNbLights);
2811 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2812 aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2814 const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2815 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2816 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2817 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2818 TCollection_AsciiString aKey;
2819 if (!Create (aProgramSrc, aKey, theProgram))
2821 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2822 return Standard_False;
2824 return Standard_True;
2827 // =======================================================================
2828 // function : prepareStdProgramStereo
2830 // =======================================================================
2831 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
2832 const Graphic3d_StereoMode theStereoMode)
2834 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2835 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2837 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2838 TCollection_AsciiString aSrcVert =
2841 EOL" TexCoord = occVertex.zw;"
2842 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
2845 TCollection_AsciiString aSrcFrag;
2846 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uLeftSampler", Graphic3d_TOS_FRAGMENT));
2847 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uRightSampler", Graphic3d_TOS_FRAGMENT));
2848 const char* aName = "stereo";
2849 switch (theStereoMode)
2851 case Graphic3d_StereoMode_Anaglyph:
2854 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultL", Graphic3d_TOS_FRAGMENT));
2855 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultR", Graphic3d_TOS_FRAGMENT));
2856 const TCollection_AsciiString aNormalize = mySRgbState
2857 ? EOL"#define sRgb2linear(theColor) theColor"
2858 EOL"#define linear2sRgb(theColor) theColor"
2859 : EOL"#define sRgb2linear(theColor) pow(theColor, vec4(2.2, 2.2, 2.2, 1.0))"
2860 EOL"#define linear2sRgb(theColor) pow(theColor, 1.0 / vec4(2.2, 2.2, 2.2, 1.0))";
2861 aSrcFrag = aNormalize
2864 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2865 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2866 EOL" aColorL = sRgb2linear (aColorL);"
2867 EOL" aColorR = sRgb2linear (aColorR);"
2868 EOL" vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
2869 EOL" occSetFragColor (linear2sRgb (aColor));"
2873 case Graphic3d_StereoMode_RowInterlaced:
2875 aName = "row-interlaced";
2879 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2880 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2881 EOL" if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
2883 EOL" occSetFragColor (aColorL);"
2887 EOL" occSetFragColor (aColorR);"
2892 case Graphic3d_StereoMode_ColumnInterlaced:
2894 aName = "column-interlaced";
2898 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2899 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2900 EOL" if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
2902 EOL" occSetFragColor (aColorL);"
2906 EOL" occSetFragColor (aColorR);"
2911 case Graphic3d_StereoMode_ChessBoard:
2913 aName = "chessboard";
2917 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2918 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2919 EOL" bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
2920 EOL" bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
2921 EOL" if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
2923 EOL" occSetFragColor (aColorL);"
2927 EOL" occSetFragColor (aColorR);"
2932 case Graphic3d_StereoMode_SideBySide:
2934 aName = "sidebyside";
2938 EOL" vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
2939 EOL" if (TexCoord.x > 0.5)"
2941 EOL" aTexCoord.x -= 1.0;"
2943 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2944 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2945 EOL" if (TexCoord.x <= 0.5)"
2947 EOL" occSetFragColor (aColorL);"
2951 EOL" occSetFragColor (aColorR);"
2956 case Graphic3d_StereoMode_OverUnder:
2958 aName = "overunder";
2962 EOL" vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
2963 EOL" if (TexCoord.y > 0.5)"
2965 EOL" aTexCoord.y -= 1.0;"
2967 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2968 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2969 EOL" if (TexCoord.y <= 0.5)"
2971 EOL" occSetFragColor (aColorL);"
2975 EOL" occSetFragColor (aColorR);"
2980 case Graphic3d_StereoMode_QuadBuffer:
2981 case Graphic3d_StereoMode_SoftPageFlip:
2982 case Graphic3d_StereoMode_OpenVR:
2985 /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
2986 if (!aProgram.IsNull())
2988 return aProgram->IsValid();
2993 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2994 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2995 EOL" aColorL.b = 0.0;"
2996 EOL" aColorL.g = 0.0;"
2997 EOL" aColorR.r = 0.0;"
2998 EOL" occSetFragColor (aColorL + aColorR);"
3004 defaultGlslVersion (aProgramSrc, aName, 0);
3005 aProgramSrc->SetDefaultSampler (false);
3006 aProgramSrc->SetNbLightsMax (0);
3007 aProgramSrc->SetNbClipPlanesMax (0);
3008 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3009 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3010 TCollection_AsciiString aKey;
3011 if (!Create (aProgramSrc, aKey, theProgram))
3013 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3014 return Standard_False;
3017 myContext->BindProgram (theProgram);
3018 theProgram->SetSampler (myContext, "uLeftSampler", Graphic3d_TextureUnit_0);
3019 theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
3020 myContext->BindProgram (NULL);
3021 return Standard_True;
3024 // =======================================================================
3025 // function : prepareStdProgramBoundBox
3027 // =======================================================================
3028 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramBoundBox()
3030 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
3032 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3033 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxCenter", Graphic3d_TOS_VERTEX));
3034 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxSize", Graphic3d_TOS_VERTEX));
3036 TCollection_AsciiString aSrcVert =
3039 EOL" vec4 aCenter = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
3040 EOL" vec4 aPos = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
3041 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * aPos;"
3044 TCollection_AsciiString aSrcFrag =
3047 EOL" occSetFragColor (occColor);"
3050 defaultGlslVersion (aProgramSrc, "bndbox", 0);
3051 aProgramSrc->SetDefaultSampler (false);
3052 aProgramSrc->SetNbLightsMax (0);
3053 aProgramSrc->SetNbClipPlanesMax (0);
3054 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3055 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3056 TCollection_AsciiString aKey;
3057 if (!Create (aProgramSrc, aKey, myBoundBoxProgram))
3059 myBoundBoxProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3060 return Standard_False;
3063 const OpenGl_Vec4 aMin (-0.5f, -0.5f, -0.5f, 1.0f);
3064 const OpenGl_Vec4 anAxisShifts[3] =
3066 OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
3067 OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 0.0f),
3068 OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 0.0f)
3071 const OpenGl_Vec4 aLookup1 (0.0f, 1.0f, 0.0f, 1.0f);
3072 const OpenGl_Vec4 aLookup2 (0.0f, 0.0f, 1.0f, 1.0f);
3073 OpenGl_Vec4 aLinesVertices[24];
3074 for (int anAxis = 0, aVertex = 0; anAxis < 3; ++anAxis)
3076 for (int aCompIter = 0; aCompIter < 4; ++aCompIter)
3078 aLinesVertices[aVertex++] = aMin
3079 + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3080 + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3082 aLinesVertices[aVertex++] = aMin
3083 + anAxisShifts[anAxis]
3084 + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3085 + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3088 if (myContext->ToUseVbo())
3090 myBoundBoxVertBuffer = new OpenGl_VertexBuffer();
3091 if (myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData()))
3093 myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3094 return Standard_True;
3097 myBoundBoxVertBuffer = new OpenGl_VertexBufferCompat();
3098 myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData());
3099 myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3100 return Standard_True;
3103 // =======================================================================
3104 // function : preparePBREnvBakingProgram
3106 // =======================================================================
3107 Standard_Boolean OpenGl_ShaderManager::preparePBREnvBakingProgram()
3109 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
3110 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3112 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3113 + THE_FUNC_cubemap_vector_transform
3114 + Shaders_PBREnvBaking_vs;
3116 TCollection_AsciiString aSrcFrag = TCollection_AsciiString()
3117 + THE_FUNC_cubemap_vector_transform
3118 + Shaders_PBRDistribution_glsl
3119 + Shaders_PBREnvBaking_fs;
3121 // constant array definition requires OpenGL 2.1+ or OpenGL ES 3.0+
3122 #if defined(GL_ES_VERSION_2_0)
3123 aProgramSrc->SetHeader ("#version 300 es");
3125 aProgramSrc->SetHeader ("#version 120");
3128 defaultGlslVersion (aProgramSrc, "pbr_env_baking", 0);
3129 aProgramSrc->SetDefaultSampler (false);
3130 aProgramSrc->SetNbLightsMax (0);
3131 aProgramSrc->SetNbClipPlanesMax (0);
3132 aProgramSrc->SetPBR (true);
3133 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3134 aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3135 TCollection_AsciiString aKey;
3136 if (!Create (aProgramSrc, aKey, myPBREnvBakingProgram))
3138 myPBREnvBakingProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3139 return Standard_False;
3142 return Standard_True;
3145 // =======================================================================
3146 // function : GetBgCubeMapProgram
3148 // =======================================================================
3149 const Handle(Graphic3d_ShaderProgram)& OpenGl_ShaderManager::GetBgCubeMapProgram ()
3151 if (myBgCubeMapProgram.IsNull())
3153 myBgCubeMapProgram = new Graphic3d_ShaderProgram();
3155 OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3156 aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable("vec3 ViewDirection", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
3157 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("samplerCube occSampler0", Graphic3d_TOS_FRAGMENT));
3158 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uYCoeff", Graphic3d_TOS_VERTEX));
3159 aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uZCoeff", Graphic3d_TOS_VERTEX));
3161 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3162 + THE_FUNC_cubemap_vector_transform
3165 EOL" vec4 aViewDirection = occProjectionMatrixInverse * vec4(occVertex.xy, 0.0, 1.0);"
3166 EOL" aViewDirection /= aViewDirection.w;"
3167 EOL" aViewDirection.w = 0.0;"
3168 EOL" ViewDirection = normalize((occWorldViewMatrixInverse * aViewDirection).xyz);"
3169 EOL" ViewDirection = cubemapVectorTransform (ViewDirection, uYCoeff, uZCoeff);"
3170 EOL" gl_Position = vec4(occVertex.xy, 0.0, 1.0);"
3173 TCollection_AsciiString aSrcFrag =
3174 EOL"#define occEnvCubemap occSampler0"
3177 EOL" occSetFragColor (vec4(occTextureCube (occEnvCubemap, ViewDirection).rgb, 1.0));"
3180 defaultGlslVersion (myBgCubeMapProgram, "background_cubemap", 0);
3181 myBgCubeMapProgram->SetDefaultSampler (false);
3182 myBgCubeMapProgram->SetNbLightsMax (0);
3183 myBgCubeMapProgram->SetNbClipPlanesMax (0);
3184 myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3185 myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3188 return myBgCubeMapProgram;
3191 // =======================================================================
3192 // function : bindProgramWithState
3194 // =======================================================================
3195 Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram,
3196 Graphic3d_TypeOfShadingModel theShadingModel)
3198 const Standard_Boolean isBound = myContext->BindProgram (theProgram);
3200 && !theProgram.IsNull())
3202 theProgram->ApplyVariables (myContext);
3204 PushState (theProgram, theShadingModel);
3208 // =======================================================================
3209 // function : BindMarkerProgram
3211 // =======================================================================
3212 Standard_Boolean OpenGl_ShaderManager::BindMarkerProgram (const Handle(OpenGl_TextureSet)& theTextures,
3213 Graphic3d_TypeOfShadingModel theShadingModel,
3214 Graphic3d_AlphaMode theAlphaMode,
3215 Standard_Boolean theHasVertColor,
3216 const Handle(OpenGl_ShaderProgram)& theCustomProgram)
3218 if (!theCustomProgram.IsNull()
3219 || myContext->caps->ffpEnable)
3221 return bindProgramWithState (theCustomProgram, theShadingModel);
3224 Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, false, false);
3225 if (!theTextures.IsNull()
3226 && theTextures->HasPointSprite())
3228 aBits |= theTextures->Last()->IsAlpha() ? OpenGl_PO_PointSpriteA : OpenGl_PO_PointSprite;
3232 aBits |= OpenGl_PO_PointSimple;
3234 Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theShadingModel, aBits);
3235 return bindProgramWithState (aProgram, theShadingModel);