0030748: Visualization - Marker displayed in immediate layer ruins QT Quick view...
[occt.git] / src / OpenGl / OpenGl_SceneGeometry.hxx
1 // Created on: 2013-08-27
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013-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 #ifndef _OpenGl_SceneGeometry_Header
17 #define _OpenGl_SceneGeometry_Header
18
19 #include <BVH_Geometry.hxx>
20 #include <BVH_Triangulation.hxx>
21 #include <BVH_BinnedBuilder.hxx>
22 #include <NCollection_StdAllocator.hxx>
23 #include <OpenGl_TextureBufferArb.hxx>
24 #include <OpenGl_Texture.hxx>
25 #include <OpenGl_Sampler.hxx>
26
27 class  OpenGl_Element;
28 struct OpenGl_ElementNode;
29 class  OpenGl_Group;
30 class  OpenGl_Structure;
31 class  OpenGl_PrimitiveArray;
32
33 namespace OpenGl_Raytrace
34 {
35   //! Checks to see if the group contains ray-trace geometry.
36   Standard_Boolean IsRaytracedGroup (const OpenGl_Group* theGroup);
37
38   //! Checks to see if the element contains ray-trace geometry.
39   Standard_Boolean IsRaytracedElement (const OpenGl_ElementNode* theNode);
40
41   //! Checks to see if the element contains ray-trace geometry.
42   Standard_Boolean IsRaytracedElement (const OpenGl_Element* theElement);
43 }
44
45 //! Stores properties of surface material.
46 class OpenGl_RaytraceMaterial
47 {
48 public:
49
50   //! Ambient reflection coefficient.
51   BVH_Vec4f Ambient;
52
53   //! Diffuse reflection coefficient.
54   BVH_Vec4f Diffuse;
55
56   //! Glossy reflection coefficient.
57   BVH_Vec4f Specular;
58
59   //! Material emission.
60   BVH_Vec4f Emission;
61
62   //! Specular reflection coefficient.
63   BVH_Vec4f Reflection;
64
65   //! Specular refraction coefficient.
66   BVH_Vec4f Refraction;
67
68   //! Material transparency.
69   BVH_Vec4f Transparency;
70
71   //! Texture transformation matrix.
72   BVH_Mat4f TextureTransform;
73
74   //! Physically-based material properties (used in path tracing engine).
75   struct Physical
76   {
77     //! Weight of coat specular/glossy BRDF.
78     BVH_Vec4f Kc;
79
80     //! Weight of base diffuse BRDF.
81     BVH_Vec4f Kd;
82
83     //! Weight of base specular/glossy BRDF.
84     BVH_Vec4f Ks;
85
86     //! Weight of base specular/glossy BTDF.
87     BVH_Vec4f Kt;
88
89     //! Radiance emitted by the surface.
90     BVH_Vec4f Le;
91
92     //! Fresnel coefficients of coat layer.
93     BVH_Vec4f FresnelCoat;
94
95     //! Fresnel coefficients of base layer.
96     BVH_Vec4f FresnelBase;
97
98     //! Absorption color/intensity.
99     BVH_Vec4f Absorption;
100
101   } BSDF;
102
103 public:
104
105   //! Creates new default material.
106   OpenGl_RaytraceMaterial();
107
108   //! Creates new material with specified properties.
109   OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
110                            const BVH_Vec4f& theDiffuse,
111                            const BVH_Vec4f& theSpecular);
112
113   //! Creates new material with specified properties.
114   OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
115                            const BVH_Vec4f& theDiffuse,
116                            const BVH_Vec4f& theSpecular,
117                            const BVH_Vec4f& theEmission,
118                            const BVH_Vec4f& theTranspar);
119
120   //! Creates new material with specified properties.
121   OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
122                            const BVH_Vec4f& theDiffuse,
123                            const BVH_Vec4f& theSpecular,
124                            const BVH_Vec4f& theEmission,
125                            const BVH_Vec4f& theTranspar,
126                            const BVH_Vec4f& theReflection,
127                            const BVH_Vec4f& theRefraction);
128
129   //! Returns packed (serialized) representation of material.
130   const Standard_ShortReal* Packed()
131   {
132     return reinterpret_cast<Standard_ShortReal*> (this);
133   }
134 };
135
136 //! Stores properties of OpenGL light source.
137 class OpenGl_RaytraceLight
138 {
139 public:
140
141   //! Diffuse intensity (in terms of OpenGL).
142   BVH_Vec4f Emission;
143
144   //! Position of light source (in terms of OpenGL).
145   BVH_Vec4f Position;
146
147 public:
148
149   //! Creates new light source.
150   OpenGl_RaytraceLight() { }
151
152   //! Creates new light source.
153   OpenGl_RaytraceLight (const BVH_Vec4f& theEmission,
154                         const BVH_Vec4f& thePosition);
155
156   //! Returns packed (serialized) representation of light source.
157   const Standard_ShortReal* Packed()
158   {
159     return reinterpret_cast<Standard_ShortReal*> (this);
160   }
161 };
162
163 //! Shared pointer to quad BVH (QBVH) tree.
164 typedef opencascade::handle<BVH_Tree<Standard_ShortReal, 3, BVH_QuadTree> > QuadBvhHandle;
165 typedef BVH_Triangulation<Standard_ShortReal, 3> OpenGl_BVHTriangulation3f;
166
167 //! Triangulation of single OpenGL primitive array.
168 class OpenGl_TriangleSet : public OpenGl_BVHTriangulation3f
169 {
170   DEFINE_STANDARD_RTTIEXT(OpenGl_TriangleSet, OpenGl_BVHTriangulation3f)
171 public:
172
173   //! Value of invalid material index to return in case of errors.
174   static const Standard_Integer INVALID_MATERIAL = -1;
175
176 public:
177
178   //! Creates new OpenGL element triangulation.
179   OpenGl_TriangleSet (const Standard_Size theArrayID,
180                       const opencascade::handle<BVH_Builder<Standard_ShortReal, 3> >& theBuilder);
181
182   //! Returns ID of associated primitive array.
183   Standard_Size AssociatedPArrayID() const
184   {
185     return myArrayID;
186   }
187
188   //! Returns material index of triangle set.
189   Standard_Integer MaterialIndex() const
190   {
191     if (Elements.size() == 0)
192     {
193       return INVALID_MATERIAL;
194     }
195
196     return Elements.front().w();
197   }
198
199   //! Sets material index for entire triangle set.
200   void SetMaterialIndex (Standard_Integer theMatID)
201   {
202     for (Standard_Size anIdx = 0; anIdx < Elements.size(); ++anIdx)
203     {
204       Elements[anIdx].w() = theMatID;
205     }
206   }
207
208   //! Returns AABB of primitive set.
209   virtual BVH_BoxNt Box() const Standard_OVERRIDE;
210
211   //! Returns AABB of the given object.
212   using BVH_Triangulation<Standard_ShortReal, 3>::Box;
213
214   //! Returns centroid position along the given axis.
215   virtual Standard_ShortReal Center (const Standard_Integer theIndex, const Standard_Integer theAxis) const Standard_OVERRIDE;
216
217   //! Returns quad BVH (QBVH) tree produced from binary BVH.
218   const QuadBvhHandle& QuadBVH();
219
220 public:
221
222   BVH_Array3f Normals; //!< Array of vertex normals.
223   BVH_Array2f TexCrds; //!< Array of texture coords.
224
225 private:
226
227   Standard_Size myArrayID; //!< ID of associated primitive array.
228
229   QuadBvhHandle myQuadBVH; //!< QBVH produced from binary BVH tree.
230
231 };
232
233 //! Stores geometry of ray-tracing scene.
234 class OpenGl_RaytraceGeometry : public BVH_Geometry<Standard_ShortReal, 3>
235 {
236 public:
237
238   //! Value of invalid offset to return in case of errors.
239   static const Standard_Integer INVALID_OFFSET = -1;
240
241   //! Maximum number of textures used in ray-tracing shaders.
242   //! This is not restriction of the solution implemented, but
243   //! rather the reasonable limit of the number of textures in
244   //! various applications (can be increased if needed).
245   static const Standard_Integer MAX_TEX_NUMBER = 32;
246
247 public:
248
249   //! Array of properties of light sources.
250   std::vector<OpenGl_RaytraceLight,
251     NCollection_StdAllocator<OpenGl_RaytraceLight> > Sources;
252
253   //! Array of 'front' material properties.
254   std::vector<OpenGl_RaytraceMaterial,
255     NCollection_StdAllocator<OpenGl_RaytraceMaterial> > Materials;
256
257   //! Global ambient from all light sources.
258   BVH_Vec4f Ambient;
259
260 public:
261
262   //! Creates uninitialized ray-tracing geometry.
263   OpenGl_RaytraceGeometry()
264   : BVH_Geometry<Standard_ShortReal, 3>(),
265     myTopLevelTreeDepth (0),
266     myBotLevelTreeDepth (0)
267   {
268     //
269   }
270
271   //! Releases resources of ray-tracing geometry.
272   ~OpenGl_RaytraceGeometry()
273   {
274     //
275   }
276
277   //! Clears only ray-tracing materials.
278   void ClearMaterials()
279   {
280     std::vector<OpenGl_RaytraceMaterial,
281       NCollection_StdAllocator<OpenGl_RaytraceMaterial> > anEmptyMaterials;
282
283     Materials.swap (anEmptyMaterials);
284
285     myTextures.Clear();
286   }
287
288   //! Clears ray-tracing geometry.
289   virtual void Clear() Standard_OVERRIDE;
290
291 public: //! @name methods related to acceleration structure
292
293   //! Performs post-processing of high-level scene BVH.
294   Standard_Boolean ProcessAcceleration();
295
296   //! Returns offset of bottom-level BVH for given leaf node.
297   //! If the node index is not valid the function returns -1.
298   //! @note Can be used after processing acceleration structure.
299   Standard_Integer AccelerationOffset (Standard_Integer theNodeIdx);
300
301   //! Returns offset of triangulation vertices for given leaf node.
302   //! If the node index is not valid the function returns -1.
303   //! @note Can be used after processing acceleration structure.
304   Standard_Integer VerticesOffset (Standard_Integer theNodeIdx);
305
306   //! Returns offset of triangulation elements for given leaf node.
307   //! If the node index is not valid the function returns -1.
308   //! @note Can be used after processing acceleration structure.
309   Standard_Integer ElementsOffset (Standard_Integer theNodeIdx);
310
311   //! Returns triangulation data for given leaf node.
312   //! If the node index is not valid the function returns NULL.
313   //! @note Can be used after processing acceleration structure.
314   OpenGl_TriangleSet* TriangleSet (Standard_Integer theNodeIdx);
315
316   //! Returns quad BVH (QBVH) tree produced from binary BVH.
317   const QuadBvhHandle& QuadBVH();
318
319 public: //! @name methods related to texture management
320
321   //! Checks if scene contains textured objects.
322   Standard_Boolean HasTextures() const
323   {
324     return !myTextures.IsEmpty();
325   }
326
327   //! Adds new OpenGL texture to the scene and returns its index.
328   Standard_Integer AddTexture (const Handle(OpenGl_Texture)& theTexture);
329
330   //! Updates unique 64-bit texture handles to use in shaders.
331   Standard_Boolean UpdateTextureHandles (const Handle(OpenGl_Context)& theContext);
332
333   //! Makes the OpenGL texture handles resident (must be called before using).
334   Standard_Boolean AcquireTextures (const Handle(OpenGl_Context)& theContext);
335
336   //! Makes the OpenGL texture handles non-resident (must be called after using).
337   Standard_Boolean ReleaseTextures (const Handle(OpenGl_Context)& theContext) const;
338
339   //! Returns array of texture handles.
340   const std::vector<GLuint64>& TextureHandles() const
341   {
342     return myTextureHandles;
343   }
344
345   //! Releases OpenGL resources.
346   void ReleaseResources (const Handle(OpenGl_Context)& )
347   {
348     //
349   }
350
351 public: //! @name auxiliary methods
352
353   //! Returns depth of top-level scene BVH from last build.
354   Standard_Integer TopLevelTreeDepth() const
355   {
356     return myTopLevelTreeDepth;
357   }
358
359   //! Returns maximum depth of bottom-level scene BVHs from last build.
360   Standard_Integer BotLevelTreeDepth() const
361   {
362     return myBotLevelTreeDepth;
363   }
364
365 protected:
366
367   NCollection_Vector<Handle(OpenGl_Texture)> myTextures;           //!< Array of texture maps shared between rendered objects
368   std::vector<GLuint64>                      myTextureHandles;     //!< Array of unique 64-bit texture handles obtained from OpenGL
369   Standard_Integer                           myTopLevelTreeDepth;  //!< Depth of high-level scene BVH from last build
370   Standard_Integer                           myBotLevelTreeDepth;  //!< Maximum depth of bottom-level scene BVHs from last build
371
372   QuadBvhHandle myQuadBVH; //!< QBVH produced from binary BVH tree.
373
374 };
375
376 #endif