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_AspectFace.hxx>
20 #include <OpenGl_AspectLine.hxx>
21 #include <OpenGl_AspectMarker.hxx>
22 #include <OpenGl_AspectText.hxx>
23 #include <OpenGl_Clipping.hxx>
24 #include <OpenGl_Context.hxx>
25 #include <OpenGl_ShaderManager.hxx>
26 #include <OpenGl_ShaderProgram.hxx>
27 #include <OpenGl_Workspace.hxx>
29 #include <TCollection_ExtendedString.hxx>
31 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
35 //! Suffixes identifying shading model.
36 static const char THE_SHADINGMODEL_KEY_LETTERS[Graphic3d_TypeOfShadingModel_NB] =
38 'c', // Graphic3d_TOSM_NONE
39 'f', // Graphic3d_TOSM_FACET
40 'g', // Graphic3d_TOSM_VERTEX
41 'p' // Graphic3d_TOSM_FRAGMENT
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 //! Definition of TexCoord varying.
58 const char THE_VARY_TexCoord_OUT[] =
59 EOL"THE_SHADER_OUT vec4 TexCoord;";
60 const char THE_VARY_TexCoord_IN[] =
61 EOL"THE_SHADER_IN vec4 TexCoord;";
62 //! Compute TexCoord value in Vertex Shader
63 const char THE_VARY_TexCoord_Trsf[] =
64 EOL" float aRotSin = occTextureTrsf_RotationSin();"
65 EOL" float aRotCos = occTextureTrsf_RotationCos();"
66 EOL" vec2 aTex2 = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
67 EOL" vec2 aCopy = aTex2;"
68 EOL" aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
69 EOL" aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
70 EOL" TexCoord = vec4(aTex2, occTexCoord.zw);";
72 //! Auxiliary function to flip gl_PointCoord vertically
73 #define THE_VEC2_glPointCoord "vec2 (gl_PointCoord.x, 1.0 - gl_PointCoord.y)"
75 //! Auxiliary function to transform normal
76 const char THE_FUNC_transformNormal[] =
77 EOL"vec3 transformNormal (in vec3 theNormal)"
79 EOL" vec4 aResult = occWorldViewMatrixInverseTranspose"
80 EOL" * occModelWorldMatrixInverseTranspose"
81 EOL" * vec4 (theNormal, 0.0);"
82 EOL" return normalize (aResult.xyz);"
85 //! Global shader variable for color definition with lighting enabled.
86 const char THE_FUNC_lightDef[] =
87 EOL"vec3 Ambient;" //!< Ambient contribution of light sources
88 EOL"vec3 Diffuse;" //!< Diffuse contribution of light sources
89 EOL"vec3 Specular;"; //!< Specular contribution of light sources
91 //! Function computes contribution of isotropic point light source
92 const char THE_FUNC_pointLight[] =
93 EOL"void pointLight (in int theId,"
94 EOL" in vec3 theNormal,"
95 EOL" in vec3 theView,"
96 EOL" in vec3 thePoint,"
97 EOL" in bool theIsFront)"
99 EOL" vec3 aLight = occLight_Position (theId).xyz;"
100 EOL" if (occLight_IsHeadlight (theId) == 0)"
102 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
104 EOL" aLight -= thePoint;"
106 EOL" float aDist = length (aLight);"
107 EOL" aLight = aLight * (1.0 / aDist);"
109 EOL" float anAtten = 1.0 / (occLight_ConstAttenuation (theId)"
110 EOL" + occLight_LinearAttenuation (theId) * aDist);"
112 EOL" vec3 aHalf = normalize (aLight + theView);"
114 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
115 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
116 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
118 EOL" float aSpecl = 0.0;"
119 EOL" if (aNdotL > 0.0)"
121 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
124 EOL"Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
125 EOL"Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
128 //! Function computes contribution of spotlight source
129 const char THE_FUNC_spotLight[] =
130 EOL"void spotLight (in int theId,"
131 EOL" in vec3 theNormal,"
132 EOL" in vec3 theView,"
133 EOL" in vec3 thePoint,"
134 EOL" in bool theIsFront)"
136 EOL" vec3 aLight = occLight_Position (theId).xyz;"
137 EOL" vec3 aSpotDir = occLight_SpotDirection (theId).xyz;"
138 EOL" if (occLight_IsHeadlight (theId) == 0)"
140 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
141 EOL" aSpotDir = vec3 (occWorldViewMatrix * vec4 (aSpotDir, 0.0));"
143 EOL" aLight -= thePoint;"
145 EOL" float aDist = length (aLight);"
146 EOL" aLight = aLight * (1.0 / aDist);"
148 EOL" aSpotDir = normalize (aSpotDir);"
150 EOL" float aCosA = dot (aSpotDir, -aLight);"
151 EOL" if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
156 EOL" float anExponent = occLight_SpotExponent (theId);"
157 EOL" float anAtten = 1.0 / (occLight_ConstAttenuation (theId)"
158 EOL" + occLight_LinearAttenuation (theId) * aDist);"
159 EOL" if (anExponent > 0.0)"
161 EOL" anAtten *= pow (aCosA, anExponent * 128.0);"
164 EOL" vec3 aHalf = normalize (aLight + theView);"
166 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
167 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
168 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
170 EOL" float aSpecl = 0.0;"
171 EOL" if (aNdotL > 0.0)"
173 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
176 EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL * anAtten;"
177 EOL" Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
180 //! Function computes contribution of directional light source
181 const char THE_FUNC_directionalLight[] =
182 EOL"void directionalLight (in int theId,"
183 EOL" in vec3 theNormal,"
184 EOL" in vec3 theView,"
185 EOL" in bool theIsFront)"
187 EOL" vec3 aLight = normalize (occLight_Position (theId).xyz);"
188 EOL" if (occLight_IsHeadlight (theId) == 0)"
190 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
193 EOL" vec3 aHalf = normalize (aLight + theView);"
195 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
196 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
197 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
199 EOL" float aSpecl = 0.0;"
200 EOL" if (aNdotL > 0.0)"
202 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
205 EOL" Diffuse += occLight_Diffuse (theId).rgb * aNdotL;"
206 EOL" Specular += occLight_Specular (theId).rgb * aSpecl;"
209 //! The same as THE_FUNC_directionalLight but for the light with zero index
210 //! (avoids limitations on some mobile devices).
211 const char THE_FUNC_directionalLightFirst[] =
212 EOL"void directionalLightFirst (in vec3 theNormal,"
213 EOL" in vec3 theView,"
214 EOL" in bool theIsFront)"
216 EOL" vec3 aLight = normalize (occLightSources[1].xyz);"
217 EOL" if (occLight_IsHeadlight (0) == 0)"
219 EOL" aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
222 EOL" vec3 aHalf = normalize (aLight + theView);"
224 EOL" vec3 aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
225 EOL" float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
226 EOL" float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
228 EOL" float aSpecl = 0.0;"
229 EOL" if (aNdotL > 0.0)"
231 EOL" aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
234 EOL" Diffuse += occLightSources[0].rgb * aNdotL;"
235 EOL" Specular += occLightSources[0].rgb * aSpecl;"
238 //! Process clipping planes in Fragment Shader.
239 //! Should be added at the beginning of the main() function.
240 const char THE_FRAG_CLIP_PLANES_N[] =
241 EOL" for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount; ++aPlaneIter)"
243 EOL" vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
244 EOL" if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
250 //! Process 1 clipping plane in Fragment Shader.
251 const char THE_FRAG_CLIP_PLANES_1[] =
252 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
253 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0)"
258 //! Process 2 clipping planes in Fragment Shader.
259 const char THE_FRAG_CLIP_PLANES_2[] =
260 EOL" vec4 aClipEquation0 = occClipPlaneEquations[0];"
261 EOL" vec4 aClipEquation1 = occClipPlaneEquations[1];"
262 EOL" if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
263 EOL" || dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
268 //! Output color and coverage for accumulation by OIT algorithm.
269 const char THE_FRAG_write_oit_buffers[] =
270 EOL" float aWeight = occFragColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthFactor, 3.0), 1e-2, 1e+2);"
271 EOL" occFragCoverage.r = occFragColor.a * aWeight;"
272 EOL" occFragColor = vec4 (occFragColor.rgb * occFragColor.a * aWeight, occFragColor.a);";
274 #if !defined(GL_ES_VERSION_2_0)
276 static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
277 static const GLfloat THE_DEFAULT_SPOT_DIR[3] = { 0.0f, 0.0f, -1.0f };
278 static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
279 static const GLfloat THE_DEFAULT_SPOT_CUTOFF = 180.0f;
281 //! Bind FFP light source.
282 static void bindLight (const Graphic3d_CLight& theLight,
283 const GLenum theLightGlId,
284 const OpenGl_Mat4& theModelView,
285 OpenGl_Context* theCtx)
287 // the light is a headlight?
288 if (theLight.IsHeadlight())
290 theCtx->core11->glMatrixMode (GL_MODELVIEW);
291 theCtx->core11->glLoadIdentity();
295 const Graphic3d_Vec4& aLightColor = theLight.PackedColor();
296 switch (theLight.Type())
298 case Graphic3d_TOLS_AMBIENT : break; // handled by separate if-clause at beginning of method
299 case Graphic3d_TOLS_DIRECTIONAL:
301 // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
302 const OpenGl_Vec4 anInfDir = -theLight.PackedDirection();
304 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
305 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
306 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
307 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
308 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, anInfDir.GetData());
309 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
310 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
311 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
314 case Graphic3d_TOLS_POSITIONAL:
316 // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
317 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
318 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
319 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
320 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
321 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
322 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
323 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
324 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
325 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
326 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
327 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0);
330 case Graphic3d_TOLS_SPOT:
332 const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
333 theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
334 theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE, aLightColor.GetData());
335 theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR, aLightColor.GetData());
336 theCtx->core11->glLightfv (theLightGlId, GL_POSITION, aPosition.GetData());
337 theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION, theLight.PackedDirection().GetData());
338 theCtx->core11->glLightf (theLightGlId, GL_SPOT_EXPONENT, theLight.Concentration() * 128.0f);
339 theCtx->core11->glLightf (theLightGlId, GL_SPOT_CUTOFF, (theLight.Angle() * 180.0f) / GLfloat(M_PI));
340 theCtx->core11->glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
341 theCtx->core11->glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
342 theCtx->core11->glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
347 // restore matrix in case of headlight
348 if (theLight.IsHeadlight())
350 theCtx->core11->glLoadMatrixf (theModelView.GetData());
353 glEnable (theLightGlId);
359 // =======================================================================
360 // function : OpenGl_ShaderManager
361 // purpose : Creates new empty shader manager
362 // =======================================================================
363 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
364 : myFfpProgram (new OpenGl_ShaderProgramFFP()),
365 myShadingModel (Graphic3d_TOSM_VERTEX),
366 myContext (theContext),
367 myHasLocalOrigin (Standard_False),
373 // =======================================================================
374 // function : ~OpenGl_ShaderManager
375 // purpose : Releases resources of shader manager
376 // =======================================================================
377 OpenGl_ShaderManager::~OpenGl_ShaderManager()
379 myProgramList.Clear();
382 // =======================================================================
385 // =======================================================================
386 void OpenGl_ShaderManager::clear()
388 myProgramList.Clear();
389 myLightPrograms.Nullify();
390 myFlatPrograms = OpenGl_SetOfShaderPrograms();
391 myMapOfLightPrograms.Clear();
392 myFontProgram.Nullify();
393 myBlitProgram.Nullify();
394 for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
396 myStereoPrograms[aModeIter].Nullify();
398 switchLightPrograms();
401 // =======================================================================
403 // purpose : Creates new shader program
404 // =======================================================================
405 Standard_Boolean OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
406 TCollection_AsciiString& theShareKey,
407 Handle(OpenGl_ShaderProgram)& theProgram)
409 theProgram.Nullify();
410 if (theProxy.IsNull())
412 return Standard_False;
415 theShareKey = theProxy->GetId();
416 if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
418 if (theProgram->Share())
420 myProgramList.Append (theProgram);
422 return Standard_True;
425 theProgram = new OpenGl_ShaderProgram (theProxy);
426 if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
428 theProgram->Release (myContext);
430 theProgram.Nullify();
431 return Standard_False;
434 myProgramList.Append (theProgram);
435 myContext->ShareResource (theShareKey, theProgram);
436 return Standard_True;
439 // =======================================================================
440 // function : Unregister
441 // purpose : Removes specified shader program from the manager
442 // =======================================================================
443 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString& theShareKey,
444 Handle(OpenGl_ShaderProgram)& theProgram)
446 for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
448 if (anIt.Value() == theProgram)
450 if (!theProgram->UnShare())
453 theProgram.Nullify();
457 myProgramList.Remove (anIt);
462 const TCollection_AsciiString anID = theProgram->myProxy->GetId();
465 myContext->DelayedRelease (theProgram);
466 theProgram.Nullify();
470 theProgram.Nullify();
471 myContext->ReleaseResource (anID, Standard_True);
475 // =======================================================================
476 // function : ShaderPrograms
477 // purpose : Returns list of registered shader programs
478 // =======================================================================
479 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
481 return myProgramList;
484 // =======================================================================
486 // purpose : Returns true if no program objects are attached
487 // =======================================================================
488 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
490 return myProgramList.IsEmpty();
493 // =======================================================================
494 // function : switchLightPrograms
496 // =======================================================================
497 void OpenGl_ShaderManager::switchLightPrograms()
499 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
500 TCollection_AsciiString aKey;
501 if (!aLights.IsNull())
503 aKey = THE_SHADINGMODEL_KEY_LETTERS[myShadingModel];
505 if (aLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
507 aKey += aLights->KeyEnabledLong();
511 const Standard_Integer aMaxLimit = roundUpMaxLightSources (aLights->NbEnabled());
512 aKey += aLights->KeyEnabledShort();
518 aKey = THE_SHADINGMODEL_KEY_LETTERS[Graphic3d_TOSM_NONE];
522 if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
524 myLightPrograms = new OpenGl_SetOfShaderPrograms();
525 myMapOfLightPrograms.Bind (aKey, myLightPrograms);
529 // =======================================================================
530 // function : UpdateLightSourceStateTo
531 // purpose : Updates state of OCCT light sources
532 // =======================================================================
533 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights)
535 myLightSourceState.Set (theLights);
536 myLightSourceState.Update();
537 switchLightPrograms();
540 // =======================================================================
541 // function : UpdateLightSourceState
543 // =======================================================================
544 void OpenGl_ShaderManager::UpdateLightSourceState()
546 myLightSourceState.Update();
549 // =======================================================================
550 // function : SetShadingModel
552 // =======================================================================
553 void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
555 myShadingModel = theModel;
556 switchLightPrograms();
559 // =======================================================================
560 // function : SetProjectionState
561 // purpose : Sets new state of OCCT projection transform
562 // =======================================================================
563 void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
565 myProjectionState.Set (theProjectionMatrix);
566 myProjectionState.Update();
569 // =======================================================================
570 // function : SetModelWorldState
571 // purpose : Sets new state of OCCT model-world transform
572 // =======================================================================
573 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
575 myModelWorldState.Set (theModelWorldMatrix);
576 myModelWorldState.Update();
579 // =======================================================================
580 // function : SetWorldViewState
581 // purpose : Sets new state of OCCT world-view transform
582 // =======================================================================
583 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
585 myWorldViewState.Set (theWorldViewMatrix);
586 myWorldViewState.Update();
589 // =======================================================================
590 // function : PushLightSourceState
591 // purpose : Pushes state of OCCT light sources to the program
592 // =======================================================================
593 void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
595 if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE))
600 theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
601 if (theProgram == myFfpProgram)
603 #if !defined(GL_ES_VERSION_2_0)
604 if (myContext->core11 == NULL)
609 GLenum aLightGlId = GL_LIGHT0;
610 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
611 for (Graphic3d_LightSet::Iterator aLightIt (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
612 aLightIt.More(); aLightIt.Next())
614 if (aLightGlId > GL_LIGHT7) // only 8 lights in FFP...
616 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
617 "Warning: light sources limit (8) has been exceeded within Fixed-function pipeline.");
621 bindLight (*aLightIt.Value(), aLightGlId, aModelView, myContext);
625 // apply accumulated ambient color
626 const Graphic3d_Vec4 anAmbient = !myLightSourceState.LightSources().IsNull()
627 ? myLightSourceState.LightSources()->AmbientColor()
628 : Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
629 myContext->core11->glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbient.GetData());
631 // GL_LIGHTING is managed by drawers to switch between shaded / no lighting output,
632 // therefore managing the state here does not have any effect - do it just for consistency.
633 if (aLightGlId != GL_LIGHT0)
635 ::glEnable (GL_LIGHTING);
639 ::glDisable (GL_LIGHTING);
641 // switch off unused lights
642 for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
644 ::glDisable (aLightGlId);
650 const Standard_Integer aNbLightsMax = theProgram->NbLightsMax();
651 const GLint anAmbientLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT);
652 if (aNbLightsMax == 0
653 && anAmbientLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
658 if (myLightTypeArray.Size() < aNbLightsMax)
660 myLightTypeArray .Resize (0, aNbLightsMax - 1, false);
661 myLightParamsArray.Resize (0, aNbLightsMax - 1, false);
663 for (Standard_Integer aLightIt = 0; aLightIt < aNbLightsMax; ++aLightIt)
665 myLightTypeArray.ChangeValue (aLightIt).Type = -1;
668 if (myLightSourceState.LightSources().IsNull()
669 || myLightSourceState.LightSources()->IsEmpty())
671 theProgram->SetUniform (myContext,
672 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
674 theProgram->SetUniform (myContext,
676 OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
677 theProgram->SetUniform (myContext,
678 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
679 aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
680 myLightTypeArray.First().Packed());
684 Standard_Integer aLightsNb = 0;
685 for (Graphic3d_LightSet::Iterator anIter (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
686 anIter.More(); anIter.Next())
688 const Graphic3d_CLight& aLight = *anIter.Value();
689 if (aLightsNb >= aNbLightsMax)
691 if (aNbLightsMax != 0)
693 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
694 TCollection_AsciiString("Warning: light sources limit (") + aNbLightsMax + ") has been exceeded.");
699 OpenGl_ShaderLightType& aLightType = myLightTypeArray.ChangeValue (aLightsNb);
700 OpenGl_ShaderLightParameters& aLightParams = myLightParamsArray.ChangeValue (aLightsNb);
701 if (!aLight.IsEnabled()) // has no affect with Graphic3d_LightSet::IterationFilter_ExcludeDisabled - here just for consistency
703 // 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
704 aLightType.Type = -1; // Graphic3d_TOLS_AMBIENT can be used instead
705 aLightType.IsHeadlight = false;
706 aLightParams.Color = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f);
711 aLightType.Type = aLight.Type();
712 aLightType.IsHeadlight = aLight.IsHeadlight();
713 aLightParams.Color = aLight.PackedColor();
714 if (aLight.Type() == Graphic3d_TOLS_DIRECTIONAL)
716 aLightParams.Position = -aLight.PackedDirection();
718 else if (!aLight.IsHeadlight())
720 aLightParams.Position.x() = static_cast<float>(aLight.Position().X() - myLocalOrigin.X());
721 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y() - myLocalOrigin.Y());
722 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z() - myLocalOrigin.Z());
723 aLightParams.Position.w() = 1.0f;
727 aLightParams.Position.x() = static_cast<float>(aLight.Position().X());
728 aLightParams.Position.y() = static_cast<float>(aLight.Position().Y());
729 aLightParams.Position.z() = static_cast<float>(aLight.Position().Z());
730 aLightParams.Position.w() = 1.0f;
733 if (aLight.Type() == Graphic3d_TOLS_SPOT)
735 aLightParams.Direction = aLight.PackedDirection();
737 aLightParams.Parameters = aLight.PackedParams();
741 const Graphic3d_Vec4& anAmbient = myLightSourceState.LightSources()->AmbientColor();
742 theProgram->SetUniform (myContext,
743 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
745 theProgram->SetUniform (myContext,
748 theProgram->SetUniform (myContext,
749 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
750 aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
751 myLightTypeArray.First().Packed());
754 theProgram->SetUniform (myContext,
755 theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
756 aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
757 myLightParamsArray.First().Packed());
761 // =======================================================================
762 // function : PushProjectionState
763 // purpose : Pushes state of OCCT projection transform to the program
764 // =======================================================================
765 void OpenGl_ShaderManager::PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
767 if (myProjectionState.Index() == theProgram->ActiveState (OpenGl_PROJECTION_STATE))
772 theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
773 if (theProgram == myFfpProgram)
775 #if !defined(GL_ES_VERSION_2_0)
776 if (myContext->core11 != NULL)
778 myContext->core11->glMatrixMode (GL_PROJECTION);
779 myContext->core11->glLoadMatrixf (myProjectionState.ProjectionMatrix());
785 theProgram->SetUniform (myContext,
786 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
787 myProjectionState.ProjectionMatrix());
789 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
790 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
792 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
795 theProgram->SetUniform (myContext,
796 theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
797 myProjectionState.ProjectionMatrix(), true);
799 aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
800 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
802 theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
806 // =======================================================================
807 // function : PushModelWorldState
808 // purpose : Pushes state of OCCT model-world transform to the program
809 // =======================================================================
810 void OpenGl_ShaderManager::PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
812 if (myModelWorldState.Index() == theProgram->ActiveState (OpenGl_MODEL_WORLD_STATE))
817 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
818 if (theProgram == myFfpProgram)
820 #if !defined(GL_ES_VERSION_2_0)
821 if (myContext->core11 != NULL)
823 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
824 myContext->core11->glMatrixMode (GL_MODELVIEW);
825 myContext->core11->glLoadMatrixf (aModelView.GetData());
826 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
832 theProgram->SetUniform (myContext,
833 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
834 myModelWorldState.ModelWorldMatrix());
836 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
837 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
839 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
842 theProgram->SetUniform (myContext,
843 theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
844 myModelWorldState.ModelWorldMatrix(), true);
846 aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
847 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
849 theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
853 // =======================================================================
854 // function : PushWorldViewState
855 // purpose : Pushes state of OCCT world-view transform to the program
856 // =======================================================================
857 void OpenGl_ShaderManager::PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
859 if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
864 theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
865 if (theProgram == myFfpProgram)
867 #if !defined(GL_ES_VERSION_2_0)
868 if (myContext->core11 != NULL)
870 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
871 myContext->core11->glMatrixMode (GL_MODELVIEW);
872 myContext->core11->glLoadMatrixf (aModelView.GetData());
873 theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
879 theProgram->SetUniform (myContext,
880 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
881 myWorldViewState.WorldViewMatrix());
883 GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
884 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
886 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
889 theProgram->SetUniform (myContext,
890 theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
891 myWorldViewState.WorldViewMatrix(), true);
893 aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
894 if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
896 theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
900 // =======================================================================
901 // function : UpdateClippingState
902 // purpose : Updates state of OCCT clipping planes
903 // =======================================================================
904 void OpenGl_ShaderManager::UpdateClippingState()
906 myClippingState.Update();
909 // =======================================================================
910 // function : RevertClippingState
911 // purpose : Reverts state of OCCT clipping planes
912 // =======================================================================
913 void OpenGl_ShaderManager::RevertClippingState()
915 myClippingState.Revert();
918 // =======================================================================
919 // function : PushClippingState
920 // purpose : Pushes state of OCCT clipping planes to the program
921 // =======================================================================
922 void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
924 if (myClippingState.Index() == theProgram->ActiveState (OpenGl_CLIP_PLANES_STATE))
929 theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
930 if (theProgram == myFfpProgram)
932 #if !defined(GL_ES_VERSION_2_0)
933 if (myContext->core11 == NULL)
938 const Standard_Integer aNbMaxPlanes = myContext->MaxClipPlanes();
939 if (myClipPlaneArrayFfp.Size() < aNbMaxPlanes)
941 myClipPlaneArrayFfp.Resize (0, aNbMaxPlanes - 1, false);
944 Standard_Integer aPlaneId = 0;
945 Standard_Boolean toRestoreModelView = Standard_False;
946 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
948 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
949 if (aPlaneIter.IsDisabled())
953 else if (aPlaneId >= aNbMaxPlanes)
955 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
956 TCollection_ExtendedString("Warning: clipping planes limit (") + aNbMaxPlanes + ") has been exceeded.");
960 const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
961 OpenGl_Vec4d& aPlaneEq = myClipPlaneArrayFfp.ChangeValue (aPlaneId);
962 aPlaneEq.x() = anEquation.x();
963 aPlaneEq.y() = anEquation.y();
964 aPlaneEq.z() = anEquation.z();
965 aPlaneEq.w() = anEquation.w();
966 if (myHasLocalOrigin)
968 const gp_XYZ aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
969 const Standard_Real aD = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
973 const GLenum anFfpPlaneID = GL_CLIP_PLANE0 + aPlaneId;
974 if (anFfpPlaneID == GL_CLIP_PLANE0)
976 // set either identity or pure view matrix
977 toRestoreModelView = Standard_True;
978 myContext->core11->glMatrixMode (GL_MODELVIEW);
979 myContext->core11->glLoadMatrixf (myWorldViewState.WorldViewMatrix().GetData());
982 ::glEnable (anFfpPlaneID);
983 myContext->core11->glClipPlane (anFfpPlaneID, aPlaneEq);
988 // switch off unused lights
989 for (; aPlaneId < aNbMaxPlanes; ++aPlaneId)
991 ::glDisable (GL_CLIP_PLANE0 + aPlaneId);
994 // restore combined model-view matrix
995 if (toRestoreModelView)
997 const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
998 myContext->core11->glLoadMatrixf (aModelView.GetData());
1004 const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
1005 if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION)
1010 const Standard_Integer aNbClipPlanesMax = theProgram->NbClipPlanesMax();
1011 const GLint aNbPlanes = Min (myContext->Clipping().NbClippingOrCappingOn(), aNbClipPlanesMax);
1012 theProgram->SetUniform (myContext,
1013 theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT),
1020 if (myClipPlaneArray.Size() < aNbClipPlanesMax)
1022 myClipPlaneArray.Resize (0, aNbClipPlanesMax - 1, false);
1025 Standard_Integer aPlaneId = 0;
1026 for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1028 const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1029 if (aPlaneIter.IsDisabled())
1033 else if (aPlaneId >= aNbClipPlanesMax)
1035 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
1036 TCollection_AsciiString("Warning: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1040 const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
1041 OpenGl_Vec4& aPlaneEq = myClipPlaneArray.ChangeValue (aPlaneId);
1042 aPlaneEq.x() = float(anEquation.x());
1043 aPlaneEq.y() = float(anEquation.y());
1044 aPlaneEq.z() = float(anEquation.z());
1045 aPlaneEq.w() = float(anEquation.w());
1046 if (myHasLocalOrigin)
1048 const gp_XYZ aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
1049 const Standard_Real aD = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
1050 aPlaneEq.w() = float(aD);
1055 theProgram->SetUniform (myContext, aLocEquations, aNbClipPlanesMax, &myClipPlaneArray.First());
1058 // =======================================================================
1059 // function : PushMaterialState
1061 // =======================================================================
1062 void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1064 if (myMaterialState.Index() == theProgram->ActiveState (OpenGl_MATERIAL_STATE))
1069 const OpenGl_Material& aFrontMat = myMaterialState.FrontMaterial();
1070 const OpenGl_Material& aBackMat = myMaterialState.BackMaterial();
1071 theProgram->UpdateState (OpenGl_MATERIAL_STATE, myMaterialState.Index());
1072 if (theProgram == myFfpProgram)
1074 #if !defined(GL_ES_VERSION_2_0)
1075 if (myContext->core11 == NULL)
1080 const GLenum aFrontFace = myMaterialState.ToDistinguish() ? GL_FRONT : GL_FRONT_AND_BACK;
1081 myContext->core11->glMaterialfv(aFrontFace, GL_AMBIENT, aFrontMat.Ambient.GetData());
1082 myContext->core11->glMaterialfv(aFrontFace, GL_DIFFUSE, aFrontMat.Diffuse.GetData());
1083 myContext->core11->glMaterialfv(aFrontFace, GL_SPECULAR, aFrontMat.Specular.GetData());
1084 myContext->core11->glMaterialfv(aFrontFace, GL_EMISSION, aFrontMat.Emission.GetData());
1085 myContext->core11->glMaterialf (aFrontFace, GL_SHININESS, aFrontMat.Shine());
1086 if (myMaterialState.ToDistinguish())
1088 myContext->core11->glMaterialfv(GL_BACK, GL_AMBIENT, aBackMat.Ambient.GetData());
1089 myContext->core11->glMaterialfv(GL_BACK, GL_DIFFUSE, aBackMat.Diffuse.GetData());
1090 myContext->core11->glMaterialfv(GL_BACK, GL_SPECULAR, aBackMat.Specular.GetData());
1091 myContext->core11->glMaterialfv(GL_BACK, GL_EMISSION, aBackMat.Emission.GetData());
1092 myContext->core11->glMaterialf (GL_BACK, GL_SHININESS, aBackMat.Shine());
1098 theProgram->SetUniform (myContext,
1099 theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
1100 myMaterialState.ToMapTexture() ? 1 : 0);
1101 theProgram->SetUniform (myContext,
1102 theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
1103 myMaterialState.ToDistinguish() ? 1 : 0);
1105 const GLint aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL);
1106 if (aLocFront != OpenGl_ShaderProgram::INVALID_LOCATION)
1108 theProgram->SetUniform (myContext, aLocFront, OpenGl_Material::NbOfVec4(),
1109 aFrontMat.Packed());
1112 const GLint aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_BACK_MATERIAL);
1113 if (aLocBack != OpenGl_ShaderProgram::INVALID_LOCATION)
1115 theProgram->SetUniform (myContext, aLocBack, OpenGl_Material::NbOfVec4(),
1120 // =======================================================================
1121 // function : PushOitState
1122 // purpose : Pushes state of OIT uniforms to the specified program
1123 // =======================================================================
1124 void OpenGl_ShaderManager::PushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1126 if (!theProgram->IsValid())
1131 if (myOitState.Index() == theProgram->ActiveState (OpenGL_OIT_STATE))
1136 const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
1137 if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
1139 theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
1142 const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
1143 if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
1145 theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
1149 // =======================================================================
1150 // function : PushState
1151 // purpose : Pushes state of OCCT graphics parameters to the program
1152 // =======================================================================
1153 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1155 const Handle(OpenGl_ShaderProgram)& aProgram = !theProgram.IsNull() ? theProgram : myFfpProgram;
1156 PushClippingState (aProgram);
1157 PushWorldViewState (aProgram);
1158 PushModelWorldState (aProgram);
1159 PushProjectionState (aProgram);
1160 PushLightSourceState (aProgram);
1161 PushMaterialState (aProgram);
1162 PushOitState (aProgram);
1165 // =======================================================================
1166 // function : prepareStdProgramFont
1168 // =======================================================================
1169 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
1171 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1172 TCollection_AsciiString aSrcVert = TCollection_AsciiString()
1173 + EOL"THE_SHADER_OUT vec2 TexCoord;"
1176 EOL" TexCoord = occTexCoord.st;"
1177 EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1180 TCollection_AsciiString
1181 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
1182 #if !defined(GL_ES_VERSION_2_0)
1183 if (myContext->core11 == NULL)
1185 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
1189 TCollection_AsciiString aSrcFrag = TCollection_AsciiString() +
1190 + EOL"THE_SHADER_IN vec2 TexCoord;"
1194 EOL" vec4 aColor = occColor;"
1195 EOL" aColor.a *= getAlpha();"
1196 EOL" if (aColor.a <= 0.285) discard;"
1197 EOL" occFragColor = aColor;"
1200 #if !defined(GL_ES_VERSION_2_0)
1201 if (myContext->core32 != NULL)
1203 aProgramSrc->SetHeader ("#version 150");
1206 if (myContext->IsGlGreaterEqual (3, 0))
1208 aProgramSrc->SetHeader ("#version 300 es");
1211 aProgramSrc->SetNbLightsMax (0);
1212 aProgramSrc->SetNbClipPlanesMax (0);
1213 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
1214 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1215 TCollection_AsciiString aKey;
1216 if (!Create (aProgramSrc, aKey, myFontProgram))
1218 myFontProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1219 return Standard_False;
1221 return Standard_True;
1224 // =======================================================================
1225 // function : prepareStdProgramFboBlit
1227 // =======================================================================
1228 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
1230 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1231 TCollection_AsciiString aSrcVert =
1232 EOL"THE_SHADER_OUT vec2 TexCoord;"
1235 EOL" TexCoord = occVertex.zw;"
1236 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
1239 TCollection_AsciiString aSrcFrag =
1240 EOL"uniform sampler2D uColorSampler;"
1241 EOL"uniform sampler2D uDepthSampler;"
1243 EOL"THE_SHADER_IN vec2 TexCoord;"
1247 EOL" gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
1248 EOL" occFragColor = occTexture2D (uColorSampler, TexCoord);"
1251 #if defined(GL_ES_VERSION_2_0)
1252 if (myContext->IsGlGreaterEqual (3, 0))
1254 aProgramSrc->SetHeader ("#version 300 es");
1256 else if (myContext->extFragDepth)
1258 aProgramSrc->SetHeader ("#extension GL_EXT_frag_depth : enable"
1259 EOL"#define gl_FragDepth gl_FragDepthEXT");
1263 // there is no way to draw into depth buffer
1265 EOL"uniform sampler2D uColorSampler;"
1267 EOL"THE_SHADER_IN vec2 TexCoord;"
1271 EOL" occFragColor = occTexture2D (uColorSampler, TexCoord);"
1275 if (myContext->core32 != NULL)
1277 aProgramSrc->SetHeader ("#version 150");
1280 aProgramSrc->SetNbLightsMax (0);
1281 aProgramSrc->SetNbClipPlanesMax (0);
1282 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
1283 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1284 TCollection_AsciiString aKey;
1285 if (!Create (aProgramSrc, aKey, myBlitProgram))
1287 myBlitProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1288 return Standard_False;
1291 myContext->BindProgram (myBlitProgram);
1292 myBlitProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
1293 myBlitProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
1294 myContext->BindProgram (NULL);
1295 return Standard_True;
1298 // =======================================================================
1299 // function : prepareStdProgramOitCompositing
1301 // =======================================================================
1302 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
1304 Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
1305 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1306 TCollection_AsciiString aSrcVert, aSrcFrag;
1309 EOL"THE_SHADER_OUT vec2 TexCoord;"
1312 EOL" TexCoord = occVertex.zw;"
1313 EOL" gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
1319 EOL"uniform sampler2D uAccumTexture;"
1320 EOL"uniform sampler2D uWeightTexture;"
1322 EOL"THE_SHADER_IN vec2 TexCoord;"
1326 EOL" vec4 aAccum = occTexture2D (uAccumTexture, TexCoord);"
1327 EOL" float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
1328 EOL" occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
1330 #if !defined(GL_ES_VERSION_2_0)
1331 if (myContext->IsGlGreaterEqual (3, 2))
1333 aProgramSrc->SetHeader ("#version 150");
1336 if (myContext->IsGlGreaterEqual (3, 0))
1338 aProgramSrc->SetHeader ("#version 300 es");
1345 EOL"uniform sampler2DMS uAccumTexture;"
1346 EOL"uniform sampler2DMS uWeightTexture;"
1348 EOL"THE_SHADER_IN vec2 TexCoord;"
1352 EOL" ivec2 aTexel = ivec2 (textureSize (uAccumTexture) * TexCoord);"
1353 EOL" vec4 aAccum = texelFetch (uAccumTexture, aTexel, gl_SampleID);"
1354 EOL" float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
1355 EOL" occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
1357 #if !defined(GL_ES_VERSION_2_0)
1358 if (myContext->IsGlGreaterEqual (4, 0))
1360 aProgramSrc->SetHeader ("#version 400");
1363 if (myContext->IsGlGreaterEqual (3, 0))
1365 aProgramSrc->SetHeader ("#version 300 es");
1370 aProgramSrc->SetNbLightsMax (0);
1371 aProgramSrc->SetNbClipPlanesMax (0);
1372 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
1373 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1374 TCollection_AsciiString aKey;
1375 if (!Create (aProgramSrc, aKey, aProgram))
1377 aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1378 return Standard_False;
1381 myContext->BindProgram (aProgram);
1382 aProgram->SetSampler (myContext, "uAccumTexture", Graphic3d_TextureUnit_0);
1383 aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
1384 myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
1385 return Standard_True;
1388 // =======================================================================
1389 // function : pointSpriteAlphaSrc
1391 // =======================================================================
1392 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (const Standard_Integer theBits)
1394 TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }";
1395 #if !defined(GL_ES_VERSION_2_0)
1396 if (myContext->core11 == NULL
1397 && (theBits & OpenGl_PO_TextureA) != 0)
1399 aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }";
1404 return aSrcGetAlpha;
1410 // =======================================================================
1411 // function : textureUsed
1413 // =======================================================================
1414 static bool textureUsed (const Standard_Integer theBits)
1416 return (theBits & OpenGl_PO_TextureA) != 0 || (theBits & OpenGl_PO_TextureRGB) != 0;
1421 // =======================================================================
1422 // function : prepareStdProgramFlat
1424 // =======================================================================
1425 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_ShaderProgram)& theProgram,
1426 const Standard_Integer theBits)
1428 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1429 TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha;
1430 TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
1431 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
1432 TCollection_AsciiString aSrcFragMainGetColor = EOL" occFragColor = getColor();";
1433 if ((theBits & OpenGl_PO_Point) != 0)
1435 #if defined(GL_ES_VERSION_2_0)
1436 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
1439 if ((theBits & OpenGl_PO_TextureRGB) != 0)
1442 EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
1445 if (textureUsed (theBits))
1447 aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
1449 #if !defined(GL_ES_VERSION_2_0)
1450 if (myContext->core11 != NULL
1451 && myContext->IsGlGreaterEqual (2, 1))
1453 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1457 aSrcFragMainGetColor =
1458 EOL" vec4 aColor = getColor();"
1459 EOL" aColor.a = getAlpha();"
1460 EOL" if (aColor.a <= 0.1) discard;"
1461 EOL" occFragColor = aColor;";
1465 aSrcFragMainGetColor =
1466 EOL" vec4 aColor = getColor();"
1467 EOL" if (aColor.a <= 0.1) discard;"
1468 EOL" occFragColor = aColor;";
1473 if ((theBits & OpenGl_PO_TextureRGB) != 0)
1475 aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
1476 aSrcFragExtraOut += THE_VARY_TexCoord_IN;
1477 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
1480 EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
1482 else if ((theBits & OpenGl_PO_TextureEnv) != 0)
1484 aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
1485 aSrcFragExtraOut += THE_VARY_TexCoord_IN;
1487 aSrcVertExtraFunc = THE_FUNC_transformNormal;
1489 aSrcVertExtraMain +=
1490 EOL" vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1491 EOL" vec3 aNormal = transformNormal (occNormal);"
1492 EOL" vec3 aReflect = reflect (normalize (aPosition.xyz), aNormal);"
1493 EOL" aReflect.z += 1.0;"
1494 EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
1497 EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
1500 if ((theBits & OpenGl_PO_VertColor) != 0)
1502 aSrcVertExtraOut += EOL"THE_SHADER_OUT vec4 VertColor;";
1503 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
1504 aSrcFragExtraOut += EOL"THE_SHADER_IN vec4 VertColor;";
1505 aSrcFragGetColor = EOL"vec4 getColor(void) { return VertColor; }";
1508 int aNbClipPlanes = 0;
1509 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
1512 EOL"THE_SHADER_OUT vec4 PositionWorld;"
1513 EOL"THE_SHADER_OUT vec4 Position;";
1515 EOL"THE_SHADER_IN vec4 PositionWorld;"
1516 EOL"THE_SHADER_IN vec4 Position;";
1517 aSrcVertExtraMain +=
1518 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
1519 EOL" Position = occWorldViewMatrix * PositionWorld;";
1521 if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
1524 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
1526 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
1529 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_2;
1533 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
1534 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
1537 if ((theBits & OpenGl_PO_WriteOit) != 0)
1539 aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
1542 TCollection_AsciiString aSrcVertEndMain;
1543 if ((theBits & OpenGl_PO_StippleLine) != 0)
1545 bool hasGlslBitOps = false;
1546 #if defined(GL_ES_VERSION_2_0)
1547 if (myContext->IsGlGreaterEqual (3, 0))
1549 hasGlslBitOps = true;
1552 if (myContext->IsGlGreaterEqual (3, 0))
1554 aProgramSrc->SetHeader ("#version 130");
1555 hasGlslBitOps = true;
1557 else if(myContext->CheckExtension("GL_EXT_gpu_shader4"))
1559 aProgramSrc->SetHeader ("#extension GL_EXT_gpu_shader4 : enable");
1560 hasGlslBitOps = true;
1567 EOL"THE_SHADER_OUT vec2 ScreenSpaceCoord;";
1569 EOL"THE_SHADER_IN vec2 ScreenSpaceCoord;"
1570 EOL"uniform int uPattern;"
1571 EOL"uniform float uFactor;";
1573 EOL" ScreenSpaceCoord = gl_Position.xy / gl_Position.w;";
1574 aSrcFragMainGetColor =
1575 EOL" float anAngle = atan (dFdx (ScreenSpaceCoord.x), dFdy (ScreenSpaceCoord.y));"
1576 EOL" float aRotatePoint = gl_FragCoord.x * sin (anAngle) + gl_FragCoord.y * cos (anAngle);"
1577 EOL" uint aBit = uint (floor (aRotatePoint / uFactor + 0.5)) & 15U;"
1578 EOL" if ((uint (uPattern) & (1U << aBit)) == 0U) discard;"
1579 EOL" vec4 aColor = getColor();"
1580 EOL" if (aColor.a <= 0.1) discard;"
1581 EOL" occFragColor = aColor;";
1585 const TCollection_ExtendedString aWarnMessage =
1586 "Warning: stipple lines in GLSL will be ignored.";
1587 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
1588 GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, aWarnMessage);
1598 + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1609 + aSrcFragMainGetColor
1613 #if !defined(GL_ES_VERSION_2_0)
1614 if (myContext->core32 != NULL)
1616 aProgramSrc->SetHeader ("#version 150");
1619 if (myContext->IsGlGreaterEqual (3, 0))
1621 aProgramSrc->SetHeader ("#version 300 es");
1624 aProgramSrc->SetNbLightsMax (0);
1625 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
1626 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
1627 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1629 TCollection_AsciiString aKey;
1630 if (!Create (aProgramSrc, aKey, theProgram))
1632 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1633 return Standard_False;
1635 return Standard_True;
1638 // =======================================================================
1639 // function : pointSpriteShadingSrc
1641 // =======================================================================
1642 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString theBaseColorSrc,
1643 const Standard_Integer theBits)
1645 TCollection_AsciiString aSrcFragGetColor;
1646 if ((theBits & OpenGl_PO_TextureA) != 0)
1648 aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
1649 EOL"vec4 getColor(void)"
1651 EOL" vec4 aColor = " + theBaseColorSrc + ";"
1652 EOL" aColor.a = getAlpha();"
1653 EOL" if (aColor.a <= 0.1) discard;"
1654 EOL" return aColor;"
1657 else if ((theBits & OpenGl_PO_TextureRGB) != 0)
1659 aSrcFragGetColor = TCollection_AsciiString() +
1660 EOL"vec4 getColor(void)"
1662 EOL" vec4 aColor = " + theBaseColorSrc + ";"
1663 EOL" aColor = occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ") * aColor;"
1664 EOL" if (aColor.a <= 0.1) discard;"
1665 EOL" return aColor;"
1669 return aSrcFragGetColor;
1672 // =======================================================================
1673 // function : stdComputeLighting
1675 // =======================================================================
1676 TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (Standard_Integer& theNbLights,
1677 Standard_Boolean theHasVertColor)
1679 TCollection_AsciiString aLightsFunc, aLightsLoop;
1681 const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
1682 if (!aLights.IsNull())
1684 theNbLights = aLights->NbEnabled();
1685 if (theNbLights <= THE_NB_UNROLLED_LIGHTS_MAX)
1687 Standard_Integer anIndex = 0;
1688 for (Graphic3d_LightSet::Iterator aLightIter (aLights, Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
1689 aLightIter.More(); aLightIter.Next(), ++anIndex)
1691 switch (aLightIter.Value()->Type())
1693 case Graphic3d_TOLS_AMBIENT:
1695 break; // skip ambient
1696 case Graphic3d_TOLS_DIRECTIONAL:
1697 aLightsLoop = aLightsLoop + EOL" directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
1699 case Graphic3d_TOLS_POSITIONAL:
1700 aLightsLoop = aLightsLoop + EOL" pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
1702 case Graphic3d_TOLS_SPOT:
1703 aLightsLoop = aLightsLoop + EOL" spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
1710 theNbLights = roundUpMaxLightSources (theNbLights);
1711 bool isFirstInLoop = true;
1712 aLightsLoop = aLightsLoop +
1713 EOL" for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)"
1715 EOL" int aType = occLight_Type (anIndex);";
1716 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
1718 isFirstInLoop = false;
1720 EOL" if (aType == OccLightType_Direct)"
1722 EOL" directionalLight (anIndex, theNormal, theView, theIsFront);"
1725 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
1729 aLightsLoop += EOL" else ";
1731 isFirstInLoop = false;
1733 EOL" if (aType == OccLightType_Point)"
1735 EOL" pointLight (anIndex, theNormal, theView, aPoint, theIsFront);"
1738 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
1742 aLightsLoop += EOL" else ";
1744 isFirstInLoop = false;
1746 EOL" if (aType == OccLightType_Spot)"
1748 EOL" spotLight (anIndex, theNormal, theView, aPoint, theIsFront);"
1751 aLightsLoop += EOL" }";
1753 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) == 1
1754 && theNbLights == 1)
1756 // use the version with hard-coded first index
1757 aLightsLoop = EOL" directionalLightFirst(theNormal, theView, theIsFront);";
1758 aLightsFunc += THE_FUNC_directionalLightFirst;
1760 else if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
1762 aLightsFunc += THE_FUNC_directionalLight;
1764 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
1766 aLightsFunc += THE_FUNC_pointLight;
1768 if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
1770 aLightsFunc += THE_FUNC_spotLight;
1774 TCollection_AsciiString aGetMatAmbient = "theIsFront ? occFrontMaterial_Ambient() : occBackMaterial_Ambient();";
1775 TCollection_AsciiString aGetMatDiffuse = "theIsFront ? occFrontMaterial_Diffuse() : occBackMaterial_Diffuse();";
1776 if (theHasVertColor)
1778 aGetMatAmbient = "getVertColor();";
1779 aGetMatDiffuse = "getVertColor();";
1782 return TCollection_AsciiString()
1786 EOL"vec4 computeLighting (in vec3 theNormal,"
1787 EOL" in vec3 theView,"
1788 EOL" in vec4 thePoint,"
1789 EOL" in bool theIsFront)"
1791 EOL" Ambient = occLightAmbient.rgb;"
1792 EOL" Diffuse = vec3 (0.0);"
1793 EOL" Specular = vec3 (0.0);"
1794 EOL" vec3 aPoint = thePoint.xyz / thePoint.w;"
1796 + EOL" vec4 aMatAmbient = " + aGetMatAmbient
1797 + EOL" vec4 aMatDiffuse = " + aGetMatDiffuse
1798 + EOL" vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
1799 EOL" vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
1800 EOL" vec3 aColor = Ambient * aMatAmbient.rgb"
1801 EOL" + Diffuse * aMatDiffuse.rgb"
1802 EOL" + Specular * aMatSpecular.rgb"
1803 EOL" + aMatEmission.rgb;"
1804 EOL" return vec4 (aColor, aMatDiffuse.a);"
1808 // =======================================================================
1809 // function : prepareStdProgramGouraud
1811 // =======================================================================
1812 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
1813 const Standard_Integer theBits)
1815 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1816 TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain;
1817 TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
1818 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
1819 if ((theBits & OpenGl_PO_Point) != 0)
1821 #if defined(GL_ES_VERSION_2_0)
1822 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
1825 if (textureUsed (theBits))
1827 #if !defined(GL_ES_VERSION_2_0)
1828 if (myContext->core11 != NULL
1829 && myContext->IsGlGreaterEqual (2, 1))
1831 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1835 aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
1840 if ((theBits & OpenGl_PO_TextureRGB) != 0)
1842 aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
1843 aSrcFragExtraOut += THE_VARY_TexCoord_IN;
1844 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
1847 EOL"vec4 getColor(void)"
1849 EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
1850 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
1855 if ((theBits & OpenGl_PO_VertColor) != 0)
1857 aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
1860 int aNbClipPlanes = 0;
1861 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
1864 EOL"THE_SHADER_OUT vec4 PositionWorld;"
1865 EOL"THE_SHADER_OUT vec4 Position;";
1867 EOL"THE_SHADER_IN vec4 PositionWorld;"
1868 EOL"THE_SHADER_IN vec4 Position;";
1869 aSrcVertExtraMain +=
1870 EOL" PositionWorld = aPositionWorld;"
1871 EOL" Position = aPosition;";
1873 if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
1876 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
1878 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
1881 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_2;
1885 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
1886 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
1889 if ((theBits & OpenGl_PO_WriteOit) != 0)
1891 aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
1894 Standard_Integer aNbLights = 0;
1895 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
1896 aSrcVert = TCollection_AsciiString()
1897 + THE_FUNC_transformNormal
1902 EOL"THE_SHADER_OUT vec4 FrontColor;"
1903 EOL"THE_SHADER_OUT vec4 BackColor;"
1908 EOL" vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
1909 EOL" vec4 aPosition = occWorldViewMatrix * aPositionWorld;"
1910 EOL" vec3 aNormal = transformNormal (occNormal);"
1911 EOL" vec3 aView = vec3 (0.0, 0.0, 1.0);"
1912 EOL" FrontColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
1913 EOL" BackColor = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
1915 + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1918 aSrcFrag = TCollection_AsciiString()
1919 + EOL"THE_SHADER_IN vec4 FrontColor;"
1920 EOL"THE_SHADER_IN vec4 BackColor;"
1926 + EOL" occFragColor = getColor();"
1930 #if !defined(GL_ES_VERSION_2_0)
1931 if (myContext->core32 != NULL)
1933 aProgramSrc->SetHeader ("#version 150");
1936 if (myContext->IsGlGreaterEqual (3, 0))
1938 aProgramSrc->SetHeader ("#version 300 es");
1941 aProgramSrc->SetNbLightsMax (aNbLights);
1942 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
1943 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
1944 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1945 TCollection_AsciiString aKey;
1946 if (!Create (aProgramSrc, aKey, theProgram))
1948 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1949 return Standard_False;
1951 return Standard_True;
1954 // =======================================================================
1955 // function : prepareStdProgramPhong
1957 // =======================================================================
1958 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
1959 const Standard_Integer theBits,
1960 const Standard_Boolean theIsFlatNormal)
1962 #define thePhongCompLight "computeLighting (normalize (Normal), normalize (View), Position, gl_FrontFacing)"
1963 #if defined(GL_ES_VERSION_2_0)
1964 const bool isFlatNormal = theIsFlatNormal
1965 && (myContext->IsGlGreaterEqual (3, 0)
1966 || myContext->oesStdDerivatives);
1968 const bool isFlatNormal = theIsFlatNormal;
1971 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1972 TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain;
1973 TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain, aSrcFragWriteOit;
1974 TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return " thePhongCompLight "; }";
1975 if ((theBits & OpenGl_PO_Point) != 0)
1977 #if defined(GL_ES_VERSION_2_0)
1978 aSrcVertExtraMain += EOL" gl_PointSize = occPointSize;";
1981 if (textureUsed (theBits))
1983 #if !defined(GL_ES_VERSION_2_0)
1984 if (myContext->core11 != NULL
1985 && myContext->IsGlGreaterEqual (2, 1))
1987 aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1991 aSrcFragGetColor = pointSpriteShadingSrc (thePhongCompLight, theBits);
1996 if ((theBits & OpenGl_PO_TextureRGB) != 0)
1998 aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
1999 aSrcFragExtraOut += THE_VARY_TexCoord_IN;
2000 aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2003 EOL"vec4 getColor(void)"
2005 EOL" vec4 aColor = " thePhongCompLight ";"
2006 EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2011 if ((theBits & OpenGl_PO_VertColor) != 0)
2013 aSrcVertExtraOut += EOL"THE_SHADER_OUT vec4 VertColor;";
2014 aSrcVertExtraMain += EOL" VertColor = occVertColor;";
2015 aSrcFragGetVertColor = EOL"THE_SHADER_IN vec4 VertColor;"
2016 EOL"vec4 getVertColor(void) { return VertColor; }";
2019 int aNbClipPlanes = 0;
2020 if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2022 if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2025 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2027 else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2030 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_2;
2034 aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2035 aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
2038 if ((theBits & OpenGl_PO_WriteOit) != 0)
2040 aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
2043 aSrcVert = TCollection_AsciiString()
2044 + (isFlatNormal ? "" : THE_FUNC_transformNormal)
2046 EOL"THE_SHADER_OUT vec4 PositionWorld;"
2047 EOL"THE_SHADER_OUT vec4 Position;"
2048 EOL"THE_SHADER_OUT vec3 View;"
2049 + (isFlatNormal ? ""
2050 : EOL"THE_SHADER_OUT vec3 Normal;")
2055 EOL" PositionWorld = occModelWorldMatrix * occVertex;"
2056 EOL" Position = occWorldViewMatrix * PositionWorld;"
2057 + (isFlatNormal ? ""
2058 : EOL" Normal = transformNormal (occNormal);")
2059 + EOL" View = vec3 (0.0, 0.0, 1.0);"
2061 + EOL" gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2064 Standard_Integer aNbLights = 0;
2065 const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
2066 aSrcFrag = TCollection_AsciiString()
2067 + EOL"THE_SHADER_IN vec4 PositionWorld;"
2068 EOL"THE_SHADER_IN vec4 Position;"
2069 EOL"THE_SHADER_IN vec3 View;"
2072 : EOL"THE_SHADER_IN vec3 Normal;")
2075 + aSrcFragGetVertColor
2083 ? EOL" Normal = normalize (cross (dFdx (Position.xyz / Position.w), dFdy (Position.xyz / Position.w)));"
2085 + EOL" occFragColor = getColor();"
2089 #if !defined(GL_ES_VERSION_2_0)
2090 if (myContext->core32 != NULL)
2092 aProgramSrc->SetHeader ("#version 150");
2095 if (myContext->IsGlGreaterEqual (3, 0))
2097 aProgramSrc->SetHeader ("#version 300 es");
2099 else if (isFlatNormal)
2101 if (myContext->oesStdDerivatives)
2103 aProgramSrc->SetHeader ("#extension GL_OES_standard_derivatives : enable");
2107 myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
2108 GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2109 "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
2113 aProgramSrc->SetNbLightsMax (aNbLights);
2114 aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2115 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
2116 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2117 TCollection_AsciiString aKey;
2118 if (!Create (aProgramSrc, aKey, theProgram))
2120 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2121 return Standard_False;
2123 return Standard_True;
2126 // =======================================================================
2127 // function : prepareStdProgramStereo
2129 // =======================================================================
2130 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
2131 const Graphic3d_StereoMode theStereoMode)
2133 Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2134 TCollection_AsciiString aSrcVert =
2135 EOL"THE_SHADER_OUT vec2 TexCoord;"
2138 EOL" TexCoord = occVertex.zw;"
2139 EOL" gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
2142 TCollection_AsciiString aSrcFrag;
2143 switch (theStereoMode)
2145 case Graphic3d_StereoMode_Anaglyph:
2148 EOL"uniform sampler2D uLeftSampler;"
2149 EOL"uniform sampler2D uRightSampler;"
2151 EOL"uniform mat4 uMultL;"
2152 EOL"uniform mat4 uMultR;"
2154 EOL"const vec4 THE_POW_UP = vec4 (2.2, 2.2, 2.2, 1.0);"
2155 EOL"const vec4 THE_POW_DOWN = 1.0 / vec4 (2.2, 2.2, 2.2, 1.0);"
2157 EOL"THE_SHADER_IN vec2 TexCoord;"
2161 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2162 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2163 EOL" aColorL = pow (aColorL, THE_POW_UP);" // normalize
2164 EOL" aColorR = pow (aColorR, THE_POW_UP);"
2165 EOL" vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
2166 EOL" occFragColor = pow (aColor, THE_POW_DOWN);"
2170 case Graphic3d_StereoMode_RowInterlaced:
2173 EOL"uniform sampler2D uLeftSampler;"
2174 EOL"uniform sampler2D uRightSampler;"
2176 EOL"THE_SHADER_IN vec2 TexCoord;"
2180 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2181 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2182 EOL" if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
2184 EOL" occFragColor = aColorL;"
2188 EOL" occFragColor = aColorR;"
2193 case Graphic3d_StereoMode_ColumnInterlaced:
2196 EOL"uniform sampler2D uLeftSampler;"
2197 EOL"uniform sampler2D uRightSampler;"
2199 EOL"THE_SHADER_IN vec2 TexCoord;"
2203 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2204 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2205 EOL" if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
2207 EOL" occFragColor = aColorL;"
2211 EOL" occFragColor = aColorR;"
2216 case Graphic3d_StereoMode_ChessBoard:
2219 EOL"uniform sampler2D uLeftSampler;"
2220 EOL"uniform sampler2D uRightSampler;"
2222 EOL"THE_SHADER_IN vec2 TexCoord;"
2226 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2227 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2228 EOL" bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
2229 EOL" bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
2230 EOL" if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
2232 EOL" occFragColor = aColorL;"
2236 EOL" occFragColor = aColorR;"
2241 case Graphic3d_StereoMode_SideBySide:
2244 EOL"uniform sampler2D uLeftSampler;"
2245 EOL"uniform sampler2D uRightSampler;"
2247 EOL"THE_SHADER_IN vec2 TexCoord;"
2251 EOL" vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
2252 EOL" if (TexCoord.x > 0.5)"
2254 EOL" aTexCoord.x -= 1.0;"
2256 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2257 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2258 EOL" if (TexCoord.x <= 0.5)"
2260 EOL" occFragColor = aColorL;"
2264 EOL" occFragColor = aColorR;"
2269 case Graphic3d_StereoMode_OverUnder:
2272 EOL"uniform sampler2D uLeftSampler;"
2273 EOL"uniform sampler2D uRightSampler;"
2275 EOL"THE_SHADER_IN vec2 TexCoord;"
2279 EOL" vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
2280 EOL" if (TexCoord.y > 0.5)"
2282 EOL" aTexCoord.y -= 1.0;"
2284 EOL" vec4 aColorL = occTexture2D (uLeftSampler, aTexCoord);"
2285 EOL" vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2286 EOL" if (TexCoord.y <= 0.5)"
2288 EOL" occFragColor = aColorL;"
2292 EOL" occFragColor = aColorR;"
2297 case Graphic3d_StereoMode_QuadBuffer:
2298 case Graphic3d_StereoMode_SoftPageFlip:
2301 /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
2302 if (!aProgram.IsNull())
2304 return aProgram->IsValid();
2307 EOL"uniform sampler2D uLeftSampler;"
2308 EOL"uniform sampler2D uRightSampler;"
2310 EOL"THE_SHADER_IN vec2 TexCoord;"
2314 EOL" vec4 aColorL = occTexture2D (uLeftSampler, TexCoord);"
2315 EOL" vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2316 EOL" aColorL.b = 0.0;"
2317 EOL" aColorL.g = 0.0;"
2318 EOL" aColorR.r = 0.0;"
2319 EOL" occFragColor = aColorL + aColorR;"
2325 #if !defined(GL_ES_VERSION_2_0)
2326 if (myContext->core32 != NULL)
2328 aProgramSrc->SetHeader ("#version 150");
2331 if (myContext->IsGlGreaterEqual (3, 0))
2333 aProgramSrc->SetHeader ("#version 300 es");
2337 aProgramSrc->SetNbLightsMax (0);
2338 aProgramSrc->SetNbClipPlanesMax (0);
2339 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
2340 aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2341 TCollection_AsciiString aKey;
2342 if (!Create (aProgramSrc, aKey, theProgram))
2344 theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2345 return Standard_False;
2348 myContext->BindProgram (theProgram);
2349 theProgram->SetSampler (myContext, "uLeftSampler", Graphic3d_TextureUnit_0);
2350 theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
2351 myContext->BindProgram (NULL);
2352 return Standard_True;
2355 // =======================================================================
2356 // function : bindProgramWithState
2358 // =======================================================================
2359 Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
2361 const Standard_Boolean isBound = myContext->BindProgram (theProgram);
2363 && !theProgram.IsNull())
2365 theProgram->ApplyVariables (myContext);
2367 PushState (theProgram);