cff325cadcbe9d021c7f895ae244fe51f9383e0f
[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     theProgram->Share();
72     return;
73   }
74
75   theProgram = new OpenGl_ShaderProgram (theProxy);
76   if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
77   {
78     theProgram->Release (myContext);
79     theShareKey.Clear();
80     theProgram.Nullify();
81     return;
82   }
83
84   myProgramList.Append (theProgram);
85   myContext->ShareResource (theShareKey, theProgram);
86 }
87
88 // =======================================================================
89 // function : Unregister
90 // purpose  : Removes specified shader program from the manager
91 // =======================================================================
92 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString&      theShareKey,
93                                        Handle(OpenGl_ShaderProgram)& theProgram)
94 {
95   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
96   {
97     if (anIt.Value() == theProgram)
98     {
99       if (!theProgram->UnShare())
100       {
101         theShareKey.Clear();
102         theProgram.Nullify();
103         return;
104       }
105
106       myProgramList.Remove (anIt);
107       myMaterialStates.UnBind (theProgram);
108       break;
109     }
110   }
111
112   const TCollection_AsciiString anID = theProgram->myProxy->GetId();
113   if (anID.IsEmpty())
114   {
115     myContext->DelayedRelease (theProgram);
116     theProgram.Nullify();
117   }
118   else
119   {
120     theProgram.Nullify();
121     myContext->ReleaseResource (anID);
122   }
123 }
124
125 // =======================================================================
126 // function : ShaderPrograms
127 // purpose  : Returns list of registered shader programs
128 // =======================================================================
129 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
130 {
131   return myProgramList;
132 }
133
134 // =======================================================================
135 // function : Empty
136 // purpose  : Returns true if no program objects are attached
137 // =======================================================================
138 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
139 {
140   return myProgramList.IsEmpty();
141 }
142
143 // =======================================================================
144 // function : UpdateLightSourceStateTo
145 // purpose  : Updates state of OCCT light sources
146 // =======================================================================
147 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const OpenGl_ListOfLight* theLights)
148 {
149   myLightSourceState.Set (theLights);
150   myLightSourceState.Update();
151 }
152
153 // =======================================================================
154 // function : SetProjectionState
155 // purpose  : Sets new state of OCCT projection transform
156 // =======================================================================
157 void OpenGl_ShaderManager::UpdateProjectionStateTo (const Tmatrix3& theProjectionMatrix)
158 {
159   myProjectionState.Set (theProjectionMatrix);
160   myProjectionState.Update();
161 }
162
163 // =======================================================================
164 // function : SetModelWorldState
165 // purpose  : Sets new state of OCCT model-world transform
166 // =======================================================================
167 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const Tmatrix3& theModelWorldMatrix)
168 {
169   myModelWorldState.Set (theModelWorldMatrix);
170   myModelWorldState.Update();
171 }
172
173 // =======================================================================
174 // function : SetWorldViewState
175 // purpose  : Sets new state of OCCT world-view transform
176 // =======================================================================
177 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const Tmatrix3& theWorldViewMatrix)
178 {
179   myWorldViewState.Set (theWorldViewMatrix);
180   myWorldViewState.Update();
181 }
182
183 // =======================================================================
184 // function : RevertProjectionStateTo
185 // purpose  : Reverts state of OCCT projection transform
186 // =======================================================================
187 void OpenGl_ShaderManager::RevertProjectionStateTo (const Tmatrix3& theProjectionMatrix)
188 {
189   myProjectionState.Set (theProjectionMatrix);
190   myProjectionState.Revert();
191 }
192
193 // =======================================================================
194 // function : RevertModelWorldStateTo
195 // purpose  : Reverts state of OCCT model-world transform
196 // =======================================================================
197 void OpenGl_ShaderManager::RevertModelWorldStateTo (const Tmatrix3& theModelWorldMatrix)
198 {
199   myModelWorldState.Set (theModelWorldMatrix);
200   myModelWorldState.Revert();
201 }
202
203 // =======================================================================
204 // function : RevertWorldViewStateTo
205 // purpose  : Reverts state of OCCT world-view transform
206 // =======================================================================
207 void OpenGl_ShaderManager::RevertWorldViewStateTo (const Tmatrix3& theWorldViewMatrix)
208 {
209   myWorldViewState.Set (theWorldViewMatrix);
210   myWorldViewState.Revert();
211 }
212
213 // =======================================================================
214 // function : LightSourceState
215 // purpose  : Returns current state of OCCT light sources
216 // =======================================================================
217 const OpenGl_LightSourceState& OpenGl_ShaderManager::LightSourceState() const
218 {
219   return myLightSourceState;
220 }
221
222 // =======================================================================
223 // function : ProjectionState
224 // purpose  : Returns current state of OCCT projection transform
225 // =======================================================================
226 const OpenGl_ProjectionState& OpenGl_ShaderManager::ProjectionState() const
227 {
228   return myProjectionState;
229 }
230
231 // =======================================================================
232 // function : ModelWorldState
233 // purpose  : Returns current state of OCCT model-world transform
234 // =======================================================================
235 const OpenGl_ModelWorldState& OpenGl_ShaderManager::ModelWorldState() const
236 {
237   return myModelWorldState;
238 }
239
240 // =======================================================================
241 // function : WorldViewState
242 // purpose  : Returns current state of OCCT world-view transform
243 // =======================================================================
244 const OpenGl_WorldViewState& OpenGl_ShaderManager::WorldViewState() const
245 {
246   return myWorldViewState;
247 }
248
249 // =======================================================================
250 // function : PushLightSourceState
251 // purpose  : Pushes state of OCCT light sources to the program
252 // =======================================================================
253 void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
254 {
255   if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE))
256   {
257     return;
258   }
259   
260   theProgram->SetUniform (myContext, theProgram->GetStateLocation (
261     OpenGl_OCC_LIGHT_SOURCE_COUNT), myLightSourceState.LightSources()->Size());
262
263   OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources());
264   for (unsigned int anIndex = 0; anIter.More(); anIter.Next())
265   {
266     if (anIndex >= OpenGLMaxLights)
267     {
268       break;
269     }
270
271     const OpenGl_Light& aLight = anIter.Value();
272     if (aLight.type == TLightAmbient)
273     {
274       OpenGl_Vec3 anAmbient (aLight.col.rgb[0],
275                              aLight.col.rgb[1],
276                              aLight.col.rgb[2]);
277
278       theProgram->SetUniform (myContext,
279         theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_AMBIENT + anIndex), anAmbient);
280
281       anIter.Next();
282       if (!anIter.More())
283       {
284         theProgram->SetUniform (myContext,
285           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_TYPE + anIndex), int (aLight.type));
286         break;
287       }
288     }
289
290     OpenGl_Vec3 aDiffuse (aLight.col.rgb[0],
291                           aLight.col.rgb[1],
292                           aLight.col.rgb[2]);
293
294     OpenGl_Vec3 aPosition (aLight.type == TLightDirectional ? -aLight.dir[0] : aLight.pos[0],
295                            aLight.type == TLightDirectional ? -aLight.dir[1] : aLight.pos[1],
296                            aLight.type == TLightDirectional ? -aLight.dir[2] : aLight.pos[2]);
297
298     theProgram->SetUniform (myContext,
299       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_TYPE + anIndex), int (aLight.type));
300
301     theProgram->SetUniform (myContext,
302       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_HEAD + anIndex), aLight.HeadLight);
303
304     theProgram->SetUniform (myContext,
305       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_DIFFUSE + anIndex), aDiffuse);
306
307     theProgram->SetUniform (myContext,
308       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPECULAR + anIndex), aDiffuse);
309
310     theProgram->SetUniform (myContext,
311       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_POSITION + anIndex), aPosition);
312
313     theProgram->SetUniform (myContext,
314       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_CONST_ATTENUATION + anIndex), aLight.atten[0]);
315
316     theProgram->SetUniform (myContext,
317       theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_LINEAR_ATTENUATION + anIndex), aLight.atten[1]);
318
319     if (aLight.type == TLightSpot)
320     {
321       OpenGl_Vec3 aDirection (aLight.dir[0],
322                               aLight.dir[1],
323                               aLight.dir[2]);
324
325       theProgram->SetUniform (myContext,
326         theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_CUTOFF + anIndex), aLight.angle);
327
328       theProgram->SetUniform (myContext,
329         theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_EXPONENT + anIndex), aLight.shine);
330
331       theProgram->SetUniform (myContext,
332         theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_0_SPOT_DIRECTION + anIndex), aDirection);
333     }
334
335     ++anIndex;
336   }
337
338   theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
339 }
340
341 // =======================================================================
342 // function : PushProjectionState
343 // purpose  : Pushes state of OCCT projection transform to the program
344 // =======================================================================
345 void OpenGl_ShaderManager::PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
346 {
347   if (myProjectionState.Index() == theProgram->ActiveState (OpenGl_PROJECTION_STATE))
348   {
349     return;
350   }
351
352   theProgram->SetUniform (myContext,
353                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
354                           myProjectionState.ProjectionMatrix());
355
356   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
357   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
358   {
359     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
360   }
361
362   theProgram->SetUniform (myContext,
363                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
364                           myProjectionState.ProjectionMatrix(), true);
365
366   aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
367   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
368   {
369     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
370   }
371
372   theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
373 }
374
375 // =======================================================================
376 // function : PushModelWorldState
377 // purpose  : Pushes state of OCCT model-world transform to the program
378 // =======================================================================
379 void OpenGl_ShaderManager::PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
380 {
381   if (myModelWorldState.Index() == theProgram->ActiveState (OpenGl_MODEL_WORLD_STATE))
382   {
383     return;
384   }
385
386   theProgram->SetUniform (myContext,
387                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
388                           myModelWorldState.ModelWorldMatrix());
389
390   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
391   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
392   {
393     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
394   }
395
396   theProgram->SetUniform (myContext,
397                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
398                           myModelWorldState.ModelWorldMatrix(), true);
399
400   aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
401   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
402   {
403     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
404   }
405
406   theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
407 }
408
409 // =======================================================================
410 // function : PushWorldViewState
411 // purpose  : Pushes state of OCCT world-view transform to the program
412 // =======================================================================
413 void OpenGl_ShaderManager::PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
414 {
415   if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
416   {
417     return;
418   }
419
420   theProgram->SetUniform (myContext,
421                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
422                           myWorldViewState.WorldViewMatrix());
423
424   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
425   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
426   {
427     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
428   }
429
430   theProgram->SetUniform (myContext,
431                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
432                           myWorldViewState.WorldViewMatrix(), true);
433
434   aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
435   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
436   {
437     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
438   }
439
440   theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
441 }
442
443 // =======================================================================
444 // function : UpdateClippingState
445 // purpose  : Updates state of OCCT clipping planes
446 // =======================================================================
447 void OpenGl_ShaderManager::UpdateClippingState()
448 {
449   myClippingState.Update();
450 }
451
452 // =======================================================================
453 // function : RevertClippingState
454 // purpose  : Reverts state of OCCT clipping planes
455 // =======================================================================
456 void OpenGl_ShaderManager::RevertClippingState()
457 {
458   myClippingState.Revert();
459 }
460
461 // =======================================================================
462 // function : PushClippingState
463 // purpose  : Pushes state of OCCT clipping planes to the program
464 // =======================================================================
465 void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
466 {
467   if (myClippingState.Index() == theProgram->ActiveState (OpenGl_CLIP_PLANES_STATE))
468   {
469     return;
470   }
471
472   Graphic3d_SetOfHClipPlane::Iterator anIter (myContext->Clipping().Planes());
473   for (GLuint anIndex = 0; anIter.More(); anIter.Next())
474   {
475     const Handle(Graphic3d_ClipPlane)& aPlane = anIter.Value();
476     if (!myContext->Clipping().IsEnabled (aPlane))
477     {
478       continue;
479     }
480
481     GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_0_EQUATION + anIndex);
482     if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
483     {
484       const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
485       theProgram->SetUniform (myContext, aLocation, OpenGl_Vec4 ((float) anEquation.x(),
486                                                                  (float) anEquation.y(),
487                                                                  (float) anEquation.z(),
488                                                                  (float) anEquation.w()));
489     }
490
491     theProgram->SetUniform (myContext,
492                             theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_0_SPACE + anIndex),
493                             myContext->Clipping().GetEquationSpace (aPlane));
494     ++anIndex;
495   }
496
497   theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
498 }
499
500 // =======================================================================
501 // function : UpdateMaterialStateTo
502 // purpose  : Updates state of OCCT material for specified program
503 // =======================================================================
504 void OpenGl_ShaderManager::UpdateMaterialStateTo (const Handle(OpenGl_ShaderProgram)& theProgram,
505                                                   const OpenGl_Element*               theAspect)
506 {
507   if (myMaterialStates.IsBound (theProgram))
508   {
509     myMaterialStates.ChangeFind (theProgram).Set (theAspect);
510   }
511   else
512   {
513     myMaterialStates.Bind (theProgram, OpenGl_MaterialState (theAspect));
514   }
515
516   myMaterialStates.ChangeFind (theProgram).Update();
517 }
518
519 // =======================================================================
520 // function : ResetMaterialStates
521 // purpose  : Resets state of OCCT material for all programs
522 // =======================================================================
523 void OpenGl_ShaderManager::ResetMaterialStates()
524 {
525   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
526   {
527     anIt.Value()->UpdateState (OpenGl_MATERIALS_STATE, 0);
528   }
529 }
530
531 // =======================================================================
532 // function : MaterialState
533 // purpose  : Returns state of OCCT material for specified program
534 // =======================================================================
535 const OpenGl_MaterialState* OpenGl_ShaderManager::MaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
536 {
537   if (!myMaterialStates.IsBound (theProgram))
538     return NULL;
539
540   return &myMaterialStates.Find (theProgram);
541 }
542
543 namespace
544 {
545
546 static const OpenGl_Vec4 THE_COLOR_BLACK_VEC4 (0.0f, 0.0f, 0.0f, 0.0f);
547
548 // =======================================================================
549 // function : PushAspectFace
550 // purpose  :
551 // =======================================================================
552 static void PushAspectFace (const Handle(OpenGl_Context)&       theCtx,
553                             const Handle(OpenGl_ShaderProgram)& theProgram,
554                             const OpenGl_AspectFace*            theAspect)
555 {
556   theProgram->SetUniform (theCtx,
557                           theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
558                           theAspect->DoTextureMap());
559
560   theProgram->SetUniform (theCtx,
561                           theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),
562                           0 /* GL_TEXTURE0 */);
563
564   theProgram->SetUniform (theCtx,
565                           theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
566                           theAspect->DistinguishingMode());
567
568   for (int anIndex = 0; anIndex < 2; ++anIndex)
569   {
570     const OPENGL_SURF_PROP& aProperties = (anIndex == 0) ? theAspect->IntFront() : theAspect->IntBack();
571     GLint aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT + anIndex);
572     if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
573     {
574       OpenGl_Vec4 anAmbient (aProperties.ambcol.rgb[0] * aProperties.amb,
575                              aProperties.ambcol.rgb[1] * aProperties.amb,
576                              aProperties.ambcol.rgb[2] * aProperties.amb,
577                              aProperties.ambcol.rgb[3] * aProperties.amb);
578       theProgram->SetUniform (theCtx, aLocation, anAmbient);
579     }
580
581     aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE + anIndex);
582     if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
583     {
584       OpenGl_Vec4 aDiffuse (aProperties.difcol.rgb[0] * aProperties.diff,
585                             aProperties.difcol.rgb[1] * aProperties.diff,
586                             aProperties.difcol.rgb[2] * aProperties.diff,
587                             aProperties.difcol.rgb[3] * aProperties.diff);
588       theProgram->SetUniform (theCtx, aLocation, aDiffuse);
589     }
590
591     aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR + anIndex);
592     if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
593     {
594       OpenGl_Vec4 aSpecular (aProperties.speccol.rgb[0] * aProperties.spec,
595                              aProperties.speccol.rgb[1] * aProperties.spec,
596                              aProperties.speccol.rgb[2] * aProperties.spec,
597                              aProperties.speccol.rgb[3] * aProperties.spec);
598       theProgram->SetUniform (theCtx, aLocation, aSpecular);
599     }
600
601     aLocation = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION + anIndex);
602     if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
603     {
604       OpenGl_Vec4 anEmission (aProperties.emscol.rgb[0] * aProperties.emsv,
605                               aProperties.emscol.rgb[1] * aProperties.emsv,
606                               aProperties.emscol.rgb[2] * aProperties.emsv,
607                               aProperties.emscol.rgb[3] * aProperties.emsv);
608       theProgram->SetUniform (theCtx, aLocation, anEmission);
609     }
610     
611     theProgram->SetUniform (theCtx,
612                             theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SHININESS + anIndex),
613                             aProperties.shine);
614
615     theProgram->SetUniform (theCtx,
616                             theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY + anIndex),
617                             aProperties.trans);
618   }
619 }
620
621 // =======================================================================
622 // function : PushAspectLine
623 // purpose  :
624 // =======================================================================
625 static void PushAspectLine (const Handle(OpenGl_Context)&       theCtx,
626                             const Handle(OpenGl_ShaderProgram)& theProgram,
627                             const OpenGl_AspectLine*            theAspect)
628 {
629   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOff);
630   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
631
632   const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
633                               theAspect->Color().rgb[1],
634                               theAspect->Color().rgb[2],
635                               theAspect->Color().rgb[3]);
636   theProgram->SetUniform (theCtx,
637                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT),
638                           THE_COLOR_BLACK_VEC4);
639   theProgram->SetUniform (theCtx,
640                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE),
641                           aDiffuse);
642   theProgram->SetUniform (theCtx,
643                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR),
644                           THE_COLOR_BLACK_VEC4);
645   theProgram->SetUniform (theCtx,
646                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
647                           THE_COLOR_BLACK_VEC4);
648   theProgram->SetUniform (theCtx,
649                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
650                           0.0f);
651 }
652
653 // =======================================================================
654 // function : PushAspectText
655 // purpose  :
656 // =======================================================================
657 static void PushAspectText (const Handle(OpenGl_Context)&       theCtx,
658                             const Handle(OpenGl_ShaderProgram)& theProgram,
659                             const OpenGl_AspectText*            theAspect)
660 {
661   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
662   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
663   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
664
665   OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
666                         theAspect->Color().rgb[1],
667                         theAspect->Color().rgb[2],
668                         theAspect->Color().rgb[3]);
669   if (theAspect->DisplayType() == Aspect_TODT_DEKALE
670    || theAspect->DisplayType() == Aspect_TODT_SUBTITLE)
671   {
672     aDiffuse = OpenGl_Vec4 (theAspect->SubtitleColor().rgb[0],
673                             theAspect->SubtitleColor().rgb[1],
674                             theAspect->SubtitleColor().rgb[2],
675                             theAspect->SubtitleColor().rgb[3]);
676   }
677
678   theProgram->SetUniform (theCtx,
679                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT),
680                           THE_COLOR_BLACK_VEC4);
681   theProgram->SetUniform (theCtx,
682                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE),
683                           aDiffuse);
684   theProgram->SetUniform (theCtx,
685                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR),
686                           THE_COLOR_BLACK_VEC4);
687   theProgram->SetUniform (theCtx,
688                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
689                           THE_COLOR_BLACK_VEC4);
690   theProgram->SetUniform (theCtx,
691                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
692                           0.0f);
693 }
694
695 // =======================================================================
696 // function : PushAspectMarker
697 // purpose  :
698 // =======================================================================
699 static void PushAspectMarker (const Handle(OpenGl_Context)&       theCtx,
700                               const Handle(OpenGl_ShaderProgram)& theProgram,
701                               const OpenGl_AspectMarker*          theAspect)
702 {
703   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),   TOn);
704   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE), TOff);
705   theProgram->SetUniform (theCtx, theProgram->GetStateLocation (OpenGl_OCCT_ACTIVE_SAMPLER),   0 /* GL_TEXTURE0 */);
706
707   const OpenGl_Vec4 aDiffuse (theAspect->Color().rgb[0],
708                               theAspect->Color().rgb[1],
709                               theAspect->Color().rgb[2],
710                               theAspect->Color().rgb[3]);
711
712   theProgram->SetUniform (theCtx,
713                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_AMBIENT),
714                           THE_COLOR_BLACK_VEC4);
715   theProgram->SetUniform (theCtx,
716                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_DIFFUSE),
717                           aDiffuse);
718   theProgram->SetUniform (theCtx,
719                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_SPECULAR),
720                           THE_COLOR_BLACK_VEC4);
721   theProgram->SetUniform (theCtx,
722                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_EMISSION),
723                           THE_COLOR_BLACK_VEC4);
724   theProgram->SetUniform (theCtx,
725                           theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL_TRANSPARENCY),
726                           0.0f);
727 }
728
729 }; // nameless namespace
730
731 // =======================================================================
732 // function : PushMaterialState
733 // purpose  : Pushes current state of OCCT material to the program
734 // =======================================================================
735 void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
736 {
737   if (!myMaterialStates.IsBound (theProgram))
738   {
739     return;
740   }
741
742   const OpenGl_MaterialState& aState = myMaterialStates.Find (theProgram);
743   if (aState.Index() == theProgram->ActiveState (OpenGl_MATERIALS_STATE))
744   {
745     return;
746   }
747
748   if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectFace))
749   {
750     PushAspectFace   (myContext, theProgram, dynamic_cast<const OpenGl_AspectFace*> (aState.Aspect()));
751   }
752   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectLine))
753   {
754     PushAspectLine   (myContext, theProgram, dynamic_cast<const OpenGl_AspectLine*> (aState.Aspect()));
755   }
756   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectText))
757   {
758     PushAspectText   (myContext, theProgram, dynamic_cast<const OpenGl_AspectText*> (aState.Aspect()));
759   }
760   else if (typeid (*aState.Aspect()) == typeid (OpenGl_AspectMarker))
761   {
762     PushAspectMarker (myContext, theProgram, dynamic_cast<const OpenGl_AspectMarker*> (aState.Aspect()));
763   }
764
765   theProgram->UpdateState (OpenGl_MATERIALS_STATE, aState.Index());
766 }
767
768 // =======================================================================
769 // function : PushWorldViewState
770 // purpose  : Pushes state of OCCT graphics parameters to the program
771 // =======================================================================
772 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
773 {
774   PushClippingState    (theProgram);
775   PushMaterialState    (theProgram);
776   PushWorldViewState   (theProgram);
777   PushModelWorldState  (theProgram);
778   PushProjectionState  (theProgram);  
779   PushLightSourceState (theProgram);
780 }