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