0025201: Visualization - Implementing soft shadows and ambient occlusion in OCCT...
[occt.git] / src / OpenGl / OpenGl_AspectFace.cxx
1 // Created on: 2011-07-13
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
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.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <Aspect_PolygonOffsetMode.hxx>
17 #include <NCollection_Vec3.hxx>
18
19 #include <OpenGl_AspectFace.hxx>
20 #include <OpenGl_Context.hxx>
21 #include <OpenGl_ShaderManager.hxx>
22 #include <OpenGl_ShaderProgram.hxx>
23 #include <OpenGl_Texture.hxx>
24 #include <OpenGl_Workspace.hxx>
25
26 #include <Graphic3d_ShaderProgram.hxx>
27 #include <Graphic3d_TextureMap.hxx>
28 #include <Graphic3d_TypeOfReflection.hxx>
29 #include <Graphic3d_MaterialAspect.hxx>
30
31 namespace
32 {
33   static OPENGL_SURF_PROP THE_DEFAULT_MATERIAL =
34   {
35     0.2F,  0.8F, 0.1F, 0.0F, // amb, diff, spec, emsv
36     1.0F, 10.0F, 1.0F, 0.0F, // trans, shine, index, env_reflexion
37     0, // isphysic
38     (OPENGL_AMBIENT_MASK | OPENGL_DIFFUSE_MASK | OPENGL_SPECULAR_MASK), // color_mask
39     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // ambient color
40     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // diffuse color
41     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // specular color
42     {{ 1.0F, 1.0F, 1.0F, 1.0F }}, // emissive color
43     {{ 1.0F, 1.0F, 1.0F, 1.0F }}  // material color
44   };
45
46   static const TCollection_AsciiString THE_EMPTY_KEY;
47 };
48
49 // =======================================================================
50 // function : convertMaterial
51 // purpose  :
52 // =======================================================================
53 void OpenGl_AspectFace::convertMaterial (const CALL_DEF_MATERIAL& theMat,
54                                          OPENGL_SURF_PROP&        theSurf)
55 {
56   theSurf.amb  = theMat.IsAmbient  ? theMat.Ambient  : 0.0f;
57   theSurf.diff = theMat.IsDiffuse  ? theMat.Diffuse  : 0.0f;
58   theSurf.spec = theMat.IsSpecular ? theMat.Specular : 0.0f;
59   theSurf.emsv = theMat.IsEmission ? theMat.Emission : 0.0f;
60
61   theSurf.isphysic = theMat.IsPhysic ? 1 : 0; // type of material
62
63   // color of material
64   theSurf.color_mask = 0;
65   if (theMat.IsAmbient)
66   {
67     theSurf.color_mask |= OPENGL_AMBIENT_MASK;
68   }
69   if (theMat.IsDiffuse)
70   {
71     theSurf.color_mask |= OPENGL_DIFFUSE_MASK;
72   }
73   if (theMat.IsSpecular)
74   {
75     theSurf.color_mask |= OPENGL_SPECULAR_MASK;
76   }
77   if (theMat.IsEmission)
78   {
79     theSurf.color_mask |= OPENGL_EMISSIVE_MASK;
80   }
81
82   // ambient color
83   theSurf.ambcol.rgb[0] = theMat.ColorAmb.r;
84   theSurf.ambcol.rgb[1] = theMat.ColorAmb.g;
85   theSurf.ambcol.rgb[2] = theMat.ColorAmb.b;
86   theSurf.ambcol.rgb[3] = 1.0f;
87
88   // diffuse color
89   theSurf.difcol.rgb[0] = theMat.ColorDif.r;
90   theSurf.difcol.rgb[1] = theMat.ColorDif.g;
91   theSurf.difcol.rgb[2] = theMat.ColorDif.b;
92   theSurf.difcol.rgb[3] = 1.0f;
93
94   // specular color
95   theSurf.speccol.rgb[0] = theMat.ColorSpec.r;
96   theSurf.speccol.rgb[1] = theMat.ColorSpec.g;
97   theSurf.speccol.rgb[2] = theMat.ColorSpec.b;
98   theSurf.speccol.rgb[3] = 1.0f;
99
100   // emission color
101   theSurf.emscol.rgb[0] = theMat.ColorEms.r;
102   theSurf.emscol.rgb[1] = theMat.ColorEms.g;
103   theSurf.emscol.rgb[2] = theMat.ColorEms.b;
104   theSurf.emscol.rgb[3] = 1.0f;
105
106   theSurf.shine = 128.0f * float(theMat.Shininess);
107   theSurf.env_reflexion = theMat.EnvReflexion;
108
109   // trans = 0. => opaque
110   // trans = 1. => transparent
111   // in OpenGl it is opposite.
112   theSurf.trans = 1.0f - theMat.Transparency;
113   theSurf.index = theMat.RefractionIndex;
114
115   // material BSDF (for physically-based rendering)
116   theSurf.BSDF = theMat.BSDF;
117 }
118
119 // =======================================================================
120 // function : OpenGl_AspectFace
121 // purpose  :
122 // =======================================================================
123 OpenGl_AspectFace::OpenGl_AspectFace()
124 : myInteriorStyle (Aspect_IS_SOLID),
125   myEdge (TOff),
126   myHatch (TEL_HS_SOLID),
127   myDistinguishingMode (TOff),
128   myCullingMode (TelCullNone),
129   myIntFront (THE_DEFAULT_MATERIAL),
130   myIntBack (THE_DEFAULT_MATERIAL),
131   myPolygonOffset (THE_DEFAULT_POFFSET),
132   myDoTextureMap (false)
133 {}
134
135 // =======================================================================
136 // function : SetAspect
137 // purpose  :
138 // =======================================================================
139 void OpenGl_AspectFace::SetAspect (const CALL_DEF_CONTEXTFILLAREA& theAspect)
140 {
141   myInteriorStyle = (Aspect_InteriorStyle )theAspect.Style;
142   myEdge = theAspect.Edge ? TOn : TOff;
143
144   //TelInteriorStyleIndex
145   switch (theAspect.Hatch)
146   {
147     case 0: /* Aspect_HS_HORIZONTAL */
148       myHatch = TEL_HS_HORIZONTAL;
149       break;
150     case 1: /* Aspect_HS_HORIZONTAL_WIDE */
151       myHatch = TEL_HS_HORIZONTAL_SPARSE;
152       break;
153     case 2: /* Aspect_HS_VERTICAL */
154       myHatch = TEL_HS_VERTICAL;
155       break;
156     case 3: /* Aspect_HS_VERTICAL_WIDE */
157       myHatch = TEL_HS_VERTICAL_SPARSE;
158       break;
159     case 4: /* Aspect_HS_DIAGONAL_45 */
160       myHatch = TEL_HS_DIAG_45;
161       break;
162     case 5: /* Aspect_HS_DIAGONAL_45_WIDE */
163       myHatch = TEL_HS_DIAG_45_SPARSE;
164       break;
165     case 6: /* Aspect_HS_DIAGONAL_135 */
166       myHatch = TEL_HS_DIAG_135;
167       break;
168     case 7: /* Aspect_HS_DIAGONAL_135_WIDE */
169       myHatch = TEL_HS_DIAG_135_SPARSE;
170       break;
171     case 8: /* Aspect_HS_GRID */
172       myHatch = TEL_HS_GRID;
173       break;
174     case 9: /* Aspect_HS_GRID_WIDE */
175       myHatch = TEL_HS_GRID_SPARSE;
176       break;
177     case 10: /* Aspect_HS_GRID_DIAGONAL */
178       myHatch = TEL_HS_CROSS;
179       break;
180     case 11: /* Aspect_HS_GRID_DIAGONAL_WIDE */
181       myHatch = TEL_HS_CROSS_SPARSE;
182       break;
183     default:
184       myHatch = 0;
185       break;
186   }
187
188   myDistinguishingMode = theAspect.Distinguish ? TOn : TOff;
189   myCullingMode = theAspect.BackFace ? TelCullBack : TelCullNone;
190
191   convertMaterial (theAspect.Front, myIntFront);
192   convertMaterial (theAspect.Back,  myIntBack);
193
194   //TelInteriorColour
195   myIntFront.matcol.rgb[0] = (float )theAspect.IntColor.r;
196   myIntFront.matcol.rgb[1] = (float )theAspect.IntColor.g;
197   myIntFront.matcol.rgb[2] = (float )theAspect.IntColor.b;
198   myIntFront.matcol.rgb[3] = 1.0f;
199
200   //TelBackInteriorColour
201   myIntBack.matcol.rgb[0] = (float )theAspect.BackIntColor.r;
202   myIntBack.matcol.rgb[1] = (float )theAspect.BackIntColor.g;
203   myIntBack.matcol.rgb[2] = (float )theAspect.BackIntColor.b;
204   myIntBack.matcol.rgb[3] = 1.0f;
205
206   //TelPolygonOffset
207   myPolygonOffset.mode   = (Aspect_PolygonOffsetMode )theAspect.PolygonOffsetMode;
208   myPolygonOffset.factor = theAspect.PolygonOffsetFactor;
209   myPolygonOffset.units  = theAspect.PolygonOffsetUnits;
210
211   CALL_DEF_CONTEXTLINE anEdgeAspect;
212   anEdgeAspect.Color.r  = (float )theAspect.EdgeColor.r;
213   anEdgeAspect.Color.g  = (float )theAspect.EdgeColor.g;
214   anEdgeAspect.Color.b  = (float )theAspect.EdgeColor.b;
215   anEdgeAspect.LineType = (Aspect_TypeOfLine )theAspect.LineType;
216   anEdgeAspect.Width    = (float )theAspect.Width;
217   myAspectEdge.SetAspect (anEdgeAspect);
218
219   myDoTextureMap = (theAspect.Texture.doTextureMap != 0);
220
221   // update texture binding
222   myTexture = theAspect.Texture.TextureMap;
223
224   const TCollection_AsciiString& aTextureKey = myTexture.IsNull() ? THE_EMPTY_KEY : myTexture->GetId();
225   if (aTextureKey.IsEmpty() || myResources.TextureId != aTextureKey)
226   {
227     myResources.ResetTextureReadiness();
228   }
229
230   // update shader program binding
231   myShaderProgram = theAspect.ShaderProgram;
232
233   const TCollection_AsciiString& aShaderKey = myShaderProgram.IsNull() ? THE_EMPTY_KEY : myShaderProgram->GetId();
234   if (aShaderKey.IsEmpty() || myResources.ShaderProgramId != aShaderKey)
235   {
236     myResources.ResetShaderReadiness();
237   }
238 }
239
240 // =======================================================================
241 // function : SetAspect
242 // purpose  :
243 // =======================================================================
244 void OpenGl_AspectFace::SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
245 {
246   CALL_DEF_CONTEXTFILLAREA aFaceContext;
247   Standard_Real           aWidth;
248   Quantity_Color          aBackIntColor;
249   Quantity_Color          aEdgeColor;
250   Aspect_TypeOfLine       aLType;
251   Quantity_Color          aIntColor;
252   Aspect_InteriorStyle    aIntStyle;
253   NCollection_Vec3<Standard_Real> aColor;
254
255   theAspect->Values (aIntStyle, aIntColor, aBackIntColor, aEdgeColor, aLType, aWidth);
256   aIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
257
258   aFaceContext.Style      = int (aIntStyle);
259   aFaceContext.IntColor.r = float (aColor.r());
260   aFaceContext.IntColor.g = float (aColor.g());
261   aFaceContext.IntColor.b = float (aColor.b());
262
263   if (theAspect->Distinguish())
264   {
265     aBackIntColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
266   }
267
268   aFaceContext.BackIntColor.r = float (aColor.r());
269   aFaceContext.BackIntColor.g = float (aColor.g());
270   aFaceContext.BackIntColor.b = float (aColor.b());
271
272   aFaceContext.Edge = theAspect->Edge () ? 1:0;
273   aEdgeColor.Values (aColor.r(), aColor.g(), aColor.b(), Quantity_TOC_RGB);
274
275   aFaceContext.EdgeColor.r = float (aColor.r());
276   aFaceContext.EdgeColor.g = float (aColor.g());
277   aFaceContext.EdgeColor.b = float (aColor.b());
278   aFaceContext.LineType    = int (aLType);
279   aFaceContext.Width       = float (aWidth);
280   aFaceContext.Hatch       = int (theAspect->HatchStyle ());
281
282   aFaceContext.Distinguish = theAspect->Distinguish () ? 1:0;
283   aFaceContext.BackFace    = theAspect->BackFace ()    ? 1:0;
284
285   aFaceContext.Back.Shininess = float ((theAspect->BackMaterial ()).Shininess ());
286   aFaceContext.Back.Ambient   = float ((theAspect->BackMaterial ()).Ambient ());
287   aFaceContext.Back.Diffuse   = float ((theAspect->BackMaterial ()).Diffuse ());
288   aFaceContext.Back.Specular  = float ((theAspect->BackMaterial ()).Specular ());
289   aFaceContext.Back.Transparency  = float ((theAspect->BackMaterial ()).Transparency ());
290   aFaceContext.Back.Emission      = float ((theAspect->BackMaterial ()).Emissive ());
291
292   // Reflection mode
293   aFaceContext.Back.IsAmbient = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
294   aFaceContext.Back.IsDiffuse = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
295   aFaceContext.Back.IsSpecular = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
296   aFaceContext.Back.IsEmission = ((theAspect->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
297
298   // Material type
299   const Graphic3d_MaterialAspect aBackMat = theAspect->BackMaterial ();
300   Standard_Boolean isBackPhys = aBackMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
301   aFaceContext.Back.IsPhysic = (isBackPhys ? 1 : 0 );
302
303   // Specular Color
304   aFaceContext.Back.ColorSpec.r = float (((theAspect->BackMaterial ()).SpecularColor ()).Red ());
305   aFaceContext.Back.ColorSpec.g = float (((theAspect->BackMaterial ()).SpecularColor ()).Green ());
306   aFaceContext.Back.ColorSpec.b = float (((theAspect->BackMaterial ()).SpecularColor ()).Blue ());
307
308   // Ambient color
309   aFaceContext.Back.ColorAmb.r = float (((theAspect->BackMaterial ()).AmbientColor ()).Red ());
310   aFaceContext.Back.ColorAmb.g = float (((theAspect->BackMaterial ()).AmbientColor ()).Green ());
311   aFaceContext.Back.ColorAmb.b = float (((theAspect->BackMaterial ()).AmbientColor ()).Blue ());
312
313   // Diffuse color
314   aFaceContext.Back.ColorDif.r = float (((theAspect->BackMaterial ()).DiffuseColor ()).Red ());
315   aFaceContext.Back.ColorDif.g = float (((theAspect->BackMaterial ()).DiffuseColor ()).Green ());
316   aFaceContext.Back.ColorDif.b = float (((theAspect->BackMaterial ()).DiffuseColor ()).Blue ());
317
318   // Emissive color
319   aFaceContext.Back.ColorEms.r = float (((theAspect->BackMaterial ()).EmissiveColor ()).Red ());
320   aFaceContext.Back.ColorEms.g = float (((theAspect->BackMaterial ()).EmissiveColor ()).Green ());
321   aFaceContext.Back.ColorEms.b = float (((theAspect->BackMaterial ()).EmissiveColor ()).Blue ());
322
323   aFaceContext.Back.EnvReflexion = float ((theAspect->BackMaterial ()).EnvReflexion());
324
325   aFaceContext.Front.Shininess    = float ((theAspect->FrontMaterial ()).Shininess ());
326   aFaceContext.Front.Ambient      = float ((theAspect->FrontMaterial ()).Ambient ());
327   aFaceContext.Front.Diffuse      = float ((theAspect->FrontMaterial ()).Diffuse ());
328   aFaceContext.Front.Specular     = float ((theAspect->FrontMaterial ()).Specular ());
329   aFaceContext.Front.Transparency = float ((theAspect->FrontMaterial ()).Transparency ());
330   aFaceContext.Front.Emission     = float ((theAspect->FrontMaterial ()).Emissive ());
331
332   // Reflection mode
333   aFaceContext.Front.IsAmbient    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0);
334   aFaceContext.Front.IsDiffuse    = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0);
335   aFaceContext.Front.IsSpecular   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0);
336   aFaceContext.Front.IsEmission   = ((theAspect->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0);
337
338   // Material type
339   const Graphic3d_MaterialAspect aFrontMat = theAspect->FrontMaterial ();
340   Standard_Boolean isFrontPhys = aFrontMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
341   aFaceContext.Front.IsPhysic = (isFrontPhys ? 1 : 0 );
342
343   // Specular Color
344   aFaceContext.Front.ColorSpec.r = float (((theAspect->FrontMaterial ()).SpecularColor ()).Red ());
345   aFaceContext.Front.ColorSpec.g = float (((theAspect->FrontMaterial ()).SpecularColor ()).Green ());
346   aFaceContext.Front.ColorSpec.b = float (((theAspect->FrontMaterial ()).SpecularColor ()).Blue ());
347
348   // Ambient color
349   aFaceContext.Front.ColorAmb.r = float (((theAspect->FrontMaterial ()).AmbientColor ()).Red ());
350   aFaceContext.Front.ColorAmb.g = float (((theAspect->FrontMaterial ()).AmbientColor ()).Green ());
351   aFaceContext.Front.ColorAmb.b = float (((theAspect->FrontMaterial ()).AmbientColor ()).Blue ());
352
353   // Diffuse color
354   aFaceContext.Front.ColorDif.r = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Red ());
355   aFaceContext.Front.ColorDif.g = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Green ());
356   aFaceContext.Front.ColorDif.b = float (((theAspect->FrontMaterial ()).DiffuseColor ()).Blue ());
357
358   // Emissive color
359   aFaceContext.Front.ColorEms.r = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Red ());
360   aFaceContext.Front.ColorEms.g = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Green ());
361   aFaceContext.Front.ColorEms.b = float (((theAspect->FrontMaterial ()).EmissiveColor ()).Blue ());
362
363   aFaceContext.Front.EnvReflexion = float ((theAspect->FrontMaterial ()).EnvReflexion());
364   aFaceContext.IsDef = 1;
365   aFaceContext.Texture.TextureMap   = theAspect->TextureMap();
366   aFaceContext.Texture.doTextureMap = theAspect->TextureMapState() ? 1 : 0;
367
368   Standard_Integer aPolyMode;
369   Standard_ShortReal aPolyFactor, aPolyUnits;
370   theAspect->PolygonOffsets (aPolyMode, aPolyFactor, aPolyUnits);
371   aFaceContext.PolygonOffsetMode   = aPolyMode;
372   aFaceContext.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
373   aFaceContext.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;
374
375   aFaceContext.ShaderProgram = theAspect->ShaderProgram();
376
377   SetAspect (aFaceContext);
378 }
379
380 // =======================================================================
381 // function : Render
382 // purpose  :
383 // =======================================================================
384 void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
385 {
386   theWorkspace->SetAspectFace (this);
387 }
388
389 // =======================================================================
390 // function : Release
391 // purpose  :
392 // =======================================================================
393 void OpenGl_AspectFace::Release (OpenGl_Context* theContext)
394 {
395   if (!myResources.Texture.IsNull())
396   {
397     if (theContext)
398     {
399       if (myResources.TextureId.IsEmpty())
400       {
401         theContext->DelayedRelease (myResources.Texture);
402       }
403       else
404       {
405         myResources.Texture.Nullify(); // we need nullify all handles before ReleaseResource() call
406         theContext->ReleaseResource (myResources.TextureId, Standard_True);
407       }
408     }
409     myResources.Texture.Nullify();
410   }
411   myResources.TextureId.Clear();
412   myResources.ResetTextureReadiness();
413
414   if (!myResources.ShaderProgram.IsNull()
415    && theContext)
416   {
417     theContext->ShaderManager()->Unregister (myResources.ShaderProgramId,
418                                              myResources.ShaderProgram);
419   }
420   myResources.ShaderProgramId.Clear();
421   myResources.ResetShaderReadiness();
422 }
423
424 // =======================================================================
425 // function : BuildTexture
426 // purpose  :
427 // =======================================================================
428 void OpenGl_AspectFace::Resources::BuildTexture (const Handle(OpenGl_Context)&       theCtx,
429                                                  const Handle(Graphic3d_TextureMap)& theTexture)
430 {
431   // release old texture resource
432   if (!Texture.IsNull())
433   {
434     if (TextureId.IsEmpty())
435     {
436       theCtx->DelayedRelease (Texture);
437       Texture.Nullify();
438     }
439     else
440     {
441       Texture.Nullify(); // we need nullify all handles before ReleaseResource() call
442       theCtx->ReleaseResource (TextureId, Standard_True);
443     }
444   }
445
446   TextureId = theTexture.IsNull() ? THE_EMPTY_KEY : theTexture->GetId();
447
448   if (!theTexture.IsNull())
449   {
450     if (TextureId.IsEmpty() || !theCtx->GetResource<Handle(OpenGl_Texture)> (TextureId, Texture))
451     {
452       Texture = new OpenGl_Texture (theTexture->GetParams());
453       Handle(Image_PixMap) anImage = theTexture->GetImage();
454       if (!anImage.IsNull())
455       {
456         Texture->Init (theCtx, *anImage.operator->(), theTexture->Type());
457       }
458       if (!TextureId.IsEmpty())
459       {
460         theCtx->ShareResource (TextureId, Texture);
461       }
462     }
463   }
464 }
465
466 // =======================================================================
467 // function : BuildShader
468 // purpose  :
469 // =======================================================================
470 void OpenGl_AspectFace::Resources::BuildShader (const Handle(OpenGl_Context)&          theCtx,
471                                                 const Handle(Graphic3d_ShaderProgram)& theShader)
472 {
473   if (theCtx->core20fwd == NULL)
474   {
475     return;
476   }
477
478   // release old shader program resources
479   if (!ShaderProgram.IsNull())
480   {
481     theCtx->ShaderManager()->Unregister (ShaderProgramId, ShaderProgram);
482     ShaderProgramId.Clear();
483     ShaderProgram.Nullify();
484   }
485   if (theShader.IsNull())
486   {
487     return;
488   }
489
490   theCtx->ShaderManager()->Create (theShader, ShaderProgramId, ShaderProgram);
491 }