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