0025992: Method Geom2dAPI_InterCurveCurve::Segment(...) requires detail revision
[occt.git] / src / OpenGl / OpenGl_View_Raytrace.cxx
1 // Created on: 2015-02-20
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2015 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 <Graphic3d_TextureParams.hxx>
17
18 #include <OpenGl_FrameBuffer.hxx>
19 #include <OpenGl_PrimitiveArray.hxx>
20 #include <OpenGl_VertexBuffer.hxx>
21 #include <OpenGl_View.hxx>
22
23 #include <OSD_Protection.hxx>
24 #include <OSD_File.hxx>
25
26 using namespace OpenGl_Raytrace;
27
28 //! Use this macro to output ray-tracing debug info
29 // #define RAY_TRACE_PRINT_INFO
30
31 #ifdef RAY_TRACE_PRINT_INFO
32   #include <OSD_Timer.hxx>
33 #endif
34
35 // =======================================================================
36 // function : UpdateRaytraceGeometry
37 // purpose  : Updates 3D scene geometry for ray-tracing
38 // =======================================================================
39 Standard_Boolean OpenGl_View::updateRaytraceGeometry (const RaytraceUpdateMode      theMode,
40                                                       const Standard_Integer        theViewId,
41                                                       const Handle(OpenGl_Context)& theGlContext)
42 {
43   // In 'check' mode (OpenGl_GUM_CHECK) the scene geometry is analyzed for
44   // modifications. This is light-weight procedure performed on each frame
45   if (theMode == OpenGl_GUM_CHECK)
46   {
47     if (myLayersModificationStatus != myZLayers.ModificationState())
48     {
49       return updateRaytraceGeometry (OpenGl_GUM_PREPARE, theViewId, theGlContext);
50     }
51   }
52   else if (theMode == OpenGl_GUM_PREPARE)
53   {
54     myRaytraceGeometry.ClearMaterials();
55
56     myArrayToTrianglesMap.clear();
57
58     myIsRaytraceDataValid = Standard_False;
59   }
60
61   // The set of processed structures (reflected to ray-tracing)
62   // This set is used to remove out-of-date records from the
63   // hash map of structures
64   std::set<const OpenGl_Structure*> anElements;
65
66   // Set to store all currently visible OpenGL primitive arrays
67   // applicable for ray-tracing
68   std::set<Standard_Size> anArrayIDs;
69
70   const OpenGl_Layer& aLayer = myZLayers.Layer (Graphic3d_ZLayerId_Default);
71
72   if (aLayer.NbStructures() != 0)
73   {
74     const OpenGl_ArrayOfStructure& aStructArray = aLayer.ArrayOfStructures();
75
76     for (Standard_Integer anIndex = 0; anIndex < aStructArray.Length(); ++anIndex)
77     {
78       for (OpenGl_SequenceOfStructure::Iterator aStructIt (aStructArray (anIndex)); aStructIt.More(); aStructIt.Next())
79       {
80         const OpenGl_Structure* aStructure = aStructIt.Value();
81
82         if (theMode == OpenGl_GUM_CHECK)
83         {
84           if (toUpdateStructure (aStructure))
85           {
86             return updateRaytraceGeometry (OpenGl_GUM_PREPARE, theViewId, theGlContext);
87           }
88         }
89         else if (theMode == OpenGl_GUM_PREPARE)
90         {
91           if (!aStructure->IsRaytracable() || !aStructure->IsVisible())
92           {
93             continue;
94           }
95           else if (!aStructure->ViewAffinity.IsNull() && !aStructure->ViewAffinity->IsVisible (theViewId))
96           {
97             continue;
98           }
99
100           for (OpenGl_Structure::GroupIterator aGroupIter (aStructure->DrawGroups()); aGroupIter.More(); aGroupIter.Next())
101           {
102             // Extract OpenGL elements from the group (primitives arrays)
103             for (const OpenGl_ElementNode* aNode = aGroupIter.Value()->FirstNode(); aNode != NULL; aNode = aNode->next)
104             {
105               OpenGl_PrimitiveArray* aPrimArray = dynamic_cast<OpenGl_PrimitiveArray*> (aNode->elem);
106
107               if (aPrimArray != NULL)
108               {
109                 anArrayIDs.insert (aPrimArray->GetUID());
110               }
111             }
112           }
113         }
114         else if (theMode == OpenGl_GUM_REBUILD)
115         {
116           if (!aStructure->IsRaytracable())
117           {
118             continue;
119           }
120           else if (addRaytraceStructure (aStructure, theGlContext))
121           {
122             anElements.insert (aStructure); // structure was processed
123           }
124         }
125       }
126     }
127   }
128
129   if (theMode == OpenGl_GUM_PREPARE)
130   {
131     BVH_ObjectSet<Standard_ShortReal, 3>::BVH_ObjectList anUnchangedObjects;
132
133     // Filter out unchanged objects so only their transformations and materials
134     // will be updated (and newly added objects will be processed from scratch)
135     for (Standard_Integer anObjIdx = 0; anObjIdx < myRaytraceGeometry.Size(); ++anObjIdx)
136     {
137       OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
138         myRaytraceGeometry.Objects().ChangeValue (anObjIdx).operator->());
139
140       if (aTriangleSet == NULL)
141       {
142         continue;
143       }
144
145       if (anArrayIDs.find (aTriangleSet->AssociatedPArrayID()) != anArrayIDs.end())
146       {
147         anUnchangedObjects.Append (myRaytraceGeometry.Objects().Value (anObjIdx));
148
149         myArrayToTrianglesMap[aTriangleSet->AssociatedPArrayID()] = aTriangleSet;
150       }
151     }
152
153     myRaytraceGeometry.Objects() = anUnchangedObjects;
154
155     return updateRaytraceGeometry (OpenGl_GUM_REBUILD, theViewId, theGlContext);
156   }
157   else if (theMode == OpenGl_GUM_REBUILD)
158   {
159     // Actualize the hash map of structures - remove out-of-date records
160     std::map<const OpenGl_Structure*, Standard_Size>::iterator anIter = myStructureStates.begin();
161
162     while (anIter != myStructureStates.end())
163     {
164       if (anElements.find (anIter->first) == anElements.end())
165       {
166         myStructureStates.erase (anIter++);
167       }
168       else
169       {
170         ++anIter;
171       }
172     }
173
174     // Actualize OpenGL layer list state
175     myLayersModificationStatus = myZLayers.ModificationState();
176
177     // Rebuild two-level acceleration structure
178     myRaytraceGeometry.ProcessAcceleration();
179
180     myRaytraceSceneRadius = 2.f /* scale factor */ * std::max (
181       myRaytraceGeometry.Box().CornerMin().cwiseAbs().maxComp(),
182       myRaytraceGeometry.Box().CornerMax().cwiseAbs().maxComp());
183
184     const BVH_Vec3f aSize = myRaytraceGeometry.Box().Size();
185
186     myRaytraceSceneEpsilon = Max (1.0e-6f, 1.0e-4f * aSize.Modulus());
187
188     return uploadRaytraceData (theGlContext);
189   }
190
191   return Standard_True;
192 }
193
194 // =======================================================================
195 // function : ToUpdateStructure
196 // purpose  : Checks to see if the structure is modified
197 // =======================================================================
198 Standard_Boolean OpenGl_View::toUpdateStructure (const OpenGl_Structure* theStructure)
199 {
200   if (!theStructure->IsRaytracable())
201   {
202     if (theStructure->ModificationState() > 0)
203     {
204       theStructure->ResetModificationState();
205
206       return Standard_True; // ray-trace element was removed - need to rebuild
207     }
208
209     return Standard_False; // did not contain ray-trace elements
210   }
211
212   std::map<const OpenGl_Structure*, Standard_Size>::iterator aStructState = myStructureStates.find (theStructure);
213
214   if (aStructState != myStructureStates.end())
215   {
216     return aStructState->second != theStructure->ModificationState();
217   }
218
219   return Standard_True;
220 }
221
222 // =======================================================================
223 // function : BuildTextureTransform
224 // purpose  : Constructs texture transformation matrix
225 // =======================================================================
226 void BuildTextureTransform (const Handle(Graphic3d_TextureParams)& theParams, BVH_Mat4f& theMatrix)
227 {
228   theMatrix.InitIdentity();
229
230   // Apply scaling
231   const Graphic3d_Vec2& aScale = theParams->Scale();
232
233   theMatrix.ChangeValue (0, 0) *= aScale.x();
234   theMatrix.ChangeValue (1, 0) *= aScale.x();
235   theMatrix.ChangeValue (2, 0) *= aScale.x();
236   theMatrix.ChangeValue (3, 0) *= aScale.x();
237
238   theMatrix.ChangeValue (0, 1) *= aScale.y();
239   theMatrix.ChangeValue (1, 1) *= aScale.y();
240   theMatrix.ChangeValue (2, 1) *= aScale.y();
241   theMatrix.ChangeValue (3, 1) *= aScale.y();
242
243   // Apply translation
244   const Graphic3d_Vec2 aTrans = -theParams->Translation();
245
246   theMatrix.ChangeValue (0, 3) = theMatrix.GetValue (0, 0) * aTrans.x() +
247                                  theMatrix.GetValue (0, 1) * aTrans.y();
248
249   theMatrix.ChangeValue (1, 3) = theMatrix.GetValue (1, 0) * aTrans.x() +
250                                  theMatrix.GetValue (1, 1) * aTrans.y();
251
252   theMatrix.ChangeValue (2, 3) = theMatrix.GetValue (2, 0) * aTrans.x() +
253                                  theMatrix.GetValue (2, 1) * aTrans.y();
254
255   // Apply rotation
256   const Standard_ShortReal aSin = std::sin (
257     -theParams->Rotation() * static_cast<Standard_ShortReal> (M_PI / 180.0));
258   const Standard_ShortReal aCos = std::cos (
259     -theParams->Rotation() * static_cast<Standard_ShortReal> (M_PI / 180.0));
260
261   BVH_Mat4f aRotationMat;
262   aRotationMat.SetValue (0, 0,  aCos);
263   aRotationMat.SetValue (1, 1,  aCos);
264   aRotationMat.SetValue (0, 1, -aSin);
265   aRotationMat.SetValue (1, 0,  aSin);
266
267   theMatrix = theMatrix * aRotationMat;
268 }
269
270 // =======================================================================
271 // function : ConvertMaterial
272 // purpose  : Creates ray-tracing material properties
273 // =======================================================================
274 OpenGl_RaytraceMaterial OpenGl_View::convertMaterial (const OpenGl_AspectFace*      theAspect,
275                                                       const Handle(OpenGl_Context)& theGlContext)
276 {
277   OpenGl_RaytraceMaterial theMaterial;
278
279   const OPENGL_SURF_PROP& aProperties = theAspect->IntFront();
280
281   theMaterial.Ambient = BVH_Vec4f (
282     (aProperties.isphysic ? aProperties.ambcol.rgb[0] : aProperties.matcol.rgb[0]) * aProperties.amb,
283     (aProperties.isphysic ? aProperties.ambcol.rgb[1] : aProperties.matcol.rgb[1]) * aProperties.amb,
284     (aProperties.isphysic ? aProperties.ambcol.rgb[2] : aProperties.matcol.rgb[2]) * aProperties.amb,
285     1.f);
286
287   theMaterial.Diffuse = BVH_Vec4f (
288     (aProperties.isphysic ? aProperties.difcol.rgb[0] : aProperties.matcol.rgb[0]) * aProperties.diff,
289     (aProperties.isphysic ? aProperties.difcol.rgb[1] : aProperties.matcol.rgb[1]) * aProperties.diff,
290     (aProperties.isphysic ? aProperties.difcol.rgb[2] : aProperties.matcol.rgb[2]) * aProperties.diff,
291     -1.f /* no texture */);
292
293   theMaterial.Specular = BVH_Vec4f (
294     (aProperties.isphysic ? aProperties.speccol.rgb[0] : 1.f) * aProperties.spec,
295     (aProperties.isphysic ? aProperties.speccol.rgb[1] : 1.f) * aProperties.spec,
296     (aProperties.isphysic ? aProperties.speccol.rgb[2] : 1.f) * aProperties.spec,
297     aProperties.shine);
298
299   theMaterial.Emission = BVH_Vec4f (
300     (aProperties.isphysic ? aProperties.emscol.rgb[0] : aProperties.matcol.rgb[0]) * aProperties.emsv,
301     (aProperties.isphysic ? aProperties.emscol.rgb[1] : aProperties.matcol.rgb[1]) * aProperties.emsv,
302     (aProperties.isphysic ? aProperties.emscol.rgb[2] : aProperties.matcol.rgb[2]) * aProperties.emsv,
303     1.f);
304
305   theMaterial.Transparency = BVH_Vec4f (aProperties.trans,
306                                         1.f - aProperties.trans,
307                                         aProperties.index == 0 ? 1.f : aProperties.index,
308                                         aProperties.index == 0 ? 1.f : 1.f / aProperties.index);
309
310   const Standard_ShortReal aMaxRefl = Max (theMaterial.Diffuse.x() + theMaterial.Specular.x(),
311                                       Max (theMaterial.Diffuse.y() + theMaterial.Specular.y(),
312                                            theMaterial.Diffuse.z() + theMaterial.Specular.z()));
313
314   const Standard_ShortReal aReflectionScale = 0.75f / aMaxRefl;
315
316   theMaterial.Reflection = BVH_Vec4f (
317     aProperties.speccol.rgb[0] * aProperties.spec * aReflectionScale,
318     aProperties.speccol.rgb[1] * aProperties.spec * aReflectionScale,
319     aProperties.speccol.rgb[2] * aProperties.spec * aReflectionScale,
320     0.f);
321
322   if (theAspect->DoTextureMap())
323   {
324     if (theGlContext->arbTexBindless != NULL)
325     {
326       BuildTextureTransform (theAspect->TextureParams(), theMaterial.TextureTransform);
327
328       // write texture ID in the w-component
329       theMaterial.Diffuse.w() = static_cast<Standard_ShortReal> (
330         myRaytraceGeometry.AddTexture (theAspect->TextureRes (theGlContext)));
331     }
332     else if (!myIsRaytraceWarnTextures)
333     {
334       const TCollection_ExtendedString aWarnMessage =
335         "Warning: texturing in Ray-Trace requires GL_ARB_bindless_texture extension which is missing. "
336         "Please try to update graphics card driver. At the moment textures will be ignored.";
337
338       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
339         GL_DEBUG_TYPE_PORTABILITY_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aWarnMessage);
340
341       myIsRaytraceWarnTextures = Standard_True;
342     }
343   }
344
345   return theMaterial;
346 }
347
348 // =======================================================================
349 // function : AddRaytraceStructure
350 // purpose  : Adds OpenGL structure to ray-traced scene geometry
351 // =======================================================================
352 Standard_Boolean OpenGl_View::addRaytraceStructure (const OpenGl_Structure*       theStructure,
353                                                     const Handle(OpenGl_Context)& theGlContext)
354 {
355   if (!theStructure->IsVisible())
356   {
357     myStructureStates[theStructure] = theStructure->ModificationState();
358
359     return Standard_True;
360   }
361
362   // Get structure material
363   Standard_Integer aStructMatID = -1;
364
365   if (theStructure->AspectFace() != NULL)
366   {
367     aStructMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
368
369     OpenGl_RaytraceMaterial aStructMaterial = convertMaterial (theStructure->AspectFace(), theGlContext);
370
371     myRaytraceGeometry.Materials.push_back (aStructMaterial);
372   }
373
374   Standard_ShortReal aStructTransform[16];
375
376   if (theStructure->Transformation()->mat != NULL)
377   {
378     for (Standard_Integer i = 0; i < 4; ++i)
379     {
380       for (Standard_Integer j = 0; j < 4; ++j)
381       {
382         aStructTransform[j * 4 + i] = theStructure->Transformation()->mat[i][j];
383       }
384     }
385   }
386
387   Standard_Boolean aResult = addRaytraceGroups (theStructure, aStructMatID,
388     theStructure->Transformation()->mat ? aStructTransform : NULL, theGlContext);
389
390   // Process all connected OpenGL structures
391   for (OpenGl_ListOfStructure::Iterator anIts (theStructure->ConnectedStructures()); anIts.More(); anIts.Next())
392   {
393     if (anIts.Value()->IsRaytracable())
394     {
395       aResult &= addRaytraceGroups (anIts.Value(), aStructMatID,
396         theStructure->Transformation()->mat ? aStructTransform : NULL, theGlContext);
397     }
398   }
399
400   myStructureStates[theStructure] = theStructure->ModificationState();
401
402   return aResult;
403 }
404
405 // =======================================================================
406 // function : AddRaytraceGroups
407 // purpose  : Adds OpenGL groups to ray-traced scene geometry
408 // =======================================================================
409 Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*       theStructure,
410                                                  const Standard_Integer        theStructMat,
411                                                  const Standard_ShortReal*     theTransform,
412                                                  const Handle(OpenGl_Context)& theGlContext)
413 {
414   for (OpenGl_Structure::GroupIterator aGroupIter (theStructure->DrawGroups()); aGroupIter.More(); aGroupIter.Next())
415   {
416     // Get group material
417     Standard_Integer aGroupMatID = -1;
418     if (aGroupIter.Value()->AspectFace() != NULL)
419     {
420       aGroupMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
421
422       OpenGl_RaytraceMaterial aGroupMaterial = convertMaterial (
423         aGroupIter.Value()->AspectFace(), theGlContext);
424
425       myRaytraceGeometry.Materials.push_back (aGroupMaterial);
426     }
427
428     Standard_Integer aMatID = aGroupMatID < 0 ? theStructMat : aGroupMatID;
429     if (aMatID < 0)
430     {
431       aMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
432
433       myRaytraceGeometry.Materials.push_back (OpenGl_RaytraceMaterial());
434     }
435
436     // Add OpenGL elements from group (extract primitives arrays and aspects)
437     for (const OpenGl_ElementNode* aNode = aGroupIter.Value()->FirstNode(); aNode != NULL; aNode = aNode->next)
438     {
439       OpenGl_AspectFace* anAspect = dynamic_cast<OpenGl_AspectFace*> (aNode->elem);
440
441       if (anAspect != NULL)
442       {
443         aMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
444
445         OpenGl_RaytraceMaterial aMaterial = convertMaterial (anAspect, theGlContext);
446
447         myRaytraceGeometry.Materials.push_back (aMaterial);
448       }
449       else
450       {
451         OpenGl_PrimitiveArray* aPrimArray = dynamic_cast<OpenGl_PrimitiveArray*> (aNode->elem);
452
453         if (aPrimArray != NULL)
454         {
455           std::map<Standard_Size, OpenGl_TriangleSet*>::iterator aSetIter = myArrayToTrianglesMap.find (aPrimArray->GetUID());
456
457           if (aSetIter != myArrayToTrianglesMap.end())
458           {
459             OpenGl_TriangleSet* aSet = aSetIter->second;
460
461             BVH_Transform<Standard_ShortReal, 4>* aTransform = new BVH_Transform<Standard_ShortReal, 4>();
462
463             if (theTransform != NULL)
464             {
465               aTransform->SetTransform (*(reinterpret_cast<const BVH_Mat4f*> (theTransform)));
466             }
467
468             aSet->SetProperties (aTransform);
469
470             if (aSet->MaterialIndex() != OpenGl_TriangleSet::INVALID_MATERIAL && aSet->MaterialIndex() != aMatID)
471             {
472               aSet->SetMaterialIndex (aMatID);
473             }
474           }
475           else
476           {
477             NCollection_Handle<BVH_Object<Standard_ShortReal, 3> > aSet =
478               addRaytracePrimitiveArray (aPrimArray, aMatID, 0);
479
480             if (!aSet.IsNull())
481             {
482               BVH_Transform<Standard_ShortReal, 4>* aTransform = new BVH_Transform<Standard_ShortReal, 4>;
483
484               if (theTransform != NULL)
485               {
486                 aTransform->SetTransform (*(reinterpret_cast<const BVH_Mat4f*> (theTransform)));
487               }
488
489               aSet->SetProperties (aTransform);
490
491               myRaytraceGeometry.Objects().Append (aSet);
492             }
493           }
494         }
495       }
496     }
497   }
498
499   return Standard_True;
500 }
501
502 // =======================================================================
503 // function : AddRaytracePrimitiveArray
504 // purpose  : Adds OpenGL primitive array to ray-traced scene geometry
505 // =======================================================================
506 OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
507                                                             const Standard_Integer       theMaterial,
508                                                             const OpenGl_Mat4*           theTransform)
509 {
510   const Handle(Graphic3d_BoundBuffer)& aBounds   = theArray->Bounds();
511   const Handle(Graphic3d_IndexBuffer)& anIndices = theArray->Indices();
512   const Handle(Graphic3d_Buffer)&      anAttribs = theArray->Attributes();
513
514   if (theArray->DrawMode() < GL_TRIANGLES
515   #ifndef GL_ES_VERSION_2_0
516    || theArray->DrawMode() > GL_POLYGON
517   #else
518    || theArray->DrawMode() > GL_TRIANGLE_FAN
519   #endif
520    || anAttribs.IsNull())
521   {
522     return NULL;
523   }
524
525   OpenGl_Mat4 aNormalMatrix;
526
527   if (theTransform != NULL)
528   {
529     Standard_ASSERT_RETURN (theTransform->Inverted (aNormalMatrix),
530       "Error: Failed to compute normal transformation matrix", NULL);
531
532     aNormalMatrix.Transpose();
533   }
534
535   OpenGl_TriangleSet* aSet = new OpenGl_TriangleSet (theArray->GetUID());
536   {
537     aSet->Vertices.reserve (anAttribs->NbElements);
538     aSet->Normals.reserve  (anAttribs->NbElements);
539     aSet->TexCrds.reserve  (anAttribs->NbElements);
540
541     const size_t aVertFrom = aSet->Vertices.size();
542
543     for (Standard_Integer anAttribIter = 0; anAttribIter < anAttribs->NbAttributes; ++anAttribIter)
544     {
545       const Graphic3d_Attribute& anAttrib = anAttribs->Attribute       (anAttribIter);
546       const size_t               anOffset = anAttribs->AttributeOffset (anAttribIter);
547       if (anAttrib.Id == Graphic3d_TOA_POS)
548       {
549         if (anAttrib.DataType == Graphic3d_TOD_VEC3
550          || anAttrib.DataType == Graphic3d_TOD_VEC4)
551         {
552           for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
553           {
554             aSet->Vertices.push_back (
555               *reinterpret_cast<const Graphic3d_Vec3*> (anAttribs->value (aVertIter) + anOffset));
556           }
557         }
558         else if (anAttrib.DataType == Graphic3d_TOD_VEC2)
559         {
560           for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
561           {
562             const Standard_ShortReal* aCoords =
563               reinterpret_cast<const Standard_ShortReal*> (anAttribs->value (aVertIter) + anOffset);
564
565             aSet->Vertices.push_back (BVH_Vec3f (aCoords[0], aCoords[1], 0.0f));
566           }
567         }
568       }
569       else if (anAttrib.Id == Graphic3d_TOA_NORM)
570       {
571         if (anAttrib.DataType == Graphic3d_TOD_VEC3
572          || anAttrib.DataType == Graphic3d_TOD_VEC4)
573         {
574           for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
575           {
576             aSet->Normals.push_back (
577               *reinterpret_cast<const Graphic3d_Vec3*> (anAttribs->value (aVertIter) + anOffset));
578           }
579         }
580       }
581       else if (anAttrib.Id == Graphic3d_TOA_UV)
582       {
583         if (anAttrib.DataType == Graphic3d_TOD_VEC2)
584         {
585           for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
586           {
587             aSet->TexCrds.push_back (
588               *reinterpret_cast<const Graphic3d_Vec2*> (anAttribs->value (aVertIter) + anOffset));
589           }
590         }
591       }
592     }
593
594     if (aSet->Normals.size() != aSet->Vertices.size())
595     {
596       for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
597       {
598         aSet->Normals.push_back (BVH_Vec3f());
599       }
600     }
601
602     if (aSet->TexCrds.size() != aSet->Vertices.size())
603     {
604       for (Standard_Integer aVertIter = 0; aVertIter < anAttribs->NbElements; ++aVertIter)
605       {
606         aSet->TexCrds.push_back (BVH_Vec2f());
607       }
608     }
609
610     if (theTransform != NULL)
611     {
612       for (size_t aVertIter = aVertFrom; aVertIter < aSet->Vertices.size(); ++aVertIter)
613       {
614         BVH_Vec3f& aVertex = aSet->Vertices[aVertIter];
615
616         BVH_Vec4f aTransVertex = *theTransform *
617           BVH_Vec4f (aVertex.x(), aVertex.y(), aVertex.z(), 1.f);
618
619         aVertex = BVH_Vec3f (aTransVertex.x(), aTransVertex.y(), aTransVertex.z());
620       }
621       for (size_t aVertIter = aVertFrom; aVertIter < aSet->Normals.size(); ++aVertIter)
622       {
623         BVH_Vec3f& aNormal = aSet->Normals[aVertIter];
624
625         BVH_Vec4f aTransNormal = aNormalMatrix *
626           BVH_Vec4f (aNormal.x(), aNormal.y(), aNormal.z(), 0.f);
627
628         aNormal = BVH_Vec3f (aTransNormal.x(), aTransNormal.y(), aTransNormal.z());
629       }
630     }
631
632     if (!aBounds.IsNull())
633     {
634       for (Standard_Integer aBound = 0, aBoundStart = 0; aBound < aBounds->NbBounds; ++aBound)
635       {
636         const Standard_Integer aVertNum = aBounds->Bounds[aBound];
637
638         if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, aBoundStart, *theArray))
639         {
640           delete aSet;
641           return NULL;
642         }
643
644         aBoundStart += aVertNum;
645       }
646     }
647     else
648     {
649       const Standard_Integer aVertNum = !anIndices.IsNull() ? anIndices->NbElements : anAttribs->NbElements;
650
651       if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, 0, *theArray))
652       {
653         delete aSet;
654         return NULL;
655       }
656     }
657   }
658
659   if (aSet->Size() != 0)
660   {
661     aSet->MarkDirty();
662   }
663
664   return aSet;
665 }
666
667 // =======================================================================
668 // function : AddRaytraceVertexIndices
669 // purpose  : Adds vertex indices to ray-traced scene geometry
670 // =======================================================================
671 Standard_Boolean OpenGl_View::addRaytraceVertexIndices (OpenGl_TriangleSet&                  theSet,
672                                                         const Standard_Integer               theMatID,
673                                                         const Standard_Integer               theCount,
674                                                         const Standard_Integer               theOffset,
675                                                         const OpenGl_PrimitiveArray&         theArray)
676 {
677   switch (theArray.DrawMode())
678   {
679     case GL_TRIANGLES:      return addRaytraceTriangleArray        (theSet, theMatID, theCount, theOffset, theArray.Indices());
680     case GL_TRIANGLE_FAN:   return addRaytraceTriangleFanArray     (theSet, theMatID, theCount, theOffset, theArray.Indices());
681     case GL_TRIANGLE_STRIP: return addRaytraceTriangleStripArray   (theSet, theMatID, theCount, theOffset, theArray.Indices());
682   #if !defined(GL_ES_VERSION_2_0)
683     case GL_QUAD_STRIP:     return addRaytraceQuadrangleStripArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
684     case GL_QUADS:          return addRaytraceQuadrangleArray      (theSet, theMatID, theCount, theOffset, theArray.Indices());
685     case GL_POLYGON:        return addRaytracePolygonArray         (theSet, theMatID, theCount, theOffset, theArray.Indices());
686   #endif
687   }
688
689   return Standard_False;
690 }
691
692 // =======================================================================
693 // function : AddRaytraceTriangleArray
694 // purpose  : Adds OpenGL triangle array to ray-traced scene geometry
695 // =======================================================================
696 Standard_Boolean OpenGl_View::addRaytraceTriangleArray (OpenGl_TriangleSet&                  theSet,
697                                                         const Standard_Integer               theMatID,
698                                                         const Standard_Integer               theCount,
699                                                         const Standard_Integer               theOffset,
700                                                         const Handle(Graphic3d_IndexBuffer)& theIndices)
701 {
702   if (theCount < 3)
703   {
704     return Standard_True;
705   }
706
707   theSet.Elements.reserve (theSet.Elements.size() + theCount / 3);
708
709   if (!theIndices.IsNull())
710   {
711     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; aVert += 3)
712     {
713       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + 0),
714                                             theIndices->Index (aVert + 1),
715                                             theIndices->Index (aVert + 2),
716                                             theMatID));
717     }
718   }
719   else
720   {
721     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; aVert += 3)
722     {
723       theSet.Elements.push_back (BVH_Vec4i (aVert + 0, aVert + 1, aVert + 2, theMatID));
724     }
725   }
726
727   return Standard_True;
728 }
729
730 // =======================================================================
731 // function : AddRaytraceTriangleFanArray
732 // purpose  : Adds OpenGL triangle fan array to ray-traced scene geometry
733 // =======================================================================
734 Standard_Boolean OpenGl_View::addRaytraceTriangleFanArray (OpenGl_TriangleSet&                  theSet,
735                                                            const Standard_Integer               theMatID,
736                                                            const Standard_Integer               theCount,
737                                                            const Standard_Integer               theOffset,
738                                                            const Handle(Graphic3d_IndexBuffer)& theIndices)
739 {
740   if (theCount < 3)
741   {
742     return Standard_True;
743   }
744
745   theSet.Elements.reserve (theSet.Elements.size() + theCount - 2);
746
747   if (!theIndices.IsNull())
748   {
749     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
750     {
751       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (theOffset),
752                                             theIndices->Index (aVert + 1),
753                                             theIndices->Index (aVert + 2),
754                                             theMatID));
755     }
756   }
757   else
758   {
759     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
760     {
761       theSet.Elements.push_back (BVH_Vec4i (theOffset,
762                                             aVert + 1,
763                                             aVert + 2,
764                                             theMatID));
765     }
766   }
767
768   return Standard_True;
769 }
770
771 // =======================================================================
772 // function : AddRaytraceTriangleStripArray
773 // purpose  : Adds OpenGL triangle strip array to ray-traced scene geometry
774 // =======================================================================
775 Standard_Boolean OpenGl_View::addRaytraceTriangleStripArray (OpenGl_TriangleSet&                  theSet,
776                                                              const Standard_Integer               theMatID,
777                                                              const Standard_Integer               theCount,
778                                                              const Standard_Integer               theOffset,
779                                                              const Handle(Graphic3d_IndexBuffer)& theIndices)
780 {
781   if (theCount < 3)
782   {
783     return Standard_True;
784   }
785
786   theSet.Elements.reserve (theSet.Elements.size() + theCount - 2);
787
788   if (!theIndices.IsNull())
789   {
790     for (Standard_Integer aVert = theOffset, aCW = 0; aVert < theOffset + theCount - 2; ++aVert, aCW = (aCW + 1) % 2)
791     {
792       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + aCW ? 1 : 0),
793                                             theIndices->Index (aVert + aCW ? 0 : 1),
794                                             theIndices->Index (aVert + 2),
795                                             theMatID));
796     }
797   }
798   else
799   {
800     for (Standard_Integer aVert = theOffset, aCW = 0; aVert < theOffset + theCount - 2; ++aVert, aCW = (aCW + 1) % 2)
801     {
802       theSet.Elements.push_back (BVH_Vec4i (aVert + aCW ? 1 : 0,
803                                             aVert + aCW ? 0 : 1,
804                                             aVert + 2,
805                                             theMatID));
806     }
807   }
808
809   return Standard_True;
810 }
811
812 // =======================================================================
813 // function : AddRaytraceQuadrangleArray
814 // purpose  : Adds OpenGL quad array to ray-traced scene geometry
815 // =======================================================================
816 Standard_Boolean OpenGl_View::addRaytraceQuadrangleArray (OpenGl_TriangleSet&                  theSet,
817                                                           const Standard_Integer               theMatID,
818                                                           const Standard_Integer               theCount,
819                                                           const Standard_Integer               theOffset,
820                                                           const Handle(Graphic3d_IndexBuffer)& theIndices)
821 {
822   if (theCount < 4)
823   {
824     return Standard_True;
825   }
826
827   theSet.Elements.reserve (theSet.Elements.size() + theCount / 2);
828
829   if (!theIndices.IsNull())
830   {
831     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 4)
832     {
833       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + 0),
834                                             theIndices->Index (aVert + 1),
835                                             theIndices->Index (aVert + 2),
836                                             theMatID));
837       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + 0),
838                                             theIndices->Index (aVert + 2),
839                                             theIndices->Index (aVert + 3),
840                                             theMatID));
841     }
842   }
843   else
844   {
845     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 4)
846     {
847       theSet.Elements.push_back (BVH_Vec4i (aVert + 0, aVert + 1, aVert + 2,
848                                             theMatID));
849       theSet.Elements.push_back (BVH_Vec4i (aVert + 0, aVert + 2, aVert + 3,
850                                             theMatID));
851     }
852   }
853
854   return Standard_True;
855 }
856
857 // =======================================================================
858 // function : AddRaytraceQuadrangleStripArray
859 // purpose  : Adds OpenGL quad strip array to ray-traced scene geometry
860 // =======================================================================
861 Standard_Boolean OpenGl_View::addRaytraceQuadrangleStripArray (OpenGl_TriangleSet&                  theSet,
862                                                                const Standard_Integer               theMatID,
863                                                                const Standard_Integer               theCount,
864                                                                const Standard_Integer               theOffset,
865                                                                const Handle(Graphic3d_IndexBuffer)& theIndices)
866 {
867   if (theCount < 4)
868   {
869     return Standard_True;
870   }
871
872   theSet.Elements.reserve (theSet.Elements.size() + 2 * theCount - 6);
873
874   if (!theIndices.IsNull())
875   {
876     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 2)
877     {
878       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + 0),
879                                             theIndices->Index (aVert + 1),
880                                             theIndices->Index (aVert + 2),
881                                             theMatID));
882
883       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (aVert + 1),
884                                             theIndices->Index (aVert + 3),
885                                             theIndices->Index (aVert + 2),
886                                             theMatID));
887     }
888   }
889   else
890   {
891     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 2)
892     {
893       theSet.Elements.push_back (BVH_Vec4i (aVert + 0,
894                                             aVert + 1,
895                                             aVert + 2,
896                                             theMatID));
897
898       theSet.Elements.push_back (BVH_Vec4i (aVert + 1,
899                                             aVert + 3,
900                                             aVert + 2,
901                                             theMatID));
902     }
903   }
904
905   return Standard_True;
906 }
907
908 // =======================================================================
909 // function : AddRaytracePolygonArray
910 // purpose  : Adds OpenGL polygon array to ray-traced scene geometry
911 // =======================================================================
912 Standard_Boolean OpenGl_View::addRaytracePolygonArray (OpenGl_TriangleSet&                  theSet,
913                                                        const Standard_Integer               theMatID,
914                                                        const Standard_Integer               theCount,
915                                                        const Standard_Integer               theOffset,
916                                                        const Handle(Graphic3d_IndexBuffer)& theIndices)
917 {
918   if (theCount < 3)
919   {
920     return Standard_True;
921   }
922
923   theSet.Elements.reserve (theSet.Elements.size() + theCount - 2);
924
925   if (!theIndices.IsNull())
926   {
927     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
928     {
929       theSet.Elements.push_back (BVH_Vec4i (theIndices->Index (theOffset),
930                                             theIndices->Index (aVert + 1),
931                                             theIndices->Index (aVert + 2),
932                                             theMatID));
933     }
934   }
935   else
936   {
937     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
938     {
939       theSet.Elements.push_back (BVH_Vec4i (theOffset,
940                                             aVert + 1,
941                                             aVert + 2,
942                                             theMatID));
943     }
944   }
945
946   return Standard_True;
947 }
948
949 // =======================================================================
950 // function : Source
951 // purpose  : Returns shader source combined with prefix
952 // =======================================================================
953 TCollection_AsciiString OpenGl_View::ShaderSource::Source() const
954 {
955   static const TCollection_AsciiString aVersion = "#version 140";
956
957   if (myPrefix.IsEmpty())
958   {
959     return aVersion + "\n" + mySource;
960   }
961
962   return aVersion + "\n" + myPrefix + "\n" + mySource;
963 }
964
965 // =======================================================================
966 // function : Load
967 // purpose  : Loads shader source from specified files
968 // =======================================================================
969 void OpenGl_View::ShaderSource::Load (const TCollection_AsciiString* theFileNames,
970                                       const Standard_Integer         theCount)
971 {
972   mySource.Clear();
973
974   for (Standard_Integer anIndex = 0; anIndex < theCount; ++anIndex)
975   {
976     OSD_File aFile (theFileNames[anIndex]);
977
978     Standard_ASSERT_RETURN (aFile.Exists(),
979       "Error: Failed to find shader source file", /* none */);
980
981     aFile.Open (OSD_ReadOnly, OSD_Protection());
982
983     TCollection_AsciiString aSource;
984
985     Standard_ASSERT_RETURN (aFile.IsOpen(),
986       "Error: Failed to open shader source file", /* none */);
987
988     aFile.Read (aSource, (Standard_Integer) aFile.Size());
989
990     if (!aSource.IsEmpty())
991     {
992       mySource += TCollection_AsciiString ("\n") + aSource;
993     }
994
995     aFile.Close();
996   }
997 }
998
999 // =======================================================================
1000 // function : GenerateShaderPrefix
1001 // purpose  : Generates shader prefix based on current ray-tracing options
1002 // =======================================================================
1003 TCollection_AsciiString OpenGl_View::generateShaderPrefix (const Handle(OpenGl_Context)& theGlContext) const
1004 {
1005   TCollection_AsciiString aPrefixString =
1006     TCollection_AsciiString ("#define STACK_SIZE ") + TCollection_AsciiString (myRaytraceParameters.StackSize) + "\n" +
1007     TCollection_AsciiString ("#define NB_BOUNCES ") + TCollection_AsciiString (myRaytraceParameters.NbBounces);
1008
1009   if (myRaytraceParameters.TransparentShadows)
1010   {
1011     aPrefixString += TCollection_AsciiString ("\n#define TRANSPARENT_SHADOWS");
1012   }
1013
1014   // If OpenGL driver supports bindless textures,
1015   // activate texturing in ray-tracing mode
1016   if (theGlContext->arbTexBindless != NULL)
1017   {
1018     aPrefixString += TCollection_AsciiString ("\n#define USE_TEXTURES") +
1019       TCollection_AsciiString ("\n#define MAX_TEX_NUMBER ") + TCollection_AsciiString (OpenGl_RaytraceGeometry::MAX_TEX_NUMBER);
1020   }
1021
1022   return aPrefixString;
1023 }
1024
1025 // =======================================================================
1026 // function : SafeFailBack
1027 // purpose  : Performs safe exit when shaders initialization fails
1028 // =======================================================================
1029 Standard_Boolean OpenGl_View::safeFailBack (const TCollection_ExtendedString& theMessage,
1030                                             const Handle(OpenGl_Context)&     theGlContext)
1031 {
1032   theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1033     GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, theMessage);
1034
1035   myRaytraceInitStatus = OpenGl_RT_FAIL;
1036
1037   releaseRaytraceResources (theGlContext);
1038
1039   return Standard_False;
1040 }
1041
1042 // =======================================================================
1043 // function : InitShader
1044 // purpose  : Creates new shader object with specified source
1045 // =======================================================================
1046 Handle(OpenGl_ShaderObject) OpenGl_View::initShader (const GLenum                  theType,
1047                                                      const ShaderSource&           theSource,
1048                                                      const Handle(OpenGl_Context)& theGlContext)
1049 {
1050   Handle(OpenGl_ShaderObject) aShader = new OpenGl_ShaderObject (theType);
1051
1052   if (!aShader->Create (theGlContext))
1053   {
1054     const TCollection_ExtendedString aMessage = TCollection_ExtendedString ("Error: Failed to create ") +
1055       (theType == GL_VERTEX_SHADER ? "vertex" : "fragment") + " shader object";
1056
1057     theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1058       GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
1059
1060     aShader->Release (theGlContext.operator->());
1061
1062     return Handle(OpenGl_ShaderObject)();
1063   }
1064
1065   if (!aShader->LoadSource (theGlContext, theSource.Source()))
1066   {
1067     const TCollection_ExtendedString aMessage = TCollection_ExtendedString ("Error: Failed to set ") +
1068       (theType == GL_VERTEX_SHADER ? "vertex" : "fragment") + " shader source";
1069
1070     theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1071       GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
1072
1073     aShader->Release (theGlContext.operator->());
1074
1075     return Handle(OpenGl_ShaderObject)();
1076   }
1077
1078   TCollection_AsciiString aBuildLog;
1079
1080   if (!aShader->Compile (theGlContext))
1081   {
1082     aShader->FetchInfoLog (theGlContext, aBuildLog);
1083
1084     const TCollection_ExtendedString aMessage = TCollection_ExtendedString ("Error: Failed to compile ") +
1085       (theType == GL_VERTEX_SHADER ? "vertex" : "fragment") + " shader object:\n" + aBuildLog;
1086
1087     theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1088       GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
1089
1090     aShader->Release (theGlContext.operator->());
1091
1092     return Handle(OpenGl_ShaderObject)();
1093   }
1094   else if (theGlContext->caps->glslWarnings)
1095   {
1096     aShader->FetchInfoLog (theGlContext, aBuildLog);
1097
1098     if (!aBuildLog.IsEmpty() && !aBuildLog.IsEqual ("No errors.\n"))
1099     {
1100       const TCollection_ExtendedString aMessage = TCollection_ExtendedString (theType == GL_VERTEX_SHADER ?
1101         "Vertex" : "Fragment") + " shader was compiled with following warnings:\n" + aBuildLog;
1102
1103       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1104         GL_DEBUG_TYPE_PORTABILITY_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMessage);
1105     }
1106   }
1107
1108   return aShader;
1109 }
1110
1111 // =======================================================================
1112 // function : InitRaytraceResources
1113 // purpose  : Initializes OpenGL/GLSL shader programs
1114 // =======================================================================
1115 Standard_Boolean OpenGl_View::initRaytraceResources (const Graphic3d_CView& theCView, const Handle(OpenGl_Context)& theGlContext)
1116 {
1117   if (myRaytraceInitStatus == OpenGl_RT_FAIL)
1118   {
1119     return Standard_False;
1120   }
1121
1122   Standard_Boolean aToRebuildShaders = Standard_False;
1123
1124   if (myRaytraceInitStatus == OpenGl_RT_INIT)
1125   {
1126     if (!myIsRaytraceDataValid)
1127       return Standard_True;
1128
1129     const Standard_Integer aRequiredStackSize =
1130       myRaytraceGeometry.HighLevelTreeDepth() + myRaytraceGeometry.BottomLevelTreeDepth();
1131
1132     if (myRaytraceParameters.StackSize < aRequiredStackSize)
1133     {
1134       myRaytraceParameters.StackSize = Max (aRequiredStackSize, THE_DEFAULT_STACK_SIZE);
1135
1136       aToRebuildShaders = Standard_True;
1137     }
1138     else
1139     {
1140       if (aRequiredStackSize < myRaytraceParameters.StackSize)
1141       {
1142         if (myRaytraceParameters.StackSize > THE_DEFAULT_STACK_SIZE)
1143         {
1144           myRaytraceParameters.StackSize = Max (aRequiredStackSize, THE_DEFAULT_STACK_SIZE);
1145           aToRebuildShaders = Standard_True;
1146         }
1147       }
1148     }
1149
1150     if (theCView.RenderParams.RaytracingDepth != myRaytraceParameters.NbBounces)
1151     {
1152       myRaytraceParameters.NbBounces = theCView.RenderParams.RaytracingDepth;
1153       aToRebuildShaders = Standard_True;
1154     }
1155
1156     if (theCView.RenderParams.IsTransparentShadowEnabled != myRaytraceParameters.TransparentShadows)
1157     {
1158       myRaytraceParameters.TransparentShadows = theCView.RenderParams.IsTransparentShadowEnabled;
1159       aToRebuildShaders = Standard_True;
1160     }
1161
1162     if (aToRebuildShaders)
1163     {
1164 #ifdef RAY_TRACE_PRINT_INFO
1165       std::cout << "Info: Rebuild shaders with stack size: " << myRaytraceParameters.StackSize << std::endl;
1166 #endif
1167
1168       // Change state to force update all uniforms
1169       myToUpdateEnvironmentMap = Standard_True;
1170
1171       TCollection_AsciiString aPrefixString = generateShaderPrefix (theGlContext);
1172
1173 #ifdef RAY_TRACE_PRINT_INFO
1174       std::cout << "GLSL prefix string:" << std::endl << aPrefixString << std::endl;
1175 #endif
1176
1177       myRaytraceShaderSource.SetPrefix (aPrefixString);
1178       myPostFSAAShaderSource.SetPrefix (aPrefixString);
1179
1180       if (!myRaytraceShader->LoadSource (theGlContext, myRaytraceShaderSource.Source())
1181        || !myPostFSAAShader->LoadSource (theGlContext, myPostFSAAShaderSource.Source()))
1182       {
1183         return safeFailBack ("Failed to load source into ray-tracing fragment shaders", theGlContext);
1184       }
1185
1186       if (!myRaytraceShader->Compile (theGlContext)
1187        || !myPostFSAAShader->Compile (theGlContext))
1188       {
1189         return safeFailBack ("Failed to compile ray-tracing fragment shaders", theGlContext);
1190       }
1191
1192       myRaytraceProgram->SetAttributeName (theGlContext, Graphic3d_TOA_POS, "occVertex");
1193       myPostFSAAProgram->SetAttributeName (theGlContext, Graphic3d_TOA_POS, "occVertex");
1194       if (!myRaytraceProgram->Link (theGlContext)
1195        || !myPostFSAAProgram->Link (theGlContext))
1196       {
1197         return safeFailBack ("Failed to initialize vertex attributes for ray-tracing program", theGlContext);
1198       }
1199     }
1200   }
1201
1202   if (myRaytraceInitStatus == OpenGl_RT_NONE)
1203   {
1204     if (!theGlContext->IsGlGreaterEqual (3, 1))
1205     {
1206       return safeFailBack ("Ray-tracing requires OpenGL 3.1 and higher", theGlContext);
1207     }
1208     else if (!theGlContext->arbTboRGB32)
1209     {
1210       return safeFailBack ("Ray-tracing requires OpenGL 4.0+ or GL_ARB_texture_buffer_object_rgb32 extension", theGlContext);
1211     }
1212     else if (!theGlContext->arbFBOBlit)
1213     {
1214       return safeFailBack ("Ray-tracing requires EXT_framebuffer_blit extension", theGlContext);
1215     }
1216
1217     myRaytraceParameters.NbBounces = theCView.RenderParams.RaytracingDepth;
1218
1219     TCollection_AsciiString aFolder = Graphic3d_ShaderProgram::ShadersFolder();
1220
1221     if (aFolder.IsEmpty())
1222     {
1223       return safeFailBack ("Failed to locate shaders directory", theGlContext);
1224     }
1225
1226     if (myIsRaytraceDataValid)
1227     {
1228       myRaytraceParameters.StackSize = Max (THE_DEFAULT_STACK_SIZE,
1229         myRaytraceGeometry.HighLevelTreeDepth() + myRaytraceGeometry.BottomLevelTreeDepth());
1230     }
1231
1232     TCollection_AsciiString aPrefixString  = generateShaderPrefix (theGlContext);
1233
1234 #ifdef RAY_TRACE_PRINT_INFO
1235     std::cout << "GLSL prefix string:" << std::endl << aPrefixString << std::endl;
1236 #endif
1237
1238     {
1239       Handle(OpenGl_ShaderObject) aBasicVertShader = initShader (
1240         GL_VERTEX_SHADER, ShaderSource (aFolder + "/RaytraceBase.vs"), theGlContext);
1241
1242       if (aBasicVertShader.IsNull())
1243       {
1244         return safeFailBack ("Failed to initialize ray-trace vertex shader", theGlContext);
1245       }
1246
1247       TCollection_AsciiString aFiles[] = { aFolder + "/RaytraceBase.fs",
1248                                            aFolder + "/RaytraceRender.fs" };
1249
1250       myRaytraceShaderSource.Load (aFiles, 2);
1251
1252       myRaytraceShaderSource.SetPrefix (aPrefixString);
1253
1254       myRaytraceShader = initShader (GL_FRAGMENT_SHADER, myRaytraceShaderSource, theGlContext);
1255
1256       if (myRaytraceShader.IsNull())
1257       {
1258         aBasicVertShader->Release (theGlContext.operator->());
1259
1260         return safeFailBack ("Failed to initialize ray-trace fragment shader", theGlContext);
1261       }
1262
1263       myRaytraceProgram = new OpenGl_ShaderProgram;
1264
1265       if (!myRaytraceProgram->Create (theGlContext))
1266       {
1267         aBasicVertShader->Release (theGlContext.operator->());
1268
1269         return safeFailBack ("Failed to create ray-trace shader program", theGlContext);
1270       }
1271
1272       if (!myRaytraceProgram->AttachShader (theGlContext, aBasicVertShader)
1273        || !myRaytraceProgram->AttachShader (theGlContext, myRaytraceShader))
1274       {
1275         aBasicVertShader->Release (theGlContext.operator->());
1276
1277         return safeFailBack ("Failed to attach ray-trace shader objects", theGlContext);
1278       }
1279
1280       myRaytraceProgram->SetAttributeName (theGlContext, Graphic3d_TOA_POS, "occVertex");
1281
1282       TCollection_AsciiString aLinkLog;
1283
1284       if (!myRaytraceProgram->Link (theGlContext))
1285       {
1286         myRaytraceProgram->FetchInfoLog (theGlContext, aLinkLog);
1287
1288         return safeFailBack (TCollection_ExtendedString (
1289           "Failed to link ray-trace shader program:\n") + aLinkLog, theGlContext);
1290       }
1291       else if (theGlContext->caps->glslWarnings)
1292       {
1293         myRaytraceProgram->FetchInfoLog (theGlContext, aLinkLog);
1294
1295         if (!aLinkLog.IsEmpty() && !aLinkLog.IsEqual ("No errors.\n"))
1296         {
1297           const TCollection_ExtendedString aMessage = TCollection_ExtendedString (
1298             "Ray-trace shader program was linked with following warnings:\n") + aLinkLog;
1299
1300           theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1301             GL_DEBUG_TYPE_PORTABILITY_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMessage);
1302         }
1303       }
1304     }
1305
1306     {
1307       Handle(OpenGl_ShaderObject) aBasicVertShader = initShader (
1308         GL_VERTEX_SHADER, ShaderSource (aFolder + "/RaytraceBase.vs"), theGlContext);
1309
1310       if (aBasicVertShader.IsNull())
1311       {
1312         return safeFailBack ("Failed to initialize FSAA vertex shader", theGlContext);
1313       }
1314
1315       TCollection_AsciiString aFiles[] = { aFolder + "/RaytraceBase.fs",
1316                                            aFolder + "/RaytraceSmooth.fs" };
1317
1318       myPostFSAAShaderSource.Load (aFiles, 2);
1319
1320       myPostFSAAShaderSource.SetPrefix (aPrefixString);
1321     
1322       myPostFSAAShader = initShader (GL_FRAGMENT_SHADER, myPostFSAAShaderSource, theGlContext);
1323
1324       if (myPostFSAAShader.IsNull())
1325       {
1326         aBasicVertShader->Release (theGlContext.operator->());
1327
1328         return safeFailBack ("Failed to initialize FSAA fragment shader", theGlContext);
1329       }
1330
1331       myPostFSAAProgram = new OpenGl_ShaderProgram;
1332
1333       if (!myPostFSAAProgram->Create (theGlContext))
1334       {
1335         aBasicVertShader->Release (theGlContext.operator->());
1336
1337         return safeFailBack ("Failed to create FSAA shader program", theGlContext);
1338       }
1339
1340       if (!myPostFSAAProgram->AttachShader (theGlContext, aBasicVertShader)
1341        || !myPostFSAAProgram->AttachShader (theGlContext, myPostFSAAShader))
1342       {
1343         aBasicVertShader->Release (theGlContext.operator->());
1344
1345         return safeFailBack ("Failed to attach FSAA shader objects", theGlContext);
1346       }
1347
1348       myPostFSAAProgram->SetAttributeName (theGlContext, Graphic3d_TOA_POS, "occVertex");
1349
1350       TCollection_AsciiString aLinkLog;
1351
1352       if (!myPostFSAAProgram->Link (theGlContext))
1353       {
1354         myPostFSAAProgram->FetchInfoLog (theGlContext, aLinkLog);
1355       
1356         return safeFailBack (TCollection_ExtendedString (
1357           "Failed to link FSAA shader program:\n") + aLinkLog, theGlContext);
1358       }
1359       else if (theGlContext->caps->glslWarnings)
1360       {
1361         myPostFSAAProgram->FetchInfoLog (theGlContext, aLinkLog);
1362
1363         if (!aLinkLog.IsEmpty() && !aLinkLog.IsEqual ("No errors.\n"))
1364         {
1365           const TCollection_ExtendedString aMessage = TCollection_ExtendedString (
1366             "FSAA shader program was linked with following warnings:\n") + aLinkLog;
1367
1368           theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1369             GL_DEBUG_TYPE_PORTABILITY_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMessage);
1370         }
1371       }
1372     }
1373   }
1374
1375   if (myRaytraceInitStatus == OpenGl_RT_NONE || aToRebuildShaders)
1376   {
1377     for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
1378     {
1379       Handle(OpenGl_ShaderProgram)& aShaderProgram =
1380         (anIndex == 0) ? myRaytraceProgram : myPostFSAAProgram;
1381
1382       theGlContext->BindProgram (aShaderProgram);
1383
1384       aShaderProgram->SetSampler (theGlContext,
1385         "uSceneMinPointTexture", OpenGl_RT_SceneMinPointTexture);
1386       aShaderProgram->SetSampler (theGlContext,
1387         "uSceneMaxPointTexture", OpenGl_RT_SceneMaxPointTexture);
1388       aShaderProgram->SetSampler (theGlContext,
1389         "uSceneNodeInfoTexture", OpenGl_RT_SceneNodeInfoTexture);
1390       aShaderProgram->SetSampler (theGlContext,
1391         "uGeometryVertexTexture", OpenGl_RT_GeometryVertexTexture);
1392       aShaderProgram->SetSampler (theGlContext,
1393         "uGeometryNormalTexture", OpenGl_RT_GeometryNormalTexture);
1394       aShaderProgram->SetSampler (theGlContext,
1395         "uGeometryTexCrdTexture", OpenGl_RT_GeometryTexCrdTexture);
1396       aShaderProgram->SetSampler (theGlContext,
1397         "uGeometryTriangTexture", OpenGl_RT_GeometryTriangTexture);
1398       aShaderProgram->SetSampler (theGlContext, 
1399         "uSceneTransformTexture", OpenGl_RT_SceneTransformTexture);
1400       aShaderProgram->SetSampler (theGlContext,
1401         "uEnvironmentMapTexture", OpenGl_RT_EnvironmentMapTexture);
1402       aShaderProgram->SetSampler (theGlContext,
1403         "uRaytraceMaterialTexture", OpenGl_RT_RaytraceMaterialTexture);
1404       aShaderProgram->SetSampler (theGlContext,
1405         "uRaytraceLightSrcTexture", OpenGl_RT_RaytraceLightSrcTexture);
1406
1407       aShaderProgram->SetSampler (theGlContext,
1408         "uOpenGlColorTexture", OpenGl_RT_OpenGlColorTexture);
1409       aShaderProgram->SetSampler (theGlContext,
1410         "uOpenGlDepthTexture", OpenGl_RT_OpenGlDepthTexture);
1411
1412       if (anIndex == 1)
1413       {
1414         aShaderProgram->SetSampler (theGlContext,
1415           "uFSAAInputTexture", OpenGl_RT_FSAAInputTexture);
1416       }
1417
1418       myUniformLocations[anIndex][OpenGl_RT_aPosition] =
1419         aShaderProgram->GetAttributeLocation (theGlContext, "occVertex");
1420
1421       myUniformLocations[anIndex][OpenGl_RT_uOriginLB] =
1422         aShaderProgram->GetUniformLocation (theGlContext, "uOriginLB");
1423       myUniformLocations[anIndex][OpenGl_RT_uOriginRB] =
1424         aShaderProgram->GetUniformLocation (theGlContext, "uOriginRB");
1425       myUniformLocations[anIndex][OpenGl_RT_uOriginLT] =
1426         aShaderProgram->GetUniformLocation (theGlContext, "uOriginLT");
1427       myUniformLocations[anIndex][OpenGl_RT_uOriginRT] =
1428         aShaderProgram->GetUniformLocation (theGlContext, "uOriginRT");
1429       myUniformLocations[anIndex][OpenGl_RT_uDirectLB] =
1430         aShaderProgram->GetUniformLocation (theGlContext, "uDirectLB");
1431       myUniformLocations[anIndex][OpenGl_RT_uDirectRB] =
1432         aShaderProgram->GetUniformLocation (theGlContext, "uDirectRB");
1433       myUniformLocations[anIndex][OpenGl_RT_uDirectLT] =
1434         aShaderProgram->GetUniformLocation (theGlContext, "uDirectLT");
1435       myUniformLocations[anIndex][OpenGl_RT_uDirectRT] =
1436         aShaderProgram->GetUniformLocation (theGlContext, "uDirectRT");
1437       myUniformLocations[anIndex][OpenGl_RT_uUnviewMat] =
1438         aShaderProgram->GetUniformLocation (theGlContext, "uUnviewMat");
1439
1440       myUniformLocations[anIndex][OpenGl_RT_uSceneRad] =
1441         aShaderProgram->GetUniformLocation (theGlContext, "uSceneRadius");
1442       myUniformLocations[anIndex][OpenGl_RT_uSceneEps] =
1443         aShaderProgram->GetUniformLocation (theGlContext, "uSceneEpsilon");
1444       myUniformLocations[anIndex][OpenGl_RT_uLightCount] =
1445         aShaderProgram->GetUniformLocation (theGlContext, "uLightCount");
1446       myUniformLocations[anIndex][OpenGl_RT_uLightAmbnt] =
1447         aShaderProgram->GetUniformLocation (theGlContext, "uGlobalAmbient");
1448
1449       myUniformLocations[anIndex][OpenGl_RT_uOffsetX] =
1450         aShaderProgram->GetUniformLocation (theGlContext, "uOffsetX");
1451       myUniformLocations[anIndex][OpenGl_RT_uOffsetY] =
1452         aShaderProgram->GetUniformLocation (theGlContext, "uOffsetY");
1453       myUniformLocations[anIndex][OpenGl_RT_uSamples] =
1454         aShaderProgram->GetUniformLocation (theGlContext, "uSamples");
1455       myUniformLocations[anIndex][OpenGl_RT_uWinSizeX] =
1456         aShaderProgram->GetUniformLocation (theGlContext, "uWinSizeX");
1457       myUniformLocations[anIndex][OpenGl_RT_uWinSizeY] =
1458         aShaderProgram->GetUniformLocation (theGlContext, "uWinSizeY");
1459
1460       myUniformLocations[anIndex][OpenGl_RT_uTextures] =
1461         aShaderProgram->GetUniformLocation (theGlContext, "uTextureSamplers");
1462
1463       myUniformLocations[anIndex][OpenGl_RT_uShadEnabled] =
1464         aShaderProgram->GetUniformLocation (theGlContext, "uShadowsEnable");
1465       myUniformLocations[anIndex][OpenGl_RT_uReflEnabled] =
1466         aShaderProgram->GetUniformLocation (theGlContext, "uReflectionsEnable");
1467       myUniformLocations[anIndex][OpenGl_RT_uEnvMapEnable] =
1468         aShaderProgram->GetUniformLocation (theGlContext, "uEnvironmentEnable");
1469     }
1470
1471     theGlContext->BindProgram (NULL);
1472   }
1473
1474   if (myRaytraceInitStatus != OpenGl_RT_NONE)
1475   {
1476     return myRaytraceInitStatus == OpenGl_RT_INIT;
1477   }
1478
1479   if (myRaytraceFBO1.IsNull())
1480   {
1481     myRaytraceFBO1 = new OpenGl_FrameBuffer;
1482   }
1483
1484   if (myRaytraceFBO2.IsNull())
1485   {
1486     myRaytraceFBO2 = new OpenGl_FrameBuffer;
1487   }
1488
1489   const GLfloat aVertices[] = { -1.f, -1.f,  0.f,
1490                                 -1.f,  1.f,  0.f,
1491                                  1.f,  1.f,  0.f,
1492                                  1.f,  1.f,  0.f,
1493                                  1.f, -1.f,  0.f,
1494                                 -1.f, -1.f,  0.f };
1495
1496   myRaytraceScreenQuad.Init (theGlContext, 3, 6, aVertices);
1497
1498   myRaytraceInitStatus = OpenGl_RT_INIT; // initialized in normal way
1499
1500   return Standard_True;
1501 }
1502
1503 // =======================================================================
1504 // function : NullifyResource
1505 // purpose  :
1506 // =======================================================================
1507 inline void NullifyResource (const Handle(OpenGl_Context)& theGlContext,
1508                              Handle(OpenGl_Resource)&      theResource)
1509 {
1510   if (!theResource.IsNull())
1511   {
1512     theResource->Release (theGlContext.operator->());
1513     theResource.Nullify();
1514   }
1515 }
1516
1517 // =======================================================================
1518 // function : ReleaseRaytraceResources
1519 // purpose  : Releases OpenGL/GLSL shader programs
1520 // =======================================================================
1521 void OpenGl_View::releaseRaytraceResources (const Handle(OpenGl_Context)& theGlContext)
1522 {
1523   NullifyResource (theGlContext, myOpenGlFBO);
1524   NullifyResource (theGlContext, myRaytraceFBO1);
1525   NullifyResource (theGlContext, myRaytraceFBO2);
1526
1527   NullifyResource (theGlContext, myRaytraceShader);
1528   NullifyResource (theGlContext, myPostFSAAShader);
1529
1530   NullifyResource (theGlContext, myRaytraceProgram);
1531   NullifyResource (theGlContext, myPostFSAAProgram);
1532
1533   NullifyResource (theGlContext, mySceneNodeInfoTexture);
1534   NullifyResource (theGlContext, mySceneMinPointTexture);
1535   NullifyResource (theGlContext, mySceneMaxPointTexture);
1536
1537   NullifyResource (theGlContext, myGeometryVertexTexture);
1538   NullifyResource (theGlContext, myGeometryNormalTexture);
1539   NullifyResource (theGlContext, myGeometryTexCrdTexture);
1540   NullifyResource (theGlContext, myGeometryTriangTexture);
1541   NullifyResource (theGlContext, mySceneTransformTexture);
1542
1543   NullifyResource (theGlContext, myRaytraceLightSrcTexture);
1544   NullifyResource (theGlContext, myRaytraceMaterialTexture);
1545
1546   if (myRaytraceScreenQuad.IsValid())
1547     myRaytraceScreenQuad.Release (theGlContext.operator->());
1548 }
1549
1550 // =======================================================================
1551 // function : ResizeRaytraceBuffers
1552 // purpose  : Resizes OpenGL frame buffers
1553 // =======================================================================
1554 Standard_Boolean OpenGl_View::resizeRaytraceBuffers (const Standard_Integer        theSizeX,
1555                                                      const Standard_Integer        theSizeY,
1556                                                      const Handle(OpenGl_Context)& theGlContext)
1557 {
1558   if (myRaytraceFBO1->GetVPSizeX() != theSizeX
1559    || myRaytraceFBO1->GetVPSizeY() != theSizeY)
1560   {
1561     myRaytraceFBO1->Init (theGlContext, theSizeX, theSizeY);
1562     myRaytraceFBO2->Init (theGlContext, theSizeX, theSizeY);
1563   }
1564
1565   return Standard_True;
1566 }
1567
1568 // =======================================================================
1569 // function : UpdateCamera
1570 // purpose  : Generates viewing rays for corners of screen quad
1571 // =======================================================================
1572 void OpenGl_View::updateCamera (const OpenGl_Mat4& theOrientation,
1573                                 const OpenGl_Mat4& theViewMapping,
1574                                 OpenGl_Vec3*       theOrigins,
1575                                 OpenGl_Vec3*       theDirects,
1576                                 OpenGl_Mat4&       theUnview)
1577 {
1578   // compute inverse model-view-projection matrix
1579   (theViewMapping * theOrientation).Inverted (theUnview);
1580
1581   Standard_Integer aOriginIndex = 0;
1582   Standard_Integer aDirectIndex = 0;
1583
1584   for (Standard_Integer aY = -1; aY <= 1; aY += 2)
1585   {
1586     for (Standard_Integer aX = -1; aX <= 1; aX += 2)
1587     {
1588       OpenGl_Vec4 aOrigin (GLfloat(aX),
1589                            GLfloat(aY),
1590                           -1.0f,
1591                            1.0f);
1592
1593       aOrigin = theUnview * aOrigin;
1594
1595       aOrigin.x() = aOrigin.x() / aOrigin.w();
1596       aOrigin.y() = aOrigin.y() / aOrigin.w();
1597       aOrigin.z() = aOrigin.z() / aOrigin.w();
1598
1599       OpenGl_Vec4 aDirect (GLfloat(aX),
1600                            GLfloat(aY),
1601                            1.0f,
1602                            1.0f);
1603
1604       aDirect = theUnview * aDirect;
1605
1606       aDirect.x() = aDirect.x() / aDirect.w();
1607       aDirect.y() = aDirect.y() / aDirect.w();
1608       aDirect.z() = aDirect.z() / aDirect.w();
1609
1610       aDirect = aDirect - aOrigin;
1611
1612       GLdouble aInvLen = 1.0 / sqrt (aDirect.x() * aDirect.x() +
1613                                      aDirect.y() * aDirect.y() +
1614                                      aDirect.z() * aDirect.z());
1615
1616       theOrigins[aOriginIndex++] = OpenGl_Vec3 (static_cast<GLfloat> (aOrigin.x()),
1617                                                 static_cast<GLfloat> (aOrigin.y()),
1618                                                 static_cast<GLfloat> (aOrigin.z()));
1619
1620       theDirects[aDirectIndex++] = OpenGl_Vec3 (static_cast<GLfloat> (aDirect.x() * aInvLen),
1621                                                 static_cast<GLfloat> (aDirect.y() * aInvLen),
1622                                                 static_cast<GLfloat> (aDirect.z() * aInvLen));
1623     }
1624   }
1625 }
1626
1627 // =======================================================================
1628 // function : UploadRaytraceData
1629 // purpose  : Uploads ray-trace data to the GPU
1630 // =======================================================================
1631 Standard_Boolean OpenGl_View::uploadRaytraceData (const Handle(OpenGl_Context)& theGlContext)
1632 {
1633   if (!theGlContext->IsGlGreaterEqual (3, 1))
1634   {
1635 #ifdef RAY_TRACE_PRINT_INFO
1636     std::cout << "Error: OpenGL version is less than 3.1" << std::endl;
1637 #endif
1638     return Standard_False;
1639   }
1640
1641   /////////////////////////////////////////////////////////////////////////////
1642   // Prepare OpenGL textures
1643
1644   if (theGlContext->arbTexBindless != NULL)
1645   {
1646     // If OpenGL driver supports bindless textures we need
1647     // to get unique 64- bit handles for using on the GPU
1648     if (!myRaytraceGeometry.UpdateTextureHandles (theGlContext))
1649     {
1650 #ifdef RAY_TRACE_PRINT_INFO
1651       std::cout << "Error: Failed to get OpenGL texture handles" << std::endl;
1652 #endif
1653       return Standard_False;
1654     }
1655   }
1656
1657   /////////////////////////////////////////////////////////////////////////////
1658   // Create OpenGL BVH buffers
1659
1660   if (mySceneNodeInfoTexture.IsNull())  // create scene BVH buffers
1661   {
1662     mySceneNodeInfoTexture  = new OpenGl_TextureBufferArb;
1663     mySceneMinPointTexture  = new OpenGl_TextureBufferArb;
1664     mySceneMaxPointTexture  = new OpenGl_TextureBufferArb;
1665     mySceneTransformTexture = new OpenGl_TextureBufferArb;
1666
1667     if (!mySceneNodeInfoTexture->Create  (theGlContext)
1668      || !mySceneMinPointTexture->Create  (theGlContext)
1669      || !mySceneMaxPointTexture->Create  (theGlContext)
1670      || !mySceneTransformTexture->Create (theGlContext))
1671     {
1672 #ifdef RAY_TRACE_PRINT_INFO
1673       std::cout << "Error: Failed to create scene BVH buffers" << std::endl;
1674 #endif
1675       return Standard_False;
1676     }
1677   }
1678
1679   if  (myGeometryVertexTexture.IsNull())  // create geometry buffers
1680   {
1681     myGeometryVertexTexture = new OpenGl_TextureBufferArb;
1682     myGeometryNormalTexture = new OpenGl_TextureBufferArb;
1683     myGeometryTexCrdTexture = new OpenGl_TextureBufferArb;
1684     myGeometryTriangTexture = new OpenGl_TextureBufferArb;
1685
1686     if (!myGeometryVertexTexture->Create (theGlContext)
1687      || !myGeometryNormalTexture->Create (theGlContext)
1688      || !myGeometryTexCrdTexture->Create (theGlContext)
1689      || !myGeometryTriangTexture->Create (theGlContext))
1690     {
1691 #ifdef RAY_TRACE_PRINT_INFO
1692       std::cout << "Error: Failed to create buffers for triangulation data" << std::endl;
1693 #endif
1694       return Standard_False;
1695     }
1696   }
1697
1698   if (myRaytraceMaterialTexture.IsNull()) // create material buffer
1699   {
1700     myRaytraceMaterialTexture = new OpenGl_TextureBufferArb;
1701
1702     if (!myRaytraceMaterialTexture->Create (theGlContext))
1703     {
1704 #ifdef RAY_TRACE_PRINT_INFO
1705       std::cout << "Error: Failed to create buffers for material data" << std::endl;
1706 #endif
1707       return Standard_False;
1708     }
1709   }
1710   
1711   /////////////////////////////////////////////////////////////////////////////
1712   // Write transform buffer
1713
1714   BVH_Mat4f* aNodeTransforms = new BVH_Mat4f[myRaytraceGeometry.Size()];
1715
1716   bool aResult = true;
1717
1718   for (Standard_Integer anElemIndex = 0; anElemIndex < myRaytraceGeometry.Size(); ++anElemIndex)
1719   {
1720     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
1721       myRaytraceGeometry.Objects().ChangeValue (anElemIndex).operator->());
1722
1723     const BVH_Transform<Standard_ShortReal, 4>* aTransform = 
1724       dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (aTriangleSet->Properties().operator->());
1725
1726     Standard_ASSERT_RETURN (aTransform != NULL,
1727       "OpenGl_TriangleSet does not contain transform", Standard_False);
1728
1729     aNodeTransforms[anElemIndex] = aTransform->Inversed();
1730   }
1731
1732   aResult &= mySceneTransformTexture->Init (theGlContext, 4,
1733     myRaytraceGeometry.Size() * 4, reinterpret_cast<const GLfloat*> (aNodeTransforms));
1734
1735   delete [] aNodeTransforms;
1736
1737   /////////////////////////////////////////////////////////////////////////////
1738   // Write geometry and bottom-level BVH buffers
1739
1740   Standard_Size aTotalVerticesNb = 0;
1741   Standard_Size aTotalElementsNb = 0;
1742   Standard_Size aTotalBVHNodesNb = 0;
1743
1744   for (Standard_Integer anElemIndex = 0; anElemIndex < myRaytraceGeometry.Size(); ++anElemIndex)
1745   {
1746     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
1747       myRaytraceGeometry.Objects().ChangeValue (anElemIndex).operator->());
1748
1749     Standard_ASSERT_RETURN (aTriangleSet != NULL,
1750       "Error: Failed to get triangulation of OpenGL element", Standard_False);
1751
1752     aTotalVerticesNb += aTriangleSet->Vertices.size();
1753     aTotalElementsNb += aTriangleSet->Elements.size();
1754
1755     Standard_ASSERT_RETURN (!aTriangleSet->BVH().IsNull(),
1756       "Error: Failed to get bottom-level BVH of OpenGL element", Standard_False);
1757
1758     aTotalBVHNodesNb += aTriangleSet->BVH()->NodeInfoBuffer().size();
1759   }
1760
1761   aTotalBVHNodesNb += myRaytraceGeometry.BVH()->NodeInfoBuffer().size();
1762
1763   if (aTotalBVHNodesNb != 0)
1764   {
1765     aResult &= mySceneNodeInfoTexture->Init (
1766       theGlContext, 4, GLsizei (aTotalBVHNodesNb), static_cast<const GLuint*>  (NULL));
1767     aResult &= mySceneMinPointTexture->Init (
1768       theGlContext, 3, GLsizei (aTotalBVHNodesNb), static_cast<const GLfloat*> (NULL));
1769     aResult &= mySceneMaxPointTexture->Init (
1770       theGlContext, 3, GLsizei (aTotalBVHNodesNb), static_cast<const GLfloat*> (NULL));
1771   }
1772
1773   if (!aResult)
1774   {
1775 #ifdef RAY_TRACE_PRINT_INFO
1776     std::cout << "Error: Failed to upload buffers for bottom-level scene BVH" << std::endl;
1777 #endif
1778     return Standard_False;
1779   }
1780
1781   if (aTotalElementsNb != 0)
1782   {
1783     aResult &= myGeometryTriangTexture->Init (
1784       theGlContext, 4, GLsizei (aTotalElementsNb), static_cast<const GLuint*> (NULL));
1785   }
1786
1787   if (aTotalVerticesNb != 0)
1788   {
1789     aResult &= myGeometryVertexTexture->Init (
1790       theGlContext, 3, GLsizei (aTotalVerticesNb), static_cast<const GLfloat*> (NULL));
1791     aResult &= myGeometryNormalTexture->Init (
1792       theGlContext, 3, GLsizei (aTotalVerticesNb), static_cast<const GLfloat*> (NULL));
1793     aResult &= myGeometryTexCrdTexture->Init (
1794       theGlContext, 2, GLsizei (aTotalVerticesNb), static_cast<const GLfloat*> (NULL));
1795   }
1796
1797   if (!aResult)
1798   {
1799 #ifdef RAY_TRACE_PRINT_INFO
1800     std::cout << "Error: Failed to upload buffers for scene geometry" << std::endl;
1801 #endif
1802     return Standard_False;
1803   }
1804
1805   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 3> >& aBVH = myRaytraceGeometry.BVH();
1806
1807   if (aBVH->Length() > 0)
1808   {
1809     aResult &= mySceneNodeInfoTexture->SubData (theGlContext, 0, aBVH->Length(),
1810       reinterpret_cast<const GLuint*> (&aBVH->NodeInfoBuffer().front()));
1811     aResult &= mySceneMinPointTexture->SubData (theGlContext, 0, aBVH->Length(),
1812       reinterpret_cast<const GLfloat*> (&aBVH->MinPointBuffer().front()));
1813     aResult &= mySceneMaxPointTexture->SubData (theGlContext, 0, aBVH->Length(),
1814       reinterpret_cast<const GLfloat*> (&aBVH->MaxPointBuffer().front()));
1815   }
1816
1817   for (Standard_Integer aNodeIdx = 0; aNodeIdx < aBVH->Length(); ++aNodeIdx)
1818   {
1819     if (!aBVH->IsOuter (aNodeIdx))
1820       continue;
1821
1822     OpenGl_TriangleSet* aTriangleSet = myRaytraceGeometry.TriangleSet (aNodeIdx);
1823
1824     Standard_ASSERT_RETURN (aTriangleSet != NULL,
1825       "Error: Failed to get triangulation of OpenGL element", Standard_False);
1826
1827     Standard_Integer aBVHOffset = myRaytraceGeometry.AccelerationOffset (aNodeIdx);
1828
1829     Standard_ASSERT_RETURN (aBVHOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1830       "Error: Failed to get offset for bottom-level BVH", Standard_False);
1831
1832     const Standard_Integer aBvhBuffersSize = aTriangleSet->BVH()->Length();
1833
1834     if (aBvhBuffersSize != 0)
1835     {
1836       aResult &= mySceneNodeInfoTexture->SubData (theGlContext, aBVHOffset, aBvhBuffersSize,
1837         reinterpret_cast<const GLuint*> (&aTriangleSet->BVH()->NodeInfoBuffer().front()));
1838       aResult &= mySceneMinPointTexture->SubData (theGlContext, aBVHOffset, aBvhBuffersSize,
1839         reinterpret_cast<const GLfloat*> (&aTriangleSet->BVH()->MinPointBuffer().front()));
1840       aResult &= mySceneMaxPointTexture->SubData (theGlContext, aBVHOffset, aBvhBuffersSize,
1841         reinterpret_cast<const GLfloat*> (&aTriangleSet->BVH()->MaxPointBuffer().front()));
1842
1843       if (!aResult)
1844       {
1845 #ifdef RAY_TRACE_PRINT_INFO
1846         std::cout << "Error: Failed to upload buffers for bottom-level scene BVHs" << std::endl;
1847 #endif
1848         return Standard_False;
1849       }
1850     }
1851
1852     const Standard_Integer aVerticesOffset = myRaytraceGeometry.VerticesOffset (aNodeIdx);
1853
1854     Standard_ASSERT_RETURN (aVerticesOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1855       "Error: Failed to get offset for triangulation vertices of OpenGL element", Standard_False);
1856
1857     if (!aTriangleSet->Vertices.empty())
1858     {
1859       aResult &= myGeometryNormalTexture->SubData (theGlContext, aVerticesOffset,
1860         GLsizei (aTriangleSet->Normals.size()), reinterpret_cast<const GLfloat*> (&aTriangleSet->Normals.front()));
1861       aResult &= myGeometryTexCrdTexture->SubData (theGlContext, aVerticesOffset,
1862         GLsizei (aTriangleSet->TexCrds.size()), reinterpret_cast<const GLfloat*> (&aTriangleSet->TexCrds.front()));
1863       aResult &= myGeometryVertexTexture->SubData (theGlContext, aVerticesOffset,
1864         GLsizei (aTriangleSet->Vertices.size()), reinterpret_cast<const GLfloat*> (&aTriangleSet->Vertices.front()));
1865     }
1866
1867     const Standard_Integer anElementsOffset = myRaytraceGeometry.ElementsOffset (aNodeIdx);
1868
1869     Standard_ASSERT_RETURN (anElementsOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1870       "Error: Failed to get offset for triangulation elements of OpenGL element", Standard_False);
1871
1872     if (!aTriangleSet->Elements.empty())
1873     {
1874       aResult &= myGeometryTriangTexture->SubData (theGlContext, anElementsOffset, GLsizei (aTriangleSet->Elements.size()),
1875                                                    reinterpret_cast<const GLuint*> (&aTriangleSet->Elements.front()));
1876     }
1877
1878     if (!aResult)
1879     {
1880 #ifdef RAY_TRACE_PRINT_INFO
1881       std::cout << "Error: Failed to upload triangulation buffers for OpenGL element" << std::endl;
1882 #endif
1883       return Standard_False;
1884     }
1885   }
1886
1887   /////////////////////////////////////////////////////////////////////////////
1888   // Write material buffer
1889
1890   if (myRaytraceGeometry.Materials.size() != 0)
1891   {
1892     aResult &= myRaytraceMaterialTexture->Init (theGlContext, 4,
1893       GLsizei (myRaytraceGeometry.Materials.size() * 11),  myRaytraceGeometry.Materials.front().Packed());
1894
1895     if (!aResult)
1896     {
1897 #ifdef RAY_TRACE_PRINT_INFO
1898       std::cout << "Error: Failed to upload material buffer" << std::endl;
1899 #endif
1900       return Standard_False;
1901     }
1902   }
1903
1904   myIsRaytraceDataValid = myRaytraceGeometry.Objects().Size() != 0;
1905
1906 #ifdef RAY_TRACE_PRINT_INFO
1907
1908   Standard_ShortReal aMemUsed = 0.f;
1909
1910   for (Standard_Integer anElemIdx = 0; anElemIdx < myRaytraceGeometry.Size(); ++anElemIdx)
1911   {
1912     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
1913       myRaytraceGeometry.Objects().ChangeValue (anElemIdx).operator->());
1914
1915     aMemUsed += static_cast<Standard_ShortReal> (
1916       aTriangleSet->Vertices.size() * sizeof (BVH_Vec3f));
1917     aMemUsed += static_cast<Standard_ShortReal> (
1918       aTriangleSet->Normals.size() * sizeof (BVH_Vec3f));
1919     aMemUsed += static_cast<Standard_ShortReal> (
1920       aTriangleSet->TexCrds.size() * sizeof (BVH_Vec2f));
1921     aMemUsed += static_cast<Standard_ShortReal> (
1922       aTriangleSet->Elements.size() * sizeof (BVH_Vec4i));
1923
1924     aMemUsed += static_cast<Standard_ShortReal> (
1925       aTriangleSet->BVH()->NodeInfoBuffer().size() * sizeof (BVH_Vec4i));
1926     aMemUsed += static_cast<Standard_ShortReal> (
1927       aTriangleSet->BVH()->MinPointBuffer().size() * sizeof (BVH_Vec3f));
1928     aMemUsed += static_cast<Standard_ShortReal> (
1929       aTriangleSet->BVH()->MaxPointBuffer().size() * sizeof (BVH_Vec3f));
1930   }
1931
1932   aMemUsed += static_cast<Standard_ShortReal> (
1933     myRaytraceGeometry.BVH()->NodeInfoBuffer().size() * sizeof (BVH_Vec4i));
1934   aMemUsed += static_cast<Standard_ShortReal> (
1935     myRaytraceGeometry.BVH()->MinPointBuffer().size() * sizeof (BVH_Vec3f));
1936   aMemUsed += static_cast<Standard_ShortReal> (
1937     myRaytraceGeometry.BVH()->MaxPointBuffer().size() * sizeof (BVH_Vec3f));
1938
1939   std::cout << "GPU Memory Used (MB): ~" << aMemUsed / 1048576 << std::endl;
1940
1941 #endif
1942
1943   return aResult;
1944 }
1945
1946 // =======================================================================
1947 // function : UpdateRaytraceLightSources
1948 // purpose  : Updates 3D scene light sources for ray-tracing
1949 // =======================================================================
1950 Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext)
1951 {
1952   myRaytraceGeometry.Sources.clear();
1953
1954   myRaytraceGeometry.Ambient = BVH_Vec4f (0.0f, 0.0f, 0.0f, 0.0f);
1955
1956   for (OpenGl_ListOfLight::Iterator anItl (LightList()); anItl.More(); anItl.Next())
1957   {
1958     const OpenGl_Light& aLight = anItl.Value();
1959
1960     if (aLight.Type == Visual3d_TOLS_AMBIENT)
1961     {
1962       myRaytraceGeometry.Ambient += BVH_Vec4f (aLight.Color.r(),
1963                                                aLight.Color.g(),
1964                                                aLight.Color.b(),
1965                                                0.0f);
1966       continue;
1967     }
1968
1969     BVH_Vec4f aDiffuse  (aLight.Color.r(),
1970                          aLight.Color.g(),
1971                          aLight.Color.b(),
1972                          1.0f);
1973
1974     BVH_Vec4f aPosition (-aLight.Direction.x(),
1975                          -aLight.Direction.y(),
1976                          -aLight.Direction.z(),
1977                          0.0f);
1978
1979     if (aLight.Type != Visual3d_TOLS_DIRECTIONAL)
1980     {
1981       aPosition = BVH_Vec4f (aLight.Position.x(),
1982                              aLight.Position.y(),
1983                              aLight.Position.z(),
1984                              1.0f);
1985     }
1986
1987     if (aLight.IsHeadlight)
1988     {
1989       aPosition = theInvModelView * aPosition;
1990     }
1991
1992     myRaytraceGeometry.Sources.push_back (OpenGl_RaytraceLight (aDiffuse, aPosition));
1993   }
1994
1995   if (myRaytraceLightSrcTexture.IsNull())  // create light source buffer
1996   {
1997     myRaytraceLightSrcTexture = new OpenGl_TextureBufferArb;
1998
1999     if (!myRaytraceLightSrcTexture->Create (theGlContext))
2000     {
2001 #ifdef RAY_TRACE_PRINT_INFO
2002       std::cout << "Error: Failed to create light source buffer" << std::endl;
2003 #endif
2004       return Standard_False;
2005     }
2006   }
2007   
2008   if (myRaytraceGeometry.Sources.size() != 0)
2009   {
2010     const GLfloat* aDataPtr = myRaytraceGeometry.Sources.front().Packed();
2011     if (!myRaytraceLightSrcTexture->Init (theGlContext, 4, GLsizei (myRaytraceGeometry.Sources.size() * 2), aDataPtr))
2012     {
2013 #ifdef RAY_TRACE_PRINT_INFO
2014       std::cout << "Error: Failed to upload light source buffer" << std::endl;
2015 #endif
2016       return Standard_False;
2017     }
2018   }
2019
2020   return Standard_True;
2021 }
2022
2023 // =======================================================================
2024 // function : UpdateRaytraceEnvironmentMap
2025 // purpose  : Updates environment map for ray-tracing
2026 // =======================================================================
2027 Standard_Boolean OpenGl_View::updateRaytraceEnvironmentMap (const Handle(OpenGl_Context)& theGlContext)
2028 {
2029   Standard_Boolean aResult = Standard_True;
2030
2031   if (!myToUpdateEnvironmentMap)
2032   {
2033     return aResult;
2034   }
2035
2036   for (Standard_Integer anIdx = 0; anIdx < 2; ++anIdx)
2037   {
2038     const Handle(OpenGl_ShaderProgram)& aProgram =
2039       anIdx == 0 ? myRaytraceProgram : myPostFSAAProgram;
2040
2041     if (!aProgram.IsNull())
2042     {
2043       aResult &= theGlContext->BindProgram (aProgram);
2044
2045       if (!myTextureEnv.IsNull() && mySurfaceDetail != Visual3d_TOD_NONE)
2046       {
2047         myTextureEnv->Bind (theGlContext,
2048           GL_TEXTURE0 + OpenGl_RT_EnvironmentMapTexture);
2049
2050         aResult &= aProgram->SetUniform (theGlContext,
2051           myUniformLocations[anIdx][OpenGl_RT_uEnvMapEnable], 1);
2052       }
2053       else
2054       {
2055         aResult &= aProgram->SetUniform (theGlContext,
2056           myUniformLocations[anIdx][OpenGl_RT_uEnvMapEnable], 0);
2057       }
2058     }
2059   }
2060
2061   myToUpdateEnvironmentMap = Standard_False;
2062
2063   theGlContext->BindProgram (NULL);
2064
2065   return aResult;
2066 }
2067
2068 // =======================================================================
2069 // function : SetUniformState
2070 // purpose  : Sets uniform state for the given ray-tracing shader program
2071 // =======================================================================
2072 Standard_Boolean OpenGl_View::setUniformState (const Graphic3d_CView&        theCView,
2073                                                const OpenGl_Vec3*            theOrigins,
2074                                                const OpenGl_Vec3*            theDirects,
2075                                                const OpenGl_Mat4&            theUnviewMat,
2076                                                const Standard_Integer        theProgramId,
2077                                                const Handle(OpenGl_Context)& theGlContext)
2078 {
2079   Handle(OpenGl_ShaderProgram)& theProgram =
2080     theProgramId == 0 ? myRaytraceProgram : myPostFSAAProgram;
2081
2082   if (theProgram.IsNull())
2083   {
2084     return Standard_False;
2085   }
2086
2087   Standard_Boolean aResult = Standard_True;
2088
2089   const Standard_Integer aLightSourceBufferSize =
2090     static_cast<Standard_Integer> (myRaytraceGeometry.Sources.size());
2091
2092   // Set camera state
2093   aResult &= theProgram->SetUniform (theGlContext,
2094     myUniformLocations[theProgramId][OpenGl_RT_uOriginLB], theOrigins[0]);
2095   aResult &= theProgram->SetUniform (theGlContext,
2096     myUniformLocations[theProgramId][OpenGl_RT_uOriginRB], theOrigins[1]);
2097   aResult &= theProgram->SetUniform (theGlContext,
2098     myUniformLocations[theProgramId][OpenGl_RT_uOriginLT], theOrigins[2]);
2099   aResult &= theProgram->SetUniform (theGlContext,
2100     myUniformLocations[theProgramId][OpenGl_RT_uOriginRT], theOrigins[3]);
2101   aResult &= theProgram->SetUniform (theGlContext,
2102     myUniformLocations[theProgramId][OpenGl_RT_uDirectLB], theDirects[0]);
2103   aResult &= theProgram->SetUniform (theGlContext,
2104     myUniformLocations[theProgramId][OpenGl_RT_uDirectRB], theDirects[1]);
2105   aResult &= theProgram->SetUniform (theGlContext,
2106     myUniformLocations[theProgramId][OpenGl_RT_uDirectLT], theDirects[2]);
2107   aResult &= theProgram->SetUniform (theGlContext,
2108     myUniformLocations[theProgramId][OpenGl_RT_uDirectRT], theDirects[3]);
2109   aResult &= theProgram->SetUniform (theGlContext,
2110     myUniformLocations[theProgramId][OpenGl_RT_uUnviewMat], theUnviewMat);
2111
2112   // Set scene parameters
2113   aResult &= theProgram->SetUniform (theGlContext,
2114     myUniformLocations[theProgramId][OpenGl_RT_uSceneRad], myRaytraceSceneRadius);
2115   aResult &= theProgram->SetUniform (theGlContext,
2116     myUniformLocations[theProgramId][OpenGl_RT_uSceneEps], myRaytraceSceneEpsilon);
2117   aResult &= theProgram->SetUniform (theGlContext,
2118     myUniformLocations[theProgramId][OpenGl_RT_uLightCount], aLightSourceBufferSize);
2119   aResult &= theProgram->SetUniform (theGlContext,
2120     myUniformLocations[theProgramId][OpenGl_RT_uLightAmbnt], myRaytraceGeometry.Ambient);
2121
2122   // Set run-time rendering options
2123   aResult &= theProgram->SetUniform (theGlContext,
2124     myUniformLocations[theProgramId][OpenGl_RT_uShadEnabled], theCView.RenderParams.IsShadowEnabled ? 1 : 0);
2125   aResult &= theProgram->SetUniform (theGlContext,
2126     myUniformLocations[theProgramId][OpenGl_RT_uReflEnabled], theCView.RenderParams.IsReflectionEnabled ? 1 : 0);
2127
2128   // Set array of 64-bit texture handles
2129   if (theGlContext->arbTexBindless != NULL && myRaytraceGeometry.HasTextures())
2130   {
2131     aResult &= theProgram->SetUniform (theGlContext, "uTextureSamplers", static_cast<GLsizei> (
2132       myRaytraceGeometry.TextureHandles().size()), &myRaytraceGeometry.TextureHandles()[0]);
2133   }
2134
2135   if (!aResult)
2136   {
2137 #ifdef RAY_TRACE_PRINT_INFO
2138     std::cout << "Info: Not all uniforms were detected for program " << theProgramId << std::endl;
2139 #endif
2140   }
2141
2142   return aResult;
2143 }
2144
2145 // =======================================================================
2146 // function : BindRaytraceTextures
2147 // purpose  : Binds ray-trace textures to corresponding texture units
2148 // =======================================================================
2149 void OpenGl_View::bindRaytraceTextures (const Handle(OpenGl_Context)& theGlContext)
2150 {
2151   mySceneMinPointTexture->BindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMinPointTexture);
2152   mySceneMaxPointTexture->BindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMaxPointTexture);
2153   mySceneNodeInfoTexture->BindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneNodeInfoTexture);
2154   myGeometryVertexTexture->BindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryVertexTexture);
2155   myGeometryNormalTexture->BindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryNormalTexture);
2156   myGeometryTexCrdTexture->BindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryTexCrdTexture);
2157   myGeometryTriangTexture->BindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryTriangTexture);
2158   mySceneTransformTexture->BindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneTransformTexture);
2159   myRaytraceMaterialTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceMaterialTexture);
2160   myRaytraceLightSrcTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceLightSrcTexture);
2161
2162   if (!myOpenGlFBO.IsNull())
2163   {
2164     myOpenGlFBO->ColorTexture()->Bind        (theGlContext, GL_TEXTURE0 + OpenGl_RT_OpenGlColorTexture);
2165     myOpenGlFBO->DepthStencilTexture()->Bind (theGlContext, GL_TEXTURE0 + OpenGl_RT_OpenGlDepthTexture);
2166   }
2167 }
2168
2169 // =======================================================================
2170 // function : UnbindRaytraceTextures
2171 // purpose  : Unbinds ray-trace textures from corresponding texture units
2172 // =======================================================================
2173 void OpenGl_View::unbindRaytraceTextures (const Handle(OpenGl_Context)& theGlContext)
2174 {
2175   mySceneMinPointTexture->UnbindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMinPointTexture);
2176   mySceneMaxPointTexture->UnbindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMaxPointTexture);
2177   mySceneNodeInfoTexture->UnbindTexture    (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneNodeInfoTexture);
2178   myGeometryVertexTexture->UnbindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryVertexTexture);
2179   myGeometryNormalTexture->UnbindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryNormalTexture);
2180   myGeometryTexCrdTexture->UnbindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryTexCrdTexture);
2181   myGeometryTriangTexture->UnbindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryTriangTexture);
2182   mySceneTransformTexture->UnbindTexture   (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneTransformTexture);
2183   myRaytraceMaterialTexture->UnbindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceMaterialTexture);
2184   myRaytraceLightSrcTexture->UnbindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceLightSrcTexture);
2185
2186   if (!myOpenGlFBO.IsNull())
2187   {
2188     myOpenGlFBO->ColorTexture()->Unbind        (theGlContext, GL_TEXTURE0 + OpenGl_RT_OpenGlColorTexture);
2189     myOpenGlFBO->DepthStencilTexture()->Unbind (theGlContext, GL_TEXTURE0 + OpenGl_RT_OpenGlDepthTexture);
2190   }
2191
2192   theGlContext->core15fwd->glActiveTexture (GL_TEXTURE0);
2193 }
2194
2195 // =======================================================================
2196 // function : RunRaytraceShaders
2197 // purpose  : Runs ray-tracing shader programs
2198 // =======================================================================
2199 Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView&        theCView,
2200                                                   const Standard_Integer        theSizeX,
2201                                                   const Standard_Integer        theSizeY,
2202                                                   const OpenGl_Vec3*            theOrigins,
2203                                                   const OpenGl_Vec3*            theDirects,
2204                                                   const OpenGl_Mat4&            theUnviewMat,
2205                                                   OpenGl_FrameBuffer*           theOutputFBO,
2206                                                   const Handle(OpenGl_Context)& theGlContext)
2207 {
2208   bindRaytraceTextures (theGlContext);
2209
2210   if (theCView.RenderParams.IsAntialiasingEnabled) // render source image to FBO
2211   {
2212     myRaytraceFBO1->BindBuffer (theGlContext);
2213
2214     glDisable (GL_BLEND);
2215   }
2216
2217   Standard_Boolean aResult = theGlContext->BindProgram (myRaytraceProgram);
2218
2219   aResult &= setUniformState (theCView,
2220                               theOrigins,
2221                               theDirects,
2222                               theUnviewMat,
2223                               0, // ID of RT program
2224                               theGlContext);
2225
2226   myRaytraceScreenQuad.BindVertexAttrib (theGlContext, Graphic3d_TOA_POS);
2227   {
2228     if (aResult)
2229       theGlContext->core20fwd->glDrawArrays (GL_TRIANGLES, 0, 6);
2230   }
2231   myRaytraceScreenQuad.UnbindVertexAttrib (theGlContext, Graphic3d_TOA_POS);
2232
2233   if (!theCView.RenderParams.IsAntialiasingEnabled || !aResult)
2234   {
2235     unbindRaytraceTextures (theGlContext);
2236
2237     theGlContext->BindProgram (NULL);
2238
2239     return aResult;
2240   }
2241
2242   myRaytraceFBO1->ColorTexture()->Bind (theGlContext, GL_TEXTURE0 + OpenGl_RT_FSAAInputTexture);
2243
2244   aResult &= theGlContext->BindProgram (myPostFSAAProgram);
2245
2246   aResult &= setUniformState (theCView,
2247                               theOrigins,
2248                               theDirects,
2249                               theUnviewMat,
2250                               1, // ID of FSAA program
2251                               theGlContext);
2252
2253   myRaytraceScreenQuad.BindVertexAttrib (theGlContext, Graphic3d_TOA_POS);
2254   {
2255     // Perform multi-pass adaptive FSAA using ping-pong technique.
2256     // We use 'FLIPTRI' sampling pattern changing for every pixel
2257     // (3 additional samples per pixel, the 1st sample is already
2258     // available from initial ray-traced image).
2259     for (Standard_Integer anIt = 1; anIt < 4; ++anIt)
2260     {
2261       GLfloat aOffsetX = 1.f / theSizeX;
2262       GLfloat aOffsetY = 1.f / theSizeY;
2263
2264       if (anIt == 1)
2265       {
2266         aOffsetX *= -0.55f;
2267         aOffsetY *=  0.55f;
2268       }
2269       else if (anIt == 2)
2270       {
2271         aOffsetX *=  0.00f;
2272         aOffsetY *= -0.55f;
2273       }
2274       else if (anIt == 3)
2275       {
2276         aOffsetX *= 0.55f;
2277         aOffsetY *= 0.00f;
2278       }
2279
2280       aResult &= myPostFSAAProgram->SetUniform (theGlContext,
2281         myUniformLocations[1][OpenGl_RT_uSamples], anIt + 1);
2282       aResult &= myPostFSAAProgram->SetUniform (theGlContext,
2283         myUniformLocations[1][OpenGl_RT_uOffsetX], aOffsetX);
2284       aResult &= myPostFSAAProgram->SetUniform (theGlContext,
2285         myUniformLocations[1][OpenGl_RT_uOffsetY], aOffsetY);
2286
2287       Handle(OpenGl_FrameBuffer)& aFramebuffer = anIt % 2 ? myRaytraceFBO2 : myRaytraceFBO1;
2288
2289       if (anIt == 3) // disable FBO on last iteration
2290       {
2291         glEnable (GL_BLEND);
2292
2293         if (theOutputFBO != NULL)
2294           theOutputFBO->BindBuffer (theGlContext);
2295       }
2296       else
2297       {
2298         aFramebuffer->BindBuffer (theGlContext);
2299       }
2300
2301       theGlContext->core20fwd->glDrawArrays (GL_TRIANGLES, 0, 6);
2302
2303       if (anIt != 3) // set input for the next pass
2304       {
2305         aFramebuffer->ColorTexture()->Bind (theGlContext, GL_TEXTURE0 + OpenGl_RT_FSAAInputTexture);
2306       }
2307     }
2308   }
2309   myRaytraceScreenQuad.UnbindVertexAttrib (theGlContext, Graphic3d_TOA_POS);
2310
2311   unbindRaytraceTextures (theGlContext);
2312
2313   theGlContext->BindProgram (NULL);
2314
2315   return aResult;
2316 }
2317
2318 // =======================================================================
2319 // function : Raytrace
2320 // purpose  : Redraws the window using OpenGL/GLSL ray-tracing
2321 // =======================================================================
2322 Standard_Boolean OpenGl_View::raytrace (const Graphic3d_CView&        theCView,
2323                                         const Standard_Integer        theSizeX,
2324                                         const Standard_Integer        theSizeY,
2325                                         OpenGl_FrameBuffer*           theOutputFBO,
2326                                         const Handle(OpenGl_Context)& theGlContext)
2327 {
2328   if (!initRaytraceResources (theCView, theGlContext))
2329   {
2330     return Standard_False;
2331   }
2332
2333   if (!resizeRaytraceBuffers (theSizeX, theSizeY, theGlContext))
2334   {
2335     return Standard_False;
2336   }
2337
2338   if (!updateRaytraceEnvironmentMap (theGlContext))
2339   {
2340     return Standard_False;
2341   }
2342
2343   // Get model-view and projection matrices
2344   OpenGl_Mat4 aOrientationMatrix;
2345   OpenGl_Mat4 aViewMappingMatrix;
2346   OpenGl_Mat4 aInverOrientMatrix;
2347
2348   GetMatrices (aOrientationMatrix,
2349                aViewMappingMatrix);
2350
2351   aOrientationMatrix.Inverted (aInverOrientMatrix);
2352
2353   if (!updateRaytraceLightSources (aInverOrientMatrix, theGlContext))
2354   {
2355     return Standard_False;
2356   }
2357
2358   OpenGl_Vec3 aOrigins[4];
2359   OpenGl_Vec3 aDirects[4];
2360   OpenGl_Mat4 anUnviewMat;
2361
2362   updateCamera (aOrientationMatrix,
2363                 aViewMappingMatrix,
2364                 aOrigins,
2365                 aDirects,
2366                 anUnviewMat);
2367
2368   glEnable (GL_BLEND);
2369   glDisable (GL_DEPTH_TEST);
2370   glBlendFunc (GL_ONE, GL_SRC_ALPHA);
2371
2372   if (theOutputFBO != NULL)
2373   {
2374     theOutputFBO->BindBuffer (theGlContext);
2375   }
2376
2377   // Generate ray-traced image
2378   if (myIsRaytraceDataValid)
2379   {
2380     myRaytraceScreenQuad.Bind (theGlContext);
2381
2382     if (!myRaytraceGeometry.AcquireTextures (theGlContext))
2383     {
2384       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_ERROR_ARB,
2385         0, GL_DEBUG_SEVERITY_MEDIUM_ARB, "Error: Failed to acquire OpenGL image textures");
2386     }
2387
2388     Standard_Boolean aResult = runRaytraceShaders (theCView,
2389                                                    theSizeX,
2390                                                    theSizeY,
2391                                                    aOrigins,
2392                                                    aDirects,
2393                                                    anUnviewMat,
2394                                                    theOutputFBO,
2395                                                    theGlContext);
2396
2397     if (!aResult)
2398     {
2399       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_ERROR_ARB,
2400         0, GL_DEBUG_SEVERITY_MEDIUM_ARB, "Error: Failed to execute ray-tracing shaders");
2401     }
2402
2403     if (!myRaytraceGeometry.ReleaseTextures (theGlContext))
2404     {
2405       theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_ERROR_ARB,
2406         0, GL_DEBUG_SEVERITY_MEDIUM_ARB, "Error: Failed to release OpenGL image textures");
2407     }
2408
2409     myRaytraceScreenQuad.Unbind (theGlContext);
2410   }
2411
2412   glDisable (GL_BLEND);
2413   glEnable (GL_DEPTH_TEST);
2414
2415   return Standard_True;
2416 }