0025703: Visualization - Decrease number of samplers used in ray-tracing mode
[occt.git] / src / OpenGl / OpenGl_SceneGeometry.cxx
1 // Created on: 2013-08-27
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013 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 #ifdef HAVE_TBB
17   // On Windows, function TryEnterCriticalSection has appeared in Windows NT
18   // and is surrounded by #ifdef in MS VC++ 7.1 headers.
19   // Thus to use it we need to define appropriate macro saying that we will
20   // run on Windows NT 4.0 at least
21   #if defined(_WIN32) && !defined(_WIN32_WINNT)
22     #define _WIN32_WINNT 0x0501
23   #endif
24
25   #include <tbb/tbb.h>
26 #endif
27
28 #include <OpenGl_SceneGeometry.hxx>
29
30 #include <OpenGl_ArbTexBindless.hxx>
31 #include <OpenGl_PrimitiveArray.hxx>
32 #include <OpenGl_Structure.hxx>
33 #include <OSD_Timer.hxx>
34 #include <Standard_Assert.hxx>
35
36 //! Use this macro to output BVH profiling info
37 // #define RAY_TRACE_PRINT_INFO
38
39 namespace
40 {
41   //! Useful constant for null floating-point 4D vector.
42   static const BVH_Vec4f ZERO_VEC_4F;
43 }
44
45 // =======================================================================
46 // function : OpenGl_RaytraceMaterial
47 // purpose  : Creates new default material
48 // =======================================================================
49 OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial()
50 : Ambient      (ZERO_VEC_4F),
51   Diffuse      (ZERO_VEC_4F),
52   Specular     (ZERO_VEC_4F),
53   Emission     (ZERO_VEC_4F),
54   Reflection   (ZERO_VEC_4F),
55   Refraction   (ZERO_VEC_4F),
56   Transparency (ZERO_VEC_4F)
57 { }
58
59 // =======================================================================
60 // function : OpenGl_RaytraceMaterial
61 // purpose  : Creates new material with specified properties
62 // =======================================================================
63 OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
64                                                   const BVH_Vec4f& theDiffuse,
65                                                   const BVH_Vec4f& theSpecular)
66 : Ambient      (theAmbient),
67   Diffuse      (theDiffuse),
68   Specular     (theSpecular),
69   Emission     (ZERO_VEC_4F),
70   Reflection   (ZERO_VEC_4F),
71   Refraction   (ZERO_VEC_4F),
72   Transparency (ZERO_VEC_4F)
73 {
74   //
75 }
76
77 // =======================================================================
78 // function : OpenGl_RaytraceMaterial
79 // purpose  : Creates new material with specified properties
80 // =======================================================================
81 OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
82                                                   const BVH_Vec4f& theDiffuse,
83                                                   const BVH_Vec4f& theSpecular,
84                                                   const BVH_Vec4f& theEmission,
85                                                   const BVH_Vec4f& theTranspar)
86 : Ambient      (theAmbient),
87   Diffuse      (theDiffuse),
88   Specular     (theSpecular),
89   Emission     (theEmission),
90   Reflection   (ZERO_VEC_4F),
91   Refraction   (ZERO_VEC_4F),
92   Transparency (theTranspar)
93 {
94   //
95 }
96
97 // =======================================================================
98 // function : OpenGl_RaytraceMaterial
99 // purpose  : Creates new material with specified properties
100 // =======================================================================
101 OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
102                                                   const BVH_Vec4f& theDiffuse,
103                                                   const BVH_Vec4f& theSpecular,
104                                                   const BVH_Vec4f& theEmission,
105                                                   const BVH_Vec4f& theTranspar,
106                                                   const BVH_Vec4f& theReflection,
107                                                   const BVH_Vec4f& theRefraction)
108 : Ambient      (theAmbient),
109   Diffuse      (theDiffuse),
110   Specular     (theSpecular),
111   Emission     (theEmission),
112   Reflection   (theReflection),
113   Refraction   (theRefraction),
114   Transparency (theTranspar)
115 {
116   //
117 }
118
119 // =======================================================================
120 // function : OpenGl_LightSource
121 // purpose  : Creates new light source
122 // =======================================================================
123 OpenGl_RaytraceLight::OpenGl_RaytraceLight (const BVH_Vec4f& theDiffuse,
124                                             const BVH_Vec4f& thePosition)
125 : Diffuse (theDiffuse),
126   Position (thePosition)
127 {
128   //
129 }
130
131 // =======================================================================
132 // function : Center
133 // purpose  : Returns centroid position along the given axis
134 // =======================================================================
135 Standard_ShortReal OpenGl_TriangleSet::Center (
136   const Standard_Integer theIndex, const Standard_Integer theAxis) const
137 {
138   // Note: Experiments show that the use of the box centroid (instead
139   // of the triangle centroid) increases render performance up to 12%
140
141   const BVH_Vec4i& aTriangle = Elements[theIndex];
142
143   const Standard_ShortReal aVertex0 =
144     BVH::VecComp<Standard_ShortReal, 3>::Get (Vertices[aTriangle.x()], theAxis);
145   const Standard_ShortReal aVertex1 =
146     BVH::VecComp<Standard_ShortReal, 3>::Get (Vertices[aTriangle.y()], theAxis);
147   const Standard_ShortReal aVertex2 =
148     BVH::VecComp<Standard_ShortReal, 3>::Get (Vertices[aTriangle.z()], theAxis);
149
150   return (Min (Min (aVertex0, aVertex1), aVertex2) +
151           Max (Max (aVertex0, aVertex1), aVertex2)) * 0.5f;
152 }
153
154 // =======================================================================
155 // function : Box
156 // purpose  : Returns AABB of primitive set
157 // =======================================================================
158 OpenGl_TriangleSet::BVH_BoxNt OpenGl_TriangleSet::Box() const
159 {
160   const BVH_Transform<Standard_ShortReal, 4>* aTransform =
161     dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (Properties().operator->());
162
163   BVH_BoxNt aBox = BVH_PrimitiveSet<Standard_ShortReal, 3>::Box();
164
165   if (aTransform != NULL)
166   {
167     BVH_BoxNt aTransformedBox;
168
169     for (Standard_Integer aX = 0; aX <= 1; ++aX)
170     {
171       for (Standard_Integer aY = 0; aY <= 1; ++aY)
172       {
173         for (Standard_Integer aZ = 0; aZ <= 1; ++aZ)
174         {
175           BVH_Vec4f aCorner = aTransform->Transform() * BVH_Vec4f (
176             aX == 0 ? aBox.CornerMin().x() : aBox.CornerMax().x(),
177             aY == 0 ? aBox.CornerMin().y() : aBox.CornerMax().y(),
178             aZ == 0 ? aBox.CornerMin().z() : aBox.CornerMax().z(),
179             1.f);
180
181           aTransformedBox.Add (reinterpret_cast<BVH_Vec3f&> (aCorner));
182         }
183       }
184     }
185
186     return aTransformedBox;
187   }
188
189   return aBox;
190 }
191
192 // =======================================================================
193 // function : Clear
194 // purpose  : Clears ray-tracing geometry
195 // =======================================================================
196 void OpenGl_RaytraceGeometry::Clear()
197 {
198   BVH_Geometry<Standard_ShortReal, 3>::BVH_Geometry::Clear();
199
200   std::vector<OpenGl_RaytraceLight,
201     NCollection_StdAllocator<OpenGl_RaytraceLight> > anEmptySources;
202
203   Sources.swap (anEmptySources);
204
205   std::vector<OpenGl_RaytraceMaterial,
206     NCollection_StdAllocator<OpenGl_RaytraceMaterial> > anEmptyMaterials;
207
208   Materials.swap (anEmptyMaterials);
209 }
210
211 #ifdef HAVE_TBB
212
213 struct OpenGL_BVHParallelBuilder
214 {
215   BVH_ObjectSet<Standard_ShortReal, 3>* Set;
216
217   OpenGL_BVHParallelBuilder (BVH_ObjectSet<Standard_ShortReal, 3>* theSet)
218     : Set (theSet)
219   {
220     //
221   }
222
223   void operator() (const tbb::blocked_range<size_t>& theRange) const
224   {
225     for (size_t anObjectIdx = theRange.begin(); anObjectIdx != theRange.end(); ++anObjectIdx)
226     {
227       OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
228         Set->Objects().ChangeValue (static_cast<Standard_Integer> (anObjectIdx)).operator->());
229
230       if (aTriangleSet != NULL)
231       {
232         aTriangleSet->BVH();
233       }
234     }
235   }
236 };
237
238 #endif
239
240 // =======================================================================
241 // function : ProcessAcceleration
242 // purpose  : Performs post-processing of high-level BVH
243 // =======================================================================
244 Standard_Boolean OpenGl_RaytraceGeometry::ProcessAcceleration()
245 {
246 #ifdef RAY_TRACE_PRINT_INFO
247     OSD_Timer aTimer;
248 #endif
249
250   MarkDirty(); // force BVH rebuilding
251
252 #ifdef RAY_TRACE_PRINT_INFO
253   aTimer.Reset();
254   aTimer.Start();
255 #endif
256
257 #ifdef HAVE_TBB
258   // If Intel TBB is available, perform the preliminary
259   // construction of bottom-level scene BVHs
260   tbb::parallel_for (tbb::blocked_range<size_t> (0, Size()),
261     OpenGL_BVHParallelBuilder (this));
262 #endif
263
264   myBottomLevelTreeDepth = 0;
265
266   for (Standard_Integer anObjectIdx = 0; anObjectIdx < Size(); ++anObjectIdx)
267   {
268     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
269       myObjects.ChangeValue (anObjectIdx).operator->());
270
271     Standard_ASSERT_RETURN (aTriangleSet != NULL,
272       "Error! Failed to get triangulation of OpenGL element", Standard_False);
273
274     Standard_ASSERT_RETURN (!aTriangleSet->BVH().IsNull(),
275       "Error! Failed to update bottom-level BVH of OpenGL element", Standard_False);
276
277     myBottomLevelTreeDepth = Max (myBottomLevelTreeDepth, aTriangleSet->BVH()->Depth());
278   }
279
280 #ifdef RAY_TRACE_PRINT_INFO
281   aTimer.Stop();
282
283   std::cout << "Updating bottom-level BVHs (sec): " <<
284     aTimer.ElapsedTime() << std::endl;
285 #endif
286
287 #ifdef RAY_TRACE_PRINT_INFO
288   aTimer.Reset();
289   aTimer.Start();
290 #endif
291
292   NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> > aBVH = BVH();
293
294 #ifdef RAY_TRACE_PRINT_INFO
295   aTimer.Stop();
296
297   std::cout << "Updating high-level BVH (sec): " <<
298     aTimer.ElapsedTime() << std::endl;
299 #endif
300
301   Standard_ASSERT_RETURN (!aBVH.IsNull(),
302     "Error! Failed to update high-level BVH of ray-tracing scene", Standard_False);
303
304   myHighLevelTreeDepth = aBVH->Depth();
305
306   Standard_Integer aVerticesOffset = 0;
307   Standard_Integer aElementsOffset = 0;
308   Standard_Integer aBVHNodesOffset = BVH()->Length();
309
310   for (Standard_Integer aNodeIdx = 0; aNodeIdx < aBVH->Length(); ++aNodeIdx)
311   {
312     if (!aBVH->IsOuter (aNodeIdx))
313       continue;
314
315     Standard_ASSERT_RETURN (aBVH->BegPrimitive (aNodeIdx) == aBVH->EndPrimitive (aNodeIdx),
316       "Error! Invalid leaf node in high-level BVH (contains several objects)", Standard_False);
317
318     Standard_Integer anObjectIdx = aBVH->BegPrimitive (aNodeIdx);
319
320     Standard_ASSERT_RETURN (anObjectIdx < myObjects.Size(),
321       "Error! Invalid leaf node in high-level BVH (contains out-of-range object)", Standard_False);
322
323     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
324       myObjects.ChangeValue (anObjectIdx).operator->());
325
326     // Note: We overwrite node info record to store parameters
327     // of bottom-level BVH and triangulation of OpenGL element
328
329     aBVH->NodeInfoBuffer().at (aNodeIdx) = BVH_Vec4i (
330       anObjectIdx + 1 /* to keep leaf flag */, aBVHNodesOffset, aVerticesOffset, aElementsOffset);
331
332     aVerticesOffset += (int)aTriangleSet->Vertices.size();
333     aElementsOffset += (int)aTriangleSet->Elements.size();
334     aBVHNodesOffset += aTriangleSet->BVH()->Length();
335   }
336
337   return Standard_True;
338 }
339
340 // =======================================================================
341 // function : AccelerationOffset
342 // purpose  : Returns offset of bottom-level BVH for given leaf node
343 // =======================================================================
344 Standard_Integer OpenGl_RaytraceGeometry::AccelerationOffset (Standard_Integer theNodeIdx)
345 {
346   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> >& aBVH = BVH();
347
348   if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
349     return INVALID_OFFSET;
350
351   return aBVH->NodeInfoBuffer().at (theNodeIdx).y();
352 }
353
354 // =======================================================================
355 // function : VerticesOffset
356 // purpose  : Returns offset of triangulation vertices for given leaf node
357 // =======================================================================
358 Standard_Integer OpenGl_RaytraceGeometry::VerticesOffset (Standard_Integer theNodeIdx)
359 {
360   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> >& aBVH = BVH();
361
362   if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
363     return INVALID_OFFSET;
364
365   return aBVH->NodeInfoBuffer().at (theNodeIdx).z();
366 }
367
368 // =======================================================================
369 // function : ElementsOffset
370 // purpose  : Returns offset of triangulation elements for given leaf node
371 // =======================================================================
372 Standard_Integer OpenGl_RaytraceGeometry::ElementsOffset (Standard_Integer theNodeIdx)
373 {
374   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> >& aBVH = BVH();
375
376   if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
377     return INVALID_OFFSET;
378
379   return aBVH->NodeInfoBuffer().at (theNodeIdx).w();
380 }
381
382 // =======================================================================
383 // function : TriangleSet
384 // purpose  : Returns triangulation data for given leaf node
385 // =======================================================================
386 OpenGl_TriangleSet* OpenGl_RaytraceGeometry::TriangleSet (Standard_Integer theNodeIdx)
387 {
388   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> >& aBVH = BVH();
389
390   if (theNodeIdx >= aBVH->Length() || !aBVH->IsOuter (theNodeIdx))
391     return NULL;
392
393   if (aBVH->NodeInfoBuffer().at (theNodeIdx).x() > myObjects.Size())
394     return NULL;
395
396   return dynamic_cast<OpenGl_TriangleSet*> (myObjects.ChangeValue (
397     aBVH->NodeInfoBuffer().at (theNodeIdx).x() - 1).operator->());
398 }
399
400 // =======================================================================
401 // function : AcquireTextures
402 // purpose  : Makes the OpenGL texture handles resident
403 // =======================================================================
404 Standard_Boolean OpenGl_RaytraceGeometry::AcquireTextures (const Handle(OpenGl_Context)& theContext) const
405 {
406   if (theContext->arbTexBindless == NULL)
407   {
408     return Standard_True;
409   }
410
411 #if !defined(GL_ES_VERSION_2_0)
412   for (Standard_Integer anIdx = 0; anIdx < myTextures.Size(); ++anIdx)
413   {
414     theContext->arbTexBindless->glMakeTextureHandleResidentARB (myTextureHandles[anIdx]);
415
416     if (glGetError() != GL_NO_ERROR)
417     {
418 #ifdef RAY_TRACE_PRINT_INFO
419       std::cout << "Error: Failed to make OpenGL texture resident" << std::endl;
420 #endif
421       return Standard_False;
422     }
423   }
424 #endif
425
426   return Standard_True;
427 }
428
429 // =======================================================================
430 // function : ReleaseTextures
431 // purpose  : Makes the OpenGL texture handles non-resident
432 // =======================================================================
433 Standard_Boolean OpenGl_RaytraceGeometry::ReleaseTextures (const Handle(OpenGl_Context)& theContext) const
434 {
435   if (theContext->arbTexBindless == NULL)
436   {
437     return Standard_True;
438   }
439
440 #if !defined(GL_ES_VERSION_2_0)
441   for (Standard_Integer anIdx = 0; anIdx < myTextures.Size(); ++anIdx)
442   {
443     theContext->arbTexBindless->glMakeTextureHandleNonResidentARB (myTextureHandles[anIdx]);
444
445     if (glGetError() != GL_NO_ERROR)
446     {
447 #ifdef RAY_TRACE_PRINT_INFO
448       std::cout << "Error: Failed to make OpenGL texture non-resident" << std::endl;
449 #endif
450       return Standard_False;
451     }
452   }
453 #endif
454
455   return Standard_True;
456 }
457
458 // =======================================================================
459 // function : AddTexture
460 // purpose  : Adds new OpenGL texture to the scene and returns its index
461 // =======================================================================
462 Standard_Integer OpenGl_RaytraceGeometry::AddTexture (const Handle(OpenGl_Texture)& theTexture)
463 {
464   NCollection_Vector<Handle (OpenGl_Texture)>::iterator anIter =
465     std::find (myTextures.begin(), myTextures.end(), theTexture);
466
467   if (anIter == myTextures.end())
468   {
469     if (myTextures.Size() >= MAX_TEX_NUMBER)
470     {
471       return -1;
472     }
473
474     myTextures.Append (theTexture);
475   }
476
477   return static_cast<Standard_Integer> (anIter - myTextures.begin());
478 }
479
480 // =======================================================================
481 // function : UpdateTextureHandles
482 // purpose  : Updates unique 64-bit texture handles to use in shaders
483 // =======================================================================
484 Standard_Boolean OpenGl_RaytraceGeometry::UpdateTextureHandles (const Handle(OpenGl_Context)& theContext)
485 {
486   if (theContext->arbTexBindless == NULL)
487   {
488     return Standard_False;
489   }
490
491   myTextureHandles.clear();
492
493 #if !defined(GL_ES_VERSION_2_0)
494   for (Standard_Integer anIdx = 0; anIdx < myTextures.Size(); ++anIdx)
495   {
496     const GLuint64 aHandle = theContext->arbTexBindless->glGetTextureHandleARB (
497       myTextures.Value (anIdx)->TextureId());
498
499     if (glGetError() != GL_NO_ERROR)
500     {
501 #ifdef RAY_TRACE_PRINT_INFO
502       std::cout << "Error: Failed to get 64-bit handle of OpenGL texture" << std::endl;
503 #endif
504       return Standard_False;
505     }
506
507     myTextureHandles.push_back (aHandle);
508   }
509 #endif
510
511   return Standard_True;
512 }
513
514 namespace OpenGl_Raytrace
515 {
516   // =======================================================================
517   // function : IsRaytracedElement
518   // purpose  : Checks to see if the element contains ray-trace geometry
519   // =======================================================================
520   Standard_Boolean IsRaytracedElement (const OpenGl_ElementNode* theNode)
521   {
522     OpenGl_PrimitiveArray* anArray = dynamic_cast<OpenGl_PrimitiveArray*> (theNode->elem);
523     return anArray != NULL
524         && anArray->DrawMode() >= GL_TRIANGLES;
525   }
526
527   // =======================================================================
528   // function : IsRaytracedElement
529   // purpose  : Checks to see if the element contains ray-trace geometry
530   // =======================================================================
531   Standard_Boolean IsRaytracedElement (const OpenGl_Element* theElement)
532   {
533     const OpenGl_PrimitiveArray* anArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theElement);
534     return anArray != NULL
535         && anArray->DrawMode() >= GL_TRIANGLES;
536   }
537
538   // =======================================================================
539   // function : IsRaytracedGroup
540   // purpose  : Checks to see if the group contains ray-trace geometry
541   // =======================================================================
542   Standard_Boolean IsRaytracedGroup (const OpenGl_Group *theGroup)
543   {
544     const OpenGl_ElementNode* aNode;
545     for (aNode = theGroup->FirstNode(); aNode != NULL; aNode = aNode->next)
546     {
547       if (IsRaytracedElement (aNode))
548       {
549         return Standard_True;
550       }
551     }
552     return Standard_False;
553   }
554
555   // =======================================================================
556   // function : IsRaytracedStructure
557   // purpose  : Checks to see if the structure contains ray-trace geometry
558   // =======================================================================
559   Standard_Boolean IsRaytracedStructure (const OpenGl_Structure* theStructure)
560   {
561     for (OpenGl_Structure::GroupIterator aGroupIter (theStructure->DrawGroups());
562          aGroupIter.More(); aGroupIter.Next())
563     {
564       if (aGroupIter.Value()->IsRaytracable())
565         return Standard_True;
566     }
567     for (OpenGl_ListOfStructure::Iterator anIts (theStructure->ConnectedStructures());
568          anIts.More(); anIts.Next())
569     {
570       if (IsRaytracedStructure (anIts.Value()))
571         return Standard_True;
572     }
573     return Standard_False;
574   }
575 }