0024321: Use List collection instead of NCollection_Set for collection of Handle...
[occt.git] / src / OpenGl / OpenGl_ShaderManager.cxx
1 // Created on: 2013-09-26
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 #include <typeinfo>
21
22 #include <OpenGl_AspectFace.hxx>
23 #include <OpenGl_AspectLine.hxx>
24 #include <OpenGl_AspectMarker.hxx>
25 #include <OpenGl_AspectText.hxx>
26 #include <OpenGl_Clipping.hxx>
27 #include <OpenGl_Context.hxx>
28 #include <OpenGl_ShaderManager.hxx>
29 #include <OpenGl_ShaderProgram.hxx>
30
31 IMPLEMENT_STANDARD_HANDLE (OpenGl_ShaderManager, Standard_Transient)
32 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager, Standard_Transient)
33
34 // =======================================================================
35 // function : OpenGl_ShaderManager
36 // purpose  : Creates new empty shader manager
37 // =======================================================================
38 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
39 : myContext (theContext),
40   myIsPP    (Standard_False)
41 {
42   //
43 }
44
45 // =======================================================================
46 // function : ~OpenGl_ShaderManager
47 // purpose  : Releases resources of shader manager
48 // =======================================================================
49 OpenGl_ShaderManager::~OpenGl_ShaderManager()
50 {
51   myProgramList.Clear();
52 }
53
54 // =======================================================================
55 // function : Create
56 // purpose  : Creates new shader program
57 // =======================================================================
58 void OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
59                                    TCollection_AsciiString&               theShareKey,
60                                    Handle(OpenGl_ShaderProgram)&          theProgram)
61 {
62   theProgram.Nullify();
63   if (theProxy.IsNull())
64   {
65     return;
66   }
67
68   theShareKey = theProxy->GetId();
69   if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
70   {
71     if (theProgram->Share())
72     {
73       myProgramList.Append (theProgram);
74     }
75     return;
76   }
77
78   theProgram = new OpenGl_ShaderProgram (theProxy);
79   if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
80   {
81     theProgram->Release (myContext);
82     theShareKey.Clear();
83     theProgram.Nullify();
84     return;
85   }
86
87   myProgramList.Append (theProgram);
88   myContext->ShareResource (theShareKey, theProgram);
89 }
90
91 // =======================================================================
92 // function : Unregister
93 // purpose  : Removes specified shader program from the manager
94 // =======================================================================
95 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString&      theShareKey,
96                                        Handle(OpenGl_ShaderProgram)& theProgram)
97 {
98   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
99   {
100     if (anIt.Value() == theProgram)
101     {
102       if (!theProgram->UnShare())
103       {
104         theShareKey.Clear();
105         theProgram.Nullify();
106         return;
107       }
108
109       myProgramList.Remove (anIt);
110       myMaterialStates.UnBind (theProgram);
111       break;
112     }
113   }
114
115   const TCollection_AsciiString anID = theProgram->myProxy->GetId();
116   if (anID.IsEmpty())
117   {
118     myContext->DelayedRelease (theProgram);
119     theProgram.Nullify();
120   }
121   else
122   {
123     theProgram.Nullify();
124     myContext->ReleaseResource (anID, Standard_True);
125   }
126 }
127
128 // =======================================================================
129 // function : ShaderPrograms
130 // purpose  : Returns list of registered shader programs
131 // =======================================================================
132 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
133 {
134   return myProgramList;
135 }
136
137 // =======================================================================
138 // function : Empty
139 // purpose  : Returns true if no program objects are attached
140 // =======================================================================
141 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
142 {
143   return myProgramList.IsEmpty();
144 }
145
146 // =======================================================================
147 // function : UpdateLightSourceStateTo
148 // purpose  : Updates state of OCCT light sources
149 // =======================================================================
150 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const OpenGl_ListOfLight* theLights)
151 {
152   myLightSourceState.Set (theLights);
153   myLightSourceState.Update();
154 }
155
156 // =======================================================================
157 // function : SetProjectionState
158 // purpose  : Sets new state of OCCT projection transform
159 // =======================================================================
160 void OpenGl_ShaderManager::UpdateProjectionStateTo (const Tmatrix3& theProjectionMatrix)
161 {
162   myProjectionState.Set (theProjectionMatrix);
163   myProjectionState.Update();
164 }
165
166 // =======================================================================
167 // function : SetModelWorldState
168 // purpose  : Sets new state of OCCT model-world transform
169 // =======================================================================
170 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const Tmatrix3& theModelWorldMatrix)
171 {
172   myModelWorldState.Set (theModelWorldMatrix);
173   myModelWorldState.Update();
174 }
175
176 // =======================================================================
177 // function : SetWorldViewState
178 // purpose  : Sets new state of OCCT world-view transform
179 // =======================================================================
180 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const Tmatrix3& theWorldViewMatrix)
181 {
182   myWorldViewState.Set (theWorldViewMatrix);
183   myWorldViewState.Update();
184 }
185
186 // =======================================================================
187 // function : RevertProjectionStateTo
188 // purpose  : Reverts state of OCCT projection transform
189 // =======================================================================
190 void OpenGl_ShaderManager::RevertProjectionStateTo (const Tmatrix3& theProjectionMatrix)
191 {
192   myProjectionState.Set (theProjectionMatrix);
193   myProjectionState.Revert();
194 }
195
196 // =======================================================================
197 // function : RevertModelWorldStateTo
198 // purpose  : Reverts state of OCCT model-world transform
199 // =======================================================================
200 void OpenGl_ShaderManager::RevertModelWorldStateTo (const Tmatrix3& theModelWorldMatrix)
201 {
202   myModelWorldState.Set (theModelWorldMatrix);
203   myModelWorldState.Revert();
204 }
205
206 // =======================================================================
207 // function : RevertWorldViewStateTo
208 // purpose  : Reverts state of OCCT world-view transform
209 // =======================================================================
210 void OpenGl_ShaderManager::RevertWorldViewStateTo (const Tmatrix3& theWorldViewMatrix)
211 {
212   myWorldViewState.Set (theWorldViewMatrix);
213   myWorldViewState.Revert();
214 }
215
216 // =======================================================================
217 // function : LightSourceState
218 // purpose  : Returns current state of OCCT light sources
219 // =======================================================================
220 const OpenGl_LightSourceState& OpenGl_ShaderManager::LightSourceState() const
221 {
222   return myLightSourceState;
223 }
224
225 // =======================================================================
226 // function : ProjectionState
227 // purpose  : Returns current state of OCCT projection transform
228 // =======================================================================
229 const OpenGl_ProjectionState& OpenGl_ShaderManager::ProjectionState() const
230 {
231   return myProjectionState;
232 }
233
234 // =======================================================================
235 // function : ModelWorldState
236 // purpose  : Returns current state of OCCT model-world transform
237 // =======================================================================
238 const OpenGl_ModelWorldState& OpenGl_ShaderManager::ModelWorldState() const
239 {
240   return myModelWorldState;
241 }
242
243 // =======================================================================
244 // function : WorldViewState
245 // purpose  : Returns current state of OCCT world-view transform
246 // =======================================================================
247 const OpenGl_WorldViewState& OpenGl_ShaderManager::WorldViewState() const
248 {
249   return myWorldViewState;
250 }
251
252 //! Packed properties of light source
253 class OpenGl_ShaderLightParameters
254 {
255 public:
256
257   OpenGl_Vec4 Color;
258   OpenGl_Vec4 Position;
259   OpenGl_Vec4 Direction;
260   OpenGl_Vec4 Parameters;
261
262   //! Returns packed (serialized) representation of light source properties
263   const OpenGl_Vec4* Packed()  { return reinterpret_cast<OpenGl_Vec4*> (this); }
264   static Standard_Integer NbOfVec4() { return 4; }
265
266 };
267
268 //! Packed light source type information
269 class OpenGl_ShaderLightType
270 {
271 public:
272
273   Standard_Integer Type;
274   Standard_Integer IsHeadlight;
275
276   //! Returns packed (serialized) representation of light source type
277   const OpenGl_Vec2i* Packed() { return reinterpret_cast<OpenGl_Vec2i*> (this); }
278   static Standard_Integer NbOfVec2i() { return 1; }
279
280 };
281
282 // =======================================================================
283 // function : PushLightSourceState
284 // purpose  : Pushes state of OCCT light sources to the program
285 // =======================================================================
286 void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
287 {
288   if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE)
289    || !theProgram->IsValid())
290   {
291     return;
292   }
293
294   OpenGl_ShaderLightType* aLightTypeArray = new OpenGl_ShaderLightType[OpenGLMaxLights];
295   for (Standard_Integer aLightIt = 0; aLightIt < OpenGLMaxLights; ++aLightIt)
296   {
297     aLightTypeArray[aLightIt].Type = -1;
298   }
299
300   const Standard_Integer aLightsDefNb = Min (myLightSourceState.LightSources()->Size(), OpenGLMaxLights);
301   if (aLightsDefNb < 1)
302   {
303     theProgram->SetUniform (myContext,
304                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
305                             0);
306     theProgram->SetUniform (myContext,
307                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT),
308                             OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
309     theProgram->SetUniform (myContext,
310                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
311                             OpenGLMaxLights * OpenGl_ShaderLightType::NbOfVec2i(),
312                             aLightTypeArray[0].Packed());
313     theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
314     return;
315   }
316
317   OpenGl_ShaderLightParameters* aLightParamsArray = new OpenGl_ShaderLightParameters[aLightsDefNb];
318
319   OpenGl_Vec4 anAmbient (0.0f, 0.0f, 0.0f, 0.0f);
320   Standard_Integer aLightsNb = 0;
321   for (OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources()); anIter.More(); anIter.Next())
322   {
323     const OpenGl_Light& aLight = anIter.Value();
324     if (aLight.Type == Visual3d_TOLS_AMBIENT)
325     {
326       anAmbient += aLight.Color;
327       continue;
328     }
329     else if (aLightsNb >= OpenGLMaxLights)
330     {
331       continue;
332     }
333
334     OpenGl_ShaderLightType& aLightType = aLightTypeArray[aLightsNb];
335     aLightType.Type        = aLight.Type;
336     aLightType.IsHeadlight = aLight.IsHeadlight;
337
338     OpenGl_ShaderLightParameters& aLightParams = aLightParamsArray[aLightsNb];
339     aLightParams.Color    = aLight.Color;
340     aLightParams.Position = aLight.Type == Visual3d_TOLS_DIRECTIONAL
341                          ? -aLight.Direction
342                          :  aLight.Position;
343     if (aLight.Type == Visual3d_TOLS_SPOT)
344     {
345       aLightParams.Direction = aLight.Direction;
346     }
347     aLightParams.Parameters = aLight.Params;
348     ++aLightsNb;
349   }
350
351   theProgram->SetUniform (myContext,
352                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
353                           aLightsNb);
354   theProgram->SetUniform (myContext,
355                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT),
356                           anAmbient);
357   theProgram->SetUniform (myContext,
358                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
359                           OpenGLMaxLights * OpenGl_ShaderLightType::NbOfVec2i(),
360                           aLightTypeArray[0].Packed());
361   if (aLightsNb > 0)
362   {
363     theProgram->SetUniform (myContext,
364                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
365                             aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
366                             aLightParamsArray[0].Packed());
367   }
368   delete[] aLightParamsArray;
369   delete[] aLightTypeArray;
370
371   theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
372 }
373
374 // =======================================================================
375 // function : PushProjectionState
376 // purpose  : Pushes state of OCCT projection transform to the program
377 // =======================================================================
378 void OpenGl_ShaderManager::PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
379 {
380   if (myProjectionState.Index() == theProgram->ActiveState (OpenGl_PROJECTION_STATE))
381   {
382     return;
383   }
384
385   theProgram->SetUniform (myContext,
386                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
387                           myProjectionState.ProjectionMatrix());
388
389   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
390   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
391   {
392     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
393   }
394
395   theProgram->SetUniform (myContext,
396                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
397                           myProjectionState.ProjectionMatrix(), true);
398
399   aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
400   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
401   {
402     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
403   }
404
405   theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
406 }
407
408 // =======================================================================
409 // function : PushModelWorldState
410 // purpose  : Pushes state of OCCT model-world transform to the program
411 // =======================================================================
412 void OpenGl_ShaderManager::PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
413 {
414   if (myModelWorldState.Index() == theProgram->ActiveState (OpenGl_MODEL_WORLD_STATE))
415   {
416     return;
417   }
418
419   theProgram->SetUniform (myContext,
420                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
421                           myModelWorldState.ModelWorldMatrix());
422
423   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
424   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
425   {
426     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
427   }
428
429   theProgram->SetUniform (myContext,
430                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
431                           myModelWorldState.ModelWorldMatrix(), true);
432
433   aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
434   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
435   {
436     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
437   }
438
439   theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
440 }
441
442 // =======================================================================
443 // function : PushWorldViewState
444 // purpose  : Pushes state of OCCT world-view transform to the program
445 // =======================================================================
446 void OpenGl_ShaderManager::PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
447 {
448   if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
449   {
450     return;
451   }
452
453   theProgram->SetUniform (myContext,
454                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
455                           myWorldViewState.WorldViewMatrix());
456
457   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
458   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
459   {
460     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
461   }
462
463   theProgram->SetUniform (myContext,
464                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
465                           myWorldViewState.WorldViewMatrix(), true);
466
467   aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
468   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
469   {
470     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
471   }
472
473   theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
474 }
475
476 // =======================================================================
477 // function : UpdateClippingState
478 // purpose  : Updates state of OCCT clipping planes
479 // =======================================================================
480 void OpenGl_ShaderManager::UpdateClippingState()
481 {
482   myClippingState.Update();
483 }
484
485 // =======================================================================
486 // function : RevertClippingState
487 // purpose  : Reverts state of OCCT clipping planes
488 // =======================================================================
489 void OpenGl_ShaderManager::RevertClippingState()
490 {
491   myClippingState.Revert();
492 }
493
494 // =======================================================================
495 // function : PushClippingState
496 // purpose  : Pushes state of OCCT clipping planes to the program
497 // =======================================================================
498 void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
499 {
500   if (myClippingState.Index() == theProgram->ActiveState (OpenGl_CLIP_PLANES_STATE))
501   {
502     return;
503   }
504
505   theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
506   const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
507   const GLint aLocSpaces    = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_SPACES);
508   if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION
509    && aLocSpaces    == OpenGl_ShaderProgram::INVALID_LOCATION)
510   {
511     return;
512   }
513
514   GLuint aPlanesNb = 0;
515   for (Graphic3d_SequenceOfHClipPlane::Iterator anIter (myContext->Clipping().Planes());
516        anIter.More(); anIter.Next())
517   {
518     const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value();
519     if (!myContext->Clipping().IsEnabled (aPlane))
520     {
521       continue;
522     }
523
524     ++aPlanesNb;
525   }
526   if (aPlanesNb < 1)
527   {
528     return;
529   }
530
531   OpenGl_Vec4* anEquations = new OpenGl_Vec4[aPlanesNb];
532   GLint*       aSpaces     = new GLint      [aPlanesNb];
533   GLuint aPlaneId = 0;
534   for (Graphic3d_SequenceOfHClipPlane::Iterator anIter (myContext->Clipping().Planes());
535        anIter.More(); anIter.Next())
536   {
537     const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value();
538     if (!myContext->Clipping().IsEnabled (aPlane))
539     {
540       continue;
541     }
542
543     const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
544     anEquations[aPlaneId] = OpenGl_Vec4 ((float) anEquation.x(),
545                                          (float) anEquation.y(),
546                                          (float) anEquation.z(),
547                                          (float) anEquation.w());
548     aSpaces[aPlaneId] = myContext->Clipping().GetEquationSpace (aPlane);
549     ++aPlaneId;
550   }
551   theProgram->SetUniform (myContext, aLocEquations, aPlanesNb, anEquations[0].GetData());
552   theProgram->SetUniform (myContext, aLocSpaces,    aPlanesNb, aSpaces);
553
554   delete[] anEquations;
555   delete[] aSpaces;
556 }
557
558 // =======================================================================
559 // function : UpdateMaterialStateTo
560 // purpose  : Updates state of OCCT material for specified program
561 // =======================================================================
562 void OpenGl_ShaderManager::UpdateMaterialStateTo (const Handle(OpenGl_ShaderProgram)& theProgram,
563                                                   const OpenGl_Element*               theAspect)
564 {
565   if (myMaterialStates.IsBound (theProgram))
566   {
567     myMaterialStates.ChangeFind (theProgram).Set (theAspect);
568   }
569   else
570   {
571     myMaterialStates.Bind (theProgram, OpenGl_MaterialState (theAspect));
572   }
573
574   myMaterialStates.ChangeFind (theProgram).Update();
575 }
576
577 // =======================================================================
578 // function : ResetMaterialStates
579 // purpose  : Resets state of OCCT material for all programs
580 // =======================================================================
581 void OpenGl_ShaderManager::ResetMaterialStates()
582 {
583   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
584   {
585     anIt.Value()->UpdateState (OpenGl_MATERIALS_STATE, 0);
586   }
587 }
588
589 // =======================================================================
590 // function : MaterialState
591 // purpose  : Returns state of OCCT material for specified program
592 // =======================================================================
593 const OpenGl_MaterialState* OpenGl_ShaderManager::MaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
594 {
595   if (!myMaterialStates.IsBound (theProgram))
596     return NULL;
597
598   return &myMaterialStates.Find (theProgram);
599 }
600
601 namespace
602 {
603
604 static const OpenGl_Vec4 THE_COLOR_BLACK_VEC4 (0.0f, 0.0f, 0.0f, 0.0f);
605
606 // =======================================================================
607 // function : PushAspectFace
608 // purpose  :
609 // =======================================================================
610 static void PushAspectFace (const Handle(OpenGl_Context)&       theCtx,
611                             const Handle(OpenGl_ShaderProgram)& theProgram,
612                             const OpenGl_AspectFace*            theAspect)
613 {
614   theProgram->SetUniform (theCtx,
615                           theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
616                           theAspect->DoTextureMap());
617   theProgram->SetUniform (theCtx,
618                           theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),
619                           0 /* GL_TEXTURE0 */);
620   theProgram->SetUniform (theCtx,
621                           theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
622                           theAspect->DistinguishingMode());
623
624   const float aDefSpecCol[4] = {1.0f, 1.0f, 1.0f, 1.0f};
625   OpenGl_Vec4 aParams[5];
626   for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
627   {
628     const GLint aLoc = theProgram->GetStateLocation (anIndex == 0
629                                                    ? OpenGl_OCCT_FRONT_MATERIAL
630                                                    : OpenGl_OCCT_BACK_MATERIAL);
631     if (aLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
632     {
633       continue;
634     }
635
636     const OPENGL_SURF_PROP& aProps = (anIndex == 0) ? theAspect->IntFront() : theAspect->IntBack();
637     const float* aSrcEms = aProps.isphysic ? aProps.emscol.rgb : aProps.matcol.rgb;
638     const OpenGl_Vec4 anEmission (aSrcEms[0] * aProps.emsv,
639                                   aSrcEms[1] * aProps.emsv,
640                                   aSrcEms[2] * aProps.emsv,
641                                   1.0f);
642     const float* aSrcAmb = aProps.isphysic ? aProps.ambcol.rgb : aProps.matcol.rgb;
643     const OpenGl_Vec4 anAmbient  (aSrcAmb[0] * aProps.amb,
644                                   aSrcAmb[1] * aProps.amb,
645                                   aSrcAmb[2] * aProps.amb,
646                                   1.0f);
647     const float* aSrcDif = aProps.isphysic ? aProps.difcol.rgb : aProps.matcol.rgb;
648     const OpenGl_Vec4 aDiffuse   (aSrcDif[0] * aProps.diff,
649                                   aSrcDif[1] * aProps.diff,
650                                   aSrcDif[2] * aProps.diff,
651                                   1.0f);
652     const float* aSrcSpe = aProps.isphysic ? aProps.speccol.rgb : aDefSpecCol;
653     const OpenGl_Vec4 aSpecular  (aSrcSpe[0] * aProps.spec,
654                                   aSrcSpe[1] * aProps.spec,
655                                   aSrcSpe[2] * aProps.spec,
656                                   1.0f);
657
658     aParams[0] = anEmission;
659     aParams[1] = anAmbient;
660     aParams[2] = aDiffuse;
661     aParams[3] = aSpecular;
662     aParams[4].x() = aProps.shine;
663     aParams[4].y() = aProps.trans;
664     theProgram->SetUniform (theCtx, aLoc, 5, aParams);
665   }
666 }
667
668 // =======================================================================
669 // function : PushAspectLine
670 // purpose  :
671 // =======================================================================
672 static void PushAspectLine (const Handle(OpenGl_Context)&       theCtx,
673                             const Handle(OpenGl_ShaderProgram)& theProgram,
674                             const OpenGl_AspectLine*            theAspect)
675 {
676   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOff);
677   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
678
679   const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
680                               theAspect->Color().rgb[1],
681                               theAspect->Color().rgb[2],
682                               theAspect->Color().rgb[3]);
683   OpenGl_Vec4 aParams[5];
684   aParams[0] = THE_COLOR_BLACK_VEC4;
685   aParams[1] = THE_COLOR_BLACK_VEC4;
686   aParams[2] = aDiffuse;
687   aParams[3] = THE_COLOR_BLACK_VEC4;
688   aParams[4].x() = 0.0f; // shininess
689   aParams[4].y() = 0.0f; // transparency
690   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
691                           5, aParams);
692 }
693
694 // =======================================================================
695 // function : PushAspectText
696 // purpose  :
697 // =======================================================================
698 static void PushAspectText (const Handle(OpenGl_Context)&       theCtx,
699                             const Handle(OpenGl_ShaderProgram)& theProgram,
700                             const OpenGl_AspectText*            theAspect)
701 {
702   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
703   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
704   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
705
706   OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
707                         theAspect->Color().rgb[1],
708                         theAspect->Color().rgb[2],
709                         theAspect->Color().rgb[3]);
710   if (theAspect->DisplayType() == Aspect_TODT_DEKALE
711    || theAspect->DisplayType() == Aspect_TODT_SUBTITLE)
712   {
713     aDiffuse = OpenGl_Vec4 (theAspect->SubtitleColor().rgb[0],
714                             theAspect->SubtitleColor().rgb[1],
715                             theAspect->SubtitleColor().rgb[2],
716                             theAspect->SubtitleColor().rgb[3]);
717   }
718
719   OpenGl_Vec4 aParams[5];
720   aParams[0] = THE_COLOR_BLACK_VEC4;
721   aParams[1] = THE_COLOR_BLACK_VEC4;
722   aParams[2] = aDiffuse;
723   aParams[3] = THE_COLOR_BLACK_VEC4;
724   aParams[4].x() = 0.0f; // shininess
725   aParams[4].y() = 0.0f; // transparency
726   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
727                           5, aParams);
728 }
729
730 // =======================================================================
731 // function : PushAspectMarker
732 // purpose  :
733 // =======================================================================
734 static void PushAspectMarker (const Handle(OpenGl_Context)&       theCtx,
735                               const Handle(OpenGl_ShaderProgram)& theProgram,
736                               const OpenGl_AspectMarker*          theAspect)
737 {
738   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
739   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
740   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
741
742   const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
743                               theAspect->Color().rgb[1],
744                               theAspect->Color().rgb[2],
745                               theAspect->Color().rgb[3]);
746   OpenGl_Vec4 aParams[5];
747   aParams[0] = THE_COLOR_BLACK_VEC4;
748   aParams[1] = THE_COLOR_BLACK_VEC4;
749   aParams[2] = aDiffuse;
750   aParams[3] = THE_COLOR_BLACK_VEC4;
751   aParams[4].x() = 0.0f; // shininess
752   aParams[4].y() = 0.0f; // transparency
753   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL),
754                           5, aParams);
755 }
756
757 }; // nameless namespace
758
759 // =======================================================================
760 // function : PushMaterialState
761 // purpose  : Pushes current state of OCCT material to the program
762 // =======================================================================
763 void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
764 {
765   if (!myMaterialStates.IsBound (theProgram))
766   {
767     return;
768   }
769
770   const OpenGl_MaterialState& aState = myMaterialStates.Find (theProgram);
771   if (aState.Index() == theProgram->ActiveState (OpenGl_MATERIALS_STATE))
772   {
773     return;
774   }
775
776   if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectFace))
777   {
778     PushAspectFace   (myContext, theProgram, dynamic_cast<const OpenGl_AspectFace*> (aState.Aspect()));
779   }
780   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectLine))
781   {
782     PushAspectLine   (myContext, theProgram, dynamic_cast<const OpenGl_AspectLine*> (aState.Aspect()));
783   }
784   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectText))
785   {
786     PushAspectText   (myContext, theProgram, dynamic_cast<const OpenGl_AspectText*> (aState.Aspect()));
787   }
788   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectMarker))
789   {
790     PushAspectMarker (myContext, theProgram, dynamic_cast<const OpenGl_AspectMarker*> (aState.Aspect()));
791   }
792
793   theProgram->UpdateState (OpenGl_MATERIALS_STATE, aState.Index());
794 }
795
796 // =======================================================================
797 // function : PushWorldViewState
798 // purpose  : Pushes state of OCCT graphics parameters to the program
799 // =======================================================================
800 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
801 {
802   PushClippingState    (theProgram);
803   PushMaterialState    (theProgram);
804   PushWorldViewState   (theProgram);
805   PushModelWorldState  (theProgram);
806   PushProjectionState  (theProgram);  
807   PushLightSourceState (theProgram);
808 }