0024739: TKOpenGl - port ray-tracing from OpenCL to GLSL for better integration and...
[occt.git] / src / OpenGl / OpenGl_Workspace_Raytrace.cxx
1 // Created on: 2013-08-27
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <NCollection_Mat4.hxx>
17 #include <OpenGl_ArbFBO.hxx>
18 #include <OpenGl_FrameBuffer.hxx>
19 #include <OpenGl_Texture.hxx>
20 #include <OpenGl_VertexBuffer.hxx>
21 #include <OpenGl_View.hxx>
22 #include <OpenGl_Workspace.hxx>
23 #include <OSD_File.hxx>
24 #include <OSD_Protection.hxx>
25 #include <Standard_Assert.hxx>
26
27 using namespace OpenGl_Raytrace;
28
29 //! Use this macro to output ray-tracing debug info
30 // #define RAY_TRACE_PRINT_INFO
31
32 #ifdef RAY_TRACE_PRINT_INFO
33   #include <OSD_Timer.hxx>
34 #endif
35
36 // =======================================================================
37 // function : MatVecMult
38 // purpose  : Multiples 4x4 matrix by 4D vector
39 // =======================================================================
40 template<typename T>
41 BVH_Vec4f MatVecMult (const T m[16], const BVH_Vec4f& v)
42 {
43   return BVH_Vec4f (
44     static_cast<float> (m[ 0] * v.x() + m[ 4] * v.y() +
45                         m[ 8] * v.z() + m[12] * v.w()),
46     static_cast<float> (m[ 1] * v.x() + m[ 5] * v.y() +
47                         m[ 9] * v.z() + m[13] * v.w()),
48     static_cast<float> (m[ 2] * v.x() + m[ 6] * v.y() +
49                         m[10] * v.z() + m[14] * v.w()),
50     static_cast<float> (m[ 3] * v.x() + m[ 7] * v.y() +
51                         m[11] * v.z() + m[15] * v.w()));
52 }
53
54 // =======================================================================
55 // function : UpdateRaytraceGeometry
56 // purpose  : Updates 3D scene geometry for ray tracing
57 // =======================================================================
58 Standard_Boolean OpenGl_Workspace::UpdateRaytraceGeometry (Standard_Boolean theCheck)
59 {
60   if (myView.IsNull())
61     return Standard_False;
62
63   // Note: In 'check' mode the scene geometry is analyzed for modifications
64   // This is light-weight procedure performed for each frame
65
66   if (!theCheck)
67   {
68     myRaytraceGeometry.Clear();
69
70     myIsRaytraceDataValid = Standard_False;
71   }
72   else
73   {
74     if (myLayersModificationStatus != myView->LayerList().ModificationState())
75     {
76       return UpdateRaytraceGeometry (Standard_False);
77     }
78   }
79
80   Standard_ShortReal* aTransform (NULL);
81
82   // The set of processed structures (reflected to ray-tracing)
83   // This set is used to remove out-of-date records from the
84   // hash map of structures
85   std::set<const OpenGl_Structure*> anElements;
86
87   const OpenGl_LayerList& aList = myView->LayerList();
88
89   for (OpenGl_SequenceOfLayers::Iterator anLayerIt (aList.Layers()); anLayerIt.More(); anLayerIt.Next())
90   {
91     const OpenGl_PriorityList& aPriorityList = anLayerIt.Value();
92
93     if (aPriorityList.NbStructures() == 0)
94       continue;
95
96     const OpenGl_ArrayOfStructure& aStructArray = aPriorityList.ArrayOfStructures();
97
98     for (Standard_Integer anIndex = 0; anIndex < aStructArray.Length(); ++anIndex)
99     {
100       OpenGl_SequenceOfStructure::Iterator aStructIt;
101
102       for (aStructIt.Init (aStructArray (anIndex)); aStructIt.More(); aStructIt.Next())
103       {
104         const OpenGl_Structure* aStructure = aStructIt.Value();
105
106         if (theCheck)
107         {
108           if (CheckRaytraceStructure (aStructure))
109           {
110             return UpdateRaytraceGeometry (Standard_False);
111           }
112         }
113         else
114         {
115           if (!aStructure->IsRaytracable())
116             continue;
117
118           if (aStructure->Transformation()->mat != NULL)
119           {
120             if (aTransform == NULL)
121               aTransform = new Standard_ShortReal[16];
122
123             for (Standard_Integer i = 0; i < 4; ++i)
124               for (Standard_Integer j = 0; j < 4; ++j)
125               {
126                 aTransform[j * 4 + i] = aStructure->Transformation()->mat[i][j];
127               }
128           }
129
130           AddRaytraceStructure (aStructure, aTransform, anElements);
131         }
132       }
133     }
134   }
135
136   if (!theCheck)
137   {
138     // Actualize the hash map of structures -- remove out-of-date records
139     std::map<const OpenGl_Structure*, Standard_Size>::iterator anIter = myStructureStates.begin();
140
141     while (anIter != myStructureStates.end())
142     {
143       if (anElements.find (anIter->first) == anElements.end())
144       {
145         myStructureStates.erase (anIter++);
146       }
147       else
148       {
149         ++anIter;
150       }
151     }
152
153     // Actualize OpenGL layer list state
154     myLayersModificationStatus = myView->LayerList().ModificationState();
155
156     // Rebuild bottom-level and high-level BVHs
157     myRaytraceGeometry.ProcessAcceleration();
158
159     const Standard_ShortReal aMinRadius = Max (fabs (myRaytraceGeometry.Box().CornerMin().x()), Max (
160       fabs (myRaytraceGeometry.Box().CornerMin().y()), fabs (myRaytraceGeometry.Box().CornerMin().z())));
161     const Standard_ShortReal aMaxRadius = Max (fabs (myRaytraceGeometry.Box().CornerMax().x()), Max (
162       fabs (myRaytraceGeometry.Box().CornerMax().y()), fabs (myRaytraceGeometry.Box().CornerMax().z())));
163
164     myRaytraceSceneRadius = 2.f /* scale factor */ * Max (aMinRadius, aMaxRadius);
165
166     const BVH_Vec4f aSize = myRaytraceGeometry.Box().Size();
167
168     myRaytraceSceneEpsilon = Max (1e-4f, 1e-4f * sqrtf (
169       aSize.x() * aSize.x() + aSize.y() * aSize.y() + aSize.z() * aSize.z()));
170
171     return UploadRaytraceData();
172   }
173
174   delete [] aTransform;
175
176   return Standard_True;
177 }
178
179 // =======================================================================
180 // function : CheckRaytraceStructure
181 // purpose  :  Checks to see if the structure is modified
182 // =======================================================================
183 Standard_Boolean OpenGl_Workspace::CheckRaytraceStructure (const OpenGl_Structure* theStructure)
184 {
185   if (!theStructure->IsRaytracable())
186   {
187     // Checks to see if all ray-tracable elements were
188     // removed from the structure
189     if (theStructure->ModificationState() > 0)
190     {
191       theStructure->ResetModificationState();
192       return Standard_True;
193     }
194
195     return Standard_False;
196   }
197
198   std::map<const OpenGl_Structure*, Standard_Size>::iterator aStructState = myStructureStates.find (theStructure);
199
200   if (aStructState != myStructureStates.end())
201     return aStructState->second != theStructure->ModificationState();
202
203   return Standard_True;
204 }
205
206 // =======================================================================
207 // function : CreateMaterial
208 // purpose  : Creates ray-tracing material properties
209 // =======================================================================
210 void CreateMaterial (const OPENGL_SURF_PROP& theProp, OpenGl_RaytraceMaterial& theMaterial)
211 {
212   const float* aSrcAmb = theProp.isphysic ? theProp.ambcol.rgb : theProp.matcol.rgb;
213   theMaterial.Ambient = BVH_Vec4f (aSrcAmb[0] * theProp.amb,
214                                    aSrcAmb[1] * theProp.amb,
215                                    aSrcAmb[2] * theProp.amb,
216                                    1.0f);
217
218   const float* aSrcDif = theProp.isphysic ? theProp.difcol.rgb : theProp.matcol.rgb;
219   theMaterial.Diffuse = BVH_Vec4f (aSrcDif[0] * theProp.diff,
220                                    aSrcDif[1] * theProp.diff,
221                                    aSrcDif[2] * theProp.diff,
222                                    1.0f);
223
224   const float aDefSpecCol[4] = {1.0f, 1.0f, 1.0f, 1.0f};
225   const float* aSrcSpe = theProp.isphysic ? theProp.speccol.rgb : aDefSpecCol;
226   theMaterial.Specular = BVH_Vec4f (aSrcSpe[0] * theProp.spec,
227                                     aSrcSpe[1] * theProp.spec,
228                                     aSrcSpe[2] * theProp.spec,
229                                     theProp.shine);
230
231   const float* aSrcEms = theProp.isphysic ? theProp.emscol.rgb : theProp.matcol.rgb;
232   theMaterial.Emission = BVH_Vec4f (aSrcEms[0] * theProp.emsv,
233                                     aSrcEms[1] * theProp.emsv,
234                                     aSrcEms[2] * theProp.emsv,
235                                     1.0f);
236
237   // Note: Here we use sub-linear transparency function
238   // to produce realistic-looking transparency effect
239   theMaterial.Transparency = BVH_Vec4f (powf (theProp.trans, 0.75f),
240                                         1.f - theProp.trans,
241                                         1.f,
242                                         1.f);
243
244   const float aMaxRefl = Max (theMaterial.Diffuse.x() + theMaterial.Specular.x(),
245                          Max (theMaterial.Diffuse.y() + theMaterial.Specular.y(),
246                               theMaterial.Diffuse.z() + theMaterial.Specular.z()));
247
248   const float aReflectionScale = 0.75f / aMaxRefl;
249
250   theMaterial.Reflection = BVH_Vec4f (theProp.speccol.rgb[0] * theProp.spec * aReflectionScale,
251                                       theProp.speccol.rgb[1] * theProp.spec * aReflectionScale,
252                                       theProp.speccol.rgb[2] * theProp.spec * aReflectionScale,
253                                       0.f);
254 }
255
256 // =======================================================================
257 // function : AddRaytraceStructure
258 // purpose  : Adds OpenGL structure to ray-traced scene geometry
259 // =======================================================================
260 Standard_Boolean OpenGl_Workspace::AddRaytraceStructure (const OpenGl_Structure* theStructure,
261   const Standard_ShortReal* theTransform, std::set<const OpenGl_Structure*>& theElements)
262 {
263   theElements.insert (theStructure);
264
265   if (!theStructure->IsVisible())
266   {
267     myStructureStates[theStructure] = theStructure->ModificationState();
268     return Standard_True;
269   }
270
271   // Get structure material
272   Standard_Integer aStructMatID = -1;
273
274   if (theStructure->AspectFace() != NULL)
275   {
276     aStructMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
277
278     OpenGl_RaytraceMaterial aStructMaterial;
279     CreateMaterial (theStructure->AspectFace()->IntFront(), aStructMaterial);
280
281     myRaytraceGeometry.Materials.push_back (aStructMaterial);
282   }
283
284   for (OpenGl_Structure::GroupIterator aGroupIter (theStructure->DrawGroups()); aGroupIter.More(); aGroupIter.Next())
285   {
286     // Get group material
287     Standard_Integer aGroupMatID = -1;
288     if (aGroupIter.Value()->AspectFace() != NULL)
289     {
290       aGroupMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
291
292       OpenGl_RaytraceMaterial aGroupMaterial;
293       CreateMaterial (aGroupIter.Value()->AspectFace()->IntFront(), aGroupMaterial);
294
295       myRaytraceGeometry.Materials.push_back (aGroupMaterial);
296     }
297
298     Standard_Integer aMatID = aGroupMatID < 0 ? aStructMatID : aGroupMatID;
299
300     if (aMatID < 0)
301     {
302       aMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
303
304       myRaytraceGeometry.Materials.push_back (OpenGl_RaytraceMaterial());
305     }
306
307     // Add OpenGL elements from group (extract primitives arrays and aspects)
308     for (const OpenGl_ElementNode* aNode = aGroupIter.Value()->FirstNode(); aNode != NULL; aNode = aNode->next)
309     {
310       OpenGl_AspectFace* anAspect = dynamic_cast<OpenGl_AspectFace*> (aNode->elem);
311       if (anAspect != NULL)
312       {
313         aMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
314
315         OpenGl_RaytraceMaterial aMaterial;
316         CreateMaterial (anAspect->IntFront(), aMaterial);
317
318         myRaytraceGeometry.Materials.push_back (aMaterial);
319       }
320       else
321       {
322         OpenGl_PrimitiveArray* aPrimArray = dynamic_cast<OpenGl_PrimitiveArray*> (aNode->elem);
323         if (aPrimArray != NULL)
324         {
325           NCollection_Handle<BVH_Object<Standard_ShortReal, 4> > aSet =
326             AddRaytracePrimitiveArray (aPrimArray->PArray(), aMatID, theTransform);
327
328           if (!aSet.IsNull())
329             myRaytraceGeometry.Objects().Append (aSet);
330         }
331       }
332     }
333   }
334
335   Standard_ShortReal* aTransform (NULL);
336
337   // Process all connected OpenGL structures
338   for (OpenGl_ListOfStructure::Iterator anIts (theStructure->ConnectedStructures()); anIts.More(); anIts.Next())
339   {
340     if (anIts.Value()->Transformation()->mat != NULL)
341     {
342       Standard_ShortReal* aTransform = new Standard_ShortReal[16];
343
344       for (Standard_Integer i = 0; i < 4; ++i)
345         for (Standard_Integer j = 0; j < 4; ++j)
346         {
347           aTransform[j * 4 + i] =
348             anIts.Value()->Transformation()->mat[i][j];
349         }
350     }
351
352     if (anIts.Value()->IsRaytracable())
353       AddRaytraceStructure (anIts.Value(), aTransform != NULL ? aTransform : theTransform, theElements);
354   }
355
356   delete[] aTransform;
357
358   myStructureStates[theStructure] = theStructure->ModificationState();
359
360   return Standard_True;
361 }
362
363 // =======================================================================
364 // function : AddRaytracePrimitiveArray
365 // purpose  : Adds OpenGL primitive array to ray-traced scene geometry
366 // =======================================================================
367 OpenGl_TriangleSet* OpenGl_Workspace::AddRaytracePrimitiveArray (
368   const CALL_DEF_PARRAY* theArray, Standard_Integer theMatID, const Standard_ShortReal* theTransform)
369 {
370   if (theArray->type != TelPolygonsArrayType &&
371       theArray->type != TelTrianglesArrayType &&
372       theArray->type != TelQuadranglesArrayType &&
373       theArray->type != TelTriangleFansArrayType &&
374       theArray->type != TelTriangleStripsArrayType &&
375       theArray->type != TelQuadrangleStripsArrayType)
376   {
377     return NULL;
378   }
379
380   if (theArray->vertices == NULL)
381     return NULL;
382
383 #ifdef RAY_TRACE_PRINT_INFO
384   switch (theArray->type)
385   {
386     case TelPolygonsArrayType:
387       std::cout << "\tAdding TelPolygonsArrayType" << std::endl; break;
388     case TelTrianglesArrayType:
389       std::cout << "\tAdding TelTrianglesArrayType" << std::endl; break;
390     case TelQuadranglesArrayType:
391       std::cout << "\tAdding TelQuadranglesArrayType" << std::endl; break;
392     case TelTriangleFansArrayType:
393       std::cout << "\tAdding TelTriangleFansArrayType" << std::endl; break;
394     case TelTriangleStripsArrayType:
395       std::cout << "\tAdding TelTriangleStripsArrayType" << std::endl; break;
396     case TelQuadrangleStripsArrayType:
397       std::cout << "\tAdding TelQuadrangleStripsArrayType" << std::endl; break;
398   }
399 #endif
400
401   OpenGl_TriangleSet* aSet = new OpenGl_TriangleSet;
402
403   {
404     aSet->Vertices.reserve (theArray->num_vertexs);
405
406     for (Standard_Integer aVert = 0; aVert < theArray->num_vertexs; ++aVert)
407     {
408       BVH_Vec4f aVertex (theArray->vertices[aVert].xyz[0],
409                          theArray->vertices[aVert].xyz[1],
410                          theArray->vertices[aVert].xyz[2],
411                          1.f);
412       if (theTransform)
413         aVertex = MatVecMult (theTransform, aVertex);
414
415       aSet->Vertices.push_back (aVertex);
416     }
417
418     aSet->Normals.reserve (theArray->num_vertexs);
419
420     for (Standard_Integer aNorm = 0; aNorm < theArray->num_vertexs; ++aNorm)
421     {
422       BVH_Vec4f aNormal;
423
424       // Note: In case of absence of normals, the
425       // renderer uses generated geometric normals
426
427       if (theArray->vnormals != NULL)
428       {
429         aNormal = BVH_Vec4f (theArray->vnormals[aNorm].xyz[0],
430                              theArray->vnormals[aNorm].xyz[1],
431                              theArray->vnormals[aNorm].xyz[2],
432                              0.f);
433
434         if (theTransform)
435           aNormal = MatVecMult (theTransform, aNormal);
436       }
437
438       aSet->Normals.push_back (aNormal);
439     }
440
441     if (theArray->num_bounds > 0)
442     {
443   #ifdef RAY_TRACE_PRINT_INFO
444       std::cout << "\tNumber of bounds = " << theArray->num_bounds << std::endl;
445   #endif
446
447       Standard_Integer aBoundStart = 0;
448
449       for (Standard_Integer aBound = 0; aBound < theArray->num_bounds; ++aBound)
450       {
451         const Standard_Integer aVertNum = theArray->bounds[aBound];
452
453   #ifdef RAY_TRACE_PRINT_INFO
454         std::cout << "\tAdding indices from bound " << aBound << ": " <<
455                                       aBoundStart << " .. " << aVertNum << std::endl;
456   #endif
457
458         if (!AddRaytraceVertexIndices (aSet, theArray, aBoundStart, aVertNum, theMatID))
459         {
460           delete aSet;
461           return NULL;
462         }
463
464         aBoundStart += aVertNum;
465       }
466     }
467     else
468     {
469       const Standard_Integer aVertNum = theArray->num_edges > 0 ? theArray->num_edges : theArray->num_vertexs;
470
471   #ifdef RAY_TRACE_PRINT_INFO
472         std::cout << "\tAdding indices from array: " << aVertNum << std::endl;
473   #endif
474
475       if (!AddRaytraceVertexIndices (aSet, theArray, 0, aVertNum, theMatID))
476       {
477         delete aSet;
478         return NULL;
479       }
480     }
481   }
482
483   if (aSet->Size() != 0)
484     aSet->MarkDirty();
485
486   return aSet;
487 }
488
489 // =======================================================================
490 // function : AddRaytraceVertexIndices
491 // purpose  : Adds vertex indices to ray-traced scene geometry
492 // =======================================================================
493 Standard_Boolean OpenGl_Workspace::AddRaytraceVertexIndices (OpenGl_TriangleSet* theSet,
494   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
495 {
496   switch (theArray->type)
497   {
498     case TelTrianglesArrayType:
499       return AddRaytraceTriangleArray (theSet, theArray, theOffset, theCount, theMatID);
500
501     case TelQuadranglesArrayType:
502       return AddRaytraceQuadrangleArray (theSet, theArray, theOffset, theCount, theMatID);
503
504     case TelTriangleFansArrayType:
505       return AddRaytraceTriangleFanArray (theSet, theArray, theOffset, theCount, theMatID);
506
507     case TelTriangleStripsArrayType:
508       return AddRaytraceTriangleStripArray (theSet, theArray, theOffset, theCount, theMatID);
509
510     case TelQuadrangleStripsArrayType:
511       return AddRaytraceQuadrangleStripArray (theSet, theArray, theOffset, theCount, theMatID);
512
513     default:
514       return AddRaytracePolygonArray (theSet, theArray, theOffset, theCount, theMatID);
515   }
516 }
517
518 // =======================================================================
519 // function : AddRaytraceTriangleArray
520 // purpose  : Adds OpenGL triangle array to ray-traced scene geometry
521 // =======================================================================
522 Standard_Boolean OpenGl_Workspace::AddRaytraceTriangleArray (OpenGl_TriangleSet* theSet,
523   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
524 {
525   if (theCount < 3)
526     return Standard_True;
527
528   theSet->Elements.reserve (theSet->Elements.size() + theCount / 3);
529
530   if (theArray->num_edges > 0)
531   {
532     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; aVert += 3)
533     {
534       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + 0],
535                                              theArray->edges[aVert + 1],
536                                              theArray->edges[aVert + 2],
537                                              theMatID));
538     }
539   }
540   else
541   {
542     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; aVert += 3)
543     {
544       theSet->Elements.push_back (BVH_Vec4i (aVert + 0,
545                                              aVert + 1,
546                                              aVert + 2,
547                                              theMatID));
548     }
549   }
550
551   return Standard_True;
552 }
553
554 // =======================================================================
555 // function : AddRaytraceTriangleFanArray
556 // purpose  : Adds OpenGL triangle fan array to ray-traced scene geometry
557 // =======================================================================
558 Standard_Boolean OpenGl_Workspace::AddRaytraceTriangleFanArray (OpenGl_TriangleSet* theSet,
559   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
560 {
561   if (theCount < 3)
562     return Standard_True;
563
564   theSet->Elements.reserve (theSet->Elements.size() + theCount - 2);
565
566   if (theArray->num_edges > 0)
567   {
568     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
569     {
570       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[theOffset],
571                                              theArray->edges[aVert + 1],
572                                              theArray->edges[aVert + 2],
573                                              theMatID));
574     }
575   }
576   else
577   {
578     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
579     {
580       theSet->Elements.push_back (BVH_Vec4i (theOffset,
581                                              aVert + 1,
582                                              aVert + 2,
583                                              theMatID));
584     }
585   }
586
587   return Standard_True;
588 }
589
590 // =======================================================================
591 // function : AddRaytraceTriangleStripArray
592 // purpose  : Adds OpenGL triangle strip array to ray-traced scene geometry
593 // =======================================================================
594 Standard_Boolean OpenGl_Workspace::AddRaytraceTriangleStripArray (OpenGl_TriangleSet* theSet,
595   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
596 {
597   if (theCount < 3)
598     return Standard_True;
599
600   theSet->Elements.reserve (theSet->Elements.size() + theCount - 2);
601
602   if (theArray->num_edges > 0)
603   {
604     for (Standard_Integer aVert = theOffset, aCW = 0; aVert < theOffset + theCount - 2; ++aVert, aCW = (aCW + 1) % 2)
605     {
606       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + aCW ? 1 : 0],
607                                              theArray->edges[aVert + aCW ? 0 : 1],
608                                              theArray->edges[aVert + 2],
609                                              theMatID));
610     }
611   }
612   else
613   {
614     for (Standard_Integer aVert = theOffset, aCW = 0; aVert < theOffset + theCount - 2; ++aVert, aCW = (aCW + 1) % 2)
615     {
616       theSet->Elements.push_back (BVH_Vec4i (aVert + aCW ? 1 : 0,
617                                              aVert + aCW ? 0 : 1,
618                                              aVert + 2,
619                                              theMatID));
620     }
621   }
622
623   return Standard_True;
624 }
625
626 // =======================================================================
627 // function : AddRaytraceQuadrangleArray
628 // purpose  : Adds OpenGL quad array to ray-traced scene geometry
629 // =======================================================================
630 Standard_Boolean OpenGl_Workspace::AddRaytraceQuadrangleArray (OpenGl_TriangleSet* theSet,
631   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
632 {
633   if (theCount < 4)
634     return Standard_True;
635
636   theSet->Elements.reserve (theSet->Elements.size() + theCount / 2);
637
638   if (theArray->num_edges > 0)
639   {
640     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 4)
641     {
642       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + 0],
643                                              theArray->edges[aVert + 1],
644                                              theArray->edges[aVert + 2],
645                                              theMatID));
646
647       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + 0],
648                                              theArray->edges[aVert + 2],
649                                              theArray->edges[aVert + 3],
650                                              theMatID));
651     }
652   }
653   else
654   {
655     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 4)
656     {
657       theSet->Elements.push_back (BVH_Vec4i (aVert + 0,
658                                              aVert + 1,
659                                              aVert + 2,
660                                              theMatID));
661
662       theSet->Elements.push_back (BVH_Vec4i (aVert + 0,
663                                              aVert + 2,
664                                              aVert + 3,
665                                              theMatID));
666     }
667   }
668
669   return Standard_True;
670 }
671
672 // =======================================================================
673 // function : AddRaytraceQuadrangleStripArray
674 // purpose  : Adds OpenGL quad strip array to ray-traced scene geometry
675 // =======================================================================
676 Standard_Boolean OpenGl_Workspace::AddRaytraceQuadrangleStripArray (OpenGl_TriangleSet* theSet,
677   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
678 {
679   if (theCount < 4)
680     return Standard_True;
681
682   theSet->Elements.reserve (theSet->Elements.size() + 2 * theCount - 6);
683
684   if (theArray->num_edges > 0)
685   {
686     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 2)
687     {
688       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + 0],
689                                              theArray->edges[aVert + 1],
690                                              theArray->edges[aVert + 2],
691                                              theMatID));
692
693       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[aVert + 1],
694                                              theArray->edges[aVert + 3],
695                                              theArray->edges[aVert + 2],
696                                              theMatID));
697     }
698   }
699   else
700   {
701     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 3; aVert += 2)
702     {
703       theSet->Elements.push_back (BVH_Vec4i (aVert + 0,
704                                              aVert + 1,
705                                              aVert + 2,
706                                              theMatID));
707
708       theSet->Elements.push_back (BVH_Vec4i (aVert + 1,
709                                              aVert + 3,
710                                              aVert + 2,
711                                              theMatID));
712     }
713   }
714
715   return Standard_True;
716 }
717
718 // =======================================================================
719 // function : AddRaytracePolygonArray
720 // purpose  : Adds OpenGL polygon array to ray-traced scene geometry
721 // =======================================================================
722 Standard_Boolean OpenGl_Workspace::AddRaytracePolygonArray (OpenGl_TriangleSet* theSet,
723   const CALL_DEF_PARRAY* theArray, Standard_Integer theOffset, Standard_Integer theCount, Standard_Integer theMatID)
724 {
725   if (theCount < 3)
726     return Standard_True;
727
728   theSet->Elements.reserve (theSet->Elements.size() + theCount - 2);
729
730   if (theArray->num_edges > 0)
731   {
732     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
733     {
734       theSet->Elements.push_back (BVH_Vec4i (theArray->edges[theOffset],
735                                              theArray->edges[aVert + 1],
736                                              theArray->edges[aVert + 2],
737                                              theMatID));
738     }
739   }
740   else
741   {
742     for (Standard_Integer aVert = theOffset; aVert < theOffset + theCount - 2; ++aVert)
743     {
744       theSet->Elements.push_back (BVH_Vec4i (theOffset,
745                                              aVert + 1,
746                                              aVert + 2,
747                                              theMatID));
748     }
749   }
750
751   return Standard_True;
752 }
753
754 // =======================================================================
755 // function : UpdateRaytraceLightSources
756 // purpose  : Updates 3D scene light sources for ray-tracing
757 // =======================================================================
758 Standard_Boolean OpenGl_Workspace::UpdateRaytraceLightSources (const GLdouble theInvModelView[16])
759 {
760   myRaytraceGeometry.Sources.clear();
761
762   myRaytraceGeometry.Ambient = BVH_Vec4f (0.0f, 0.0f, 0.0f, 0.0f);
763
764   for (OpenGl_ListOfLight::Iterator anItl (myView->LightList()); anItl.More(); anItl.Next())
765   {
766     const OpenGl_Light& aLight = anItl.Value();
767
768     if (aLight.Type == Visual3d_TOLS_AMBIENT)
769     {
770       myRaytraceGeometry.Ambient += BVH_Vec4f (aLight.Color.r(),
771                                                aLight.Color.g(),
772                                                aLight.Color.b(),
773                                                0.0f);
774       continue;
775     }
776
777     BVH_Vec4f aDiffuse  (aLight.Color.r(),
778                          aLight.Color.g(),
779                          aLight.Color.b(),
780                          1.0f);
781
782     BVH_Vec4f aPosition (-aLight.Direction.x(),
783                          -aLight.Direction.y(),
784                          -aLight.Direction.z(),
785                          0.0f);
786
787     if (aLight.Type != Visual3d_TOLS_DIRECTIONAL)
788     {
789       aPosition = BVH_Vec4f (aLight.Position.x(),
790                              aLight.Position.y(),
791                              aLight.Position.z(),
792                              1.0f);
793     }
794
795     if (aLight.IsHeadlight)
796       aPosition = MatVecMult (theInvModelView, aPosition);
797
798     
799     myRaytraceGeometry.Sources.push_back (OpenGl_RaytraceLight (aDiffuse, aPosition));
800   }
801
802   if (myRaytraceLightSrcTexture.IsNull())  // create light source buffer
803   {
804     myRaytraceLightSrcTexture = new OpenGl_TextureBufferArb;
805
806     if (!myRaytraceLightSrcTexture->Create (myGlContext))
807     {
808 #ifdef RAY_TRACE_PRINT_INFO
809       std::cout << "Error: Failed to create light source buffer" << std::endl;
810 #endif
811       return Standard_False;
812     }
813   }
814   
815   if (myRaytraceGeometry.Sources.size() != 0)
816   {
817     const GLfloat* aDataPtr = myRaytraceGeometry.Sources.front().Packed();
818
819     bool aResult = myRaytraceLightSrcTexture->Init (
820       myGlContext, 4, myRaytraceGeometry.Sources.size() * 2, aDataPtr);
821
822     if (!aResult)
823     {
824 #ifdef RAY_TRACE_PRINT_INFO
825       std::cout << "Error: Failed to upload light source buffer" << std::endl;
826 #endif
827       return Standard_False;
828     }
829   }
830
831   return Standard_True;
832 }
833
834 // =======================================================================
835 // function : UpdateRaytraceEnvironmentMap
836 // purpose  : Updates environment map for ray-tracing
837 // =======================================================================
838 Standard_Boolean OpenGl_Workspace::UpdateRaytraceEnvironmentMap()
839 {
840   if (myView.IsNull())
841     return Standard_False;
842
843   if (myViewModificationStatus == myView->ModificationState())
844     return Standard_True;
845
846   for (Standard_Integer anIdx = 0; anIdx < 2; ++anIdx)
847   {
848     const Handle(OpenGl_ShaderProgram)& aProgram =
849       anIdx == 0 ? myRaytraceProgram : myPostFSAAProgram;
850
851     if (!aProgram.IsNull())
852     {
853       aProgram->Bind (myGlContext);
854
855       if (!myView->TextureEnv().IsNull() && myView->SurfaceDetail() != Visual3d_TOD_NONE)
856       {
857         myView->TextureEnv()->Bind (
858           myGlContext, GL_TEXTURE0 + OpenGl_RT_EnvironmentMapTexture);
859
860         aProgram->SetUniform (myGlContext, "uEnvironmentEnable", 1);
861       }
862       else
863       {
864         aProgram->SetUniform (myGlContext, "uEnvironmentEnable", 0);
865       }
866
867       aProgram->SetSampler (myGlContext,
868         "uEnvironmentMapTexture", OpenGl_RT_EnvironmentMapTexture);
869     }
870   }
871
872   OpenGl_ShaderProgram::Unbind (myGlContext);
873
874   myViewModificationStatus = myView->ModificationState();
875
876   return Standard_True;
877 }
878
879 // =======================================================================
880 // function : Source
881 // purpose  : Returns shader source combined with prefix
882 // =======================================================================
883 TCollection_AsciiString OpenGl_Workspace::ShaderSource::Source() const
884 {
885   static const TCollection_AsciiString aVersion = "#version 140";
886
887   if (myPrefix.IsEmpty())
888   {
889     return aVersion + "\n" + mySource;
890   }
891
892   return aVersion + "\n" + myPrefix + "\n" + mySource;
893 }
894
895 // =======================================================================
896 // function : Load
897 // purpose  : Loads shader source from specified files
898 // =======================================================================
899 void OpenGl_Workspace::ShaderSource::Load (
900   const TCollection_AsciiString* theFileNames, const Standard_Integer theCount)
901 {
902   mySource.Clear();
903
904   for (Standard_Integer anIndex = 0; anIndex < theCount; ++anIndex)
905   {
906     OSD_File aFile (theFileNames[anIndex]);
907
908     Standard_ASSERT_RETURN (aFile.Exists(),
909       "Error: Failed to find shader source file", /* none */);
910
911     aFile.Open (OSD_ReadOnly, OSD_Protection());
912
913     TCollection_AsciiString aSource;
914
915     Standard_ASSERT_RETURN (aFile.IsOpen(),
916       "Error: Failed to open shader source file", /* none */);
917
918     aFile.Read (aSource, (Standard_Integer) aFile.Size());
919
920     if (!aSource.IsEmpty())
921     {
922       mySource += TCollection_AsciiString ("\n") + aSource;
923     }
924
925     aFile.Close();
926   }
927 }
928
929 // =======================================================================
930 // function : LoadShader
931 // purpose  : Creates new shader object with specified source
932 // =======================================================================
933 Handle(OpenGl_ShaderObject) OpenGl_Workspace::LoadShader (const ShaderSource& theSource, GLenum theType)
934 {
935   Handle(OpenGl_ShaderObject) aShader = new OpenGl_ShaderObject (theType);
936
937   if (!aShader->Create (myGlContext))
938   {
939     const TCollection_ExtendedString aMessage = "Error: Failed to create shader object";
940       
941     myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
942       GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
943
944     aShader->Release (myGlContext.operator->());
945
946     return Handle(OpenGl_ShaderObject)();
947   }
948
949   if (!aShader->LoadSource (myGlContext, theSource.Source()))
950   {
951     const TCollection_ExtendedString aMessage = "Error: Failed to set shader source";
952       
953     myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
954       GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
955
956     aShader->Release (myGlContext.operator->());
957
958     return Handle(OpenGl_ShaderObject)();
959   }
960
961   TCollection_AsciiString aBuildLog;
962
963   if (!aShader->Compile (myGlContext))
964   {
965     if (aShader->FetchInfoLog (myGlContext, aBuildLog))
966     {
967       const TCollection_ExtendedString aMessage =
968         TCollection_ExtendedString ("Error: Failed to compile shader object:\n") + aBuildLog;
969
970 #ifdef RAY_TRACE_PRINT_INFO
971       std::cout << aBuildLog << std::endl;
972 #endif
973
974       myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
975         GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
976     }
977     
978     aShader->Release (myGlContext.operator->());
979
980     return Handle(OpenGl_ShaderObject)();
981   }
982
983 #ifdef RAY_TRACE_PRINT_INFO
984   if (aShader->FetchInfoLog (myGlContext, aBuildLog))
985   {
986     if (!aBuildLog.IsEmpty())
987     {
988       std::cout << aBuildLog << std::endl;
989     }
990     else
991     {
992       std::cout << "Info: shader build log is empty" << std::endl;
993     }
994   }  
995 #endif
996
997   return aShader;
998 }
999
1000 // =======================================================================
1001 // function : SafeFailBack
1002 // purpose  : Performs safe exit when shaders initialization fails
1003 // =======================================================================
1004 Standard_Boolean OpenGl_Workspace::SafeFailBack (const TCollection_ExtendedString& theMessage)
1005 {
1006   myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1007     GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, theMessage);
1008
1009   myComputeInitStatus = OpenGl_RT_FAIL;
1010
1011   ReleaseRaytraceResources();
1012   
1013   return Standard_False;
1014 }
1015
1016 // =======================================================================
1017 // function : InitRaytraceResources
1018 // purpose  : Initializes OpenGL/GLSL shader programs
1019 // =======================================================================
1020 Standard_Boolean OpenGl_Workspace::InitRaytraceResources()
1021 {
1022   Standard_Boolean aToRebuildShaders = Standard_False;
1023
1024   if (myComputeInitStatus == OpenGl_RT_INIT)
1025   {
1026     if (!myIsRaytraceDataValid)
1027       return Standard_True;
1028
1029     const Standard_Integer aRequiredStackSize =
1030       myRaytraceGeometry.HighLevelTreeDepth() + myRaytraceGeometry.BottomLevelTreeDepth();
1031
1032     if (myTraversalStackSize < aRequiredStackSize)
1033     {
1034       myTraversalStackSize = Max (aRequiredStackSize, THE_DEFAULT_STACK_SIZE);
1035
1036       aToRebuildShaders = Standard_True;
1037     }
1038     else
1039     {
1040       if (aRequiredStackSize < myTraversalStackSize)
1041       {
1042         if (myTraversalStackSize > THE_DEFAULT_STACK_SIZE)
1043         {
1044           myTraversalStackSize = Max (aRequiredStackSize, THE_DEFAULT_STACK_SIZE);
1045
1046           aToRebuildShaders = Standard_True;
1047         }
1048       }
1049     }
1050
1051     if (aToRebuildShaders)
1052     {
1053 #ifdef RAY_TRACE_PRINT_INFO
1054       std::cout << "Info: Rebuild shaders with stack size: " << myTraversalStackSize << std::endl;
1055 #endif
1056
1057       TCollection_AsciiString aStackSizeStr =
1058         TCollection_AsciiString ("#define STACK_SIZE ") + TCollection_AsciiString (myTraversalStackSize);
1059
1060       myRaytraceShaderSource.SetPrefix (aStackSizeStr);
1061       myPostFSAAShaderSource.SetPrefix (aStackSizeStr);
1062
1063       if (!myRaytraceShader->LoadSource (myGlContext, myRaytraceShaderSource.Source())
1064        || !myPostFSAAShader->LoadSource (myGlContext, myPostFSAAShaderSource.Source()))
1065       {
1066         return Standard_False;
1067       }
1068
1069       if (!myRaytraceShader->Compile (myGlContext)
1070        || !myPostFSAAShader->Compile (myGlContext))
1071       {
1072         return Standard_False;
1073       }
1074
1075       if (!myRaytraceProgram->Link (myGlContext)
1076        || !myPostFSAAProgram->Link (myGlContext))
1077       {
1078         return Standard_False;
1079       }
1080     }
1081   }
1082
1083   if (myComputeInitStatus == OpenGl_RT_NONE)
1084   {
1085     if (!myGlContext->IsGlGreaterEqual (3, 1))
1086     {
1087       const TCollection_ExtendedString aMessage = "Ray-tracing requires OpenGL 3.1 and higher";
1088
1089       myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1090         GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
1091
1092       return Standard_False;
1093     }
1094
1095     TCollection_AsciiString aFolder = Graphic3d_ShaderProgram::ShadersFolder();
1096
1097     if (aFolder.IsEmpty())
1098     {
1099       const TCollection_ExtendedString aMessage = "Failed to locate shaders directory";
1100       
1101       myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
1102         GL_DEBUG_TYPE_ERROR_ARB, 0, GL_DEBUG_SEVERITY_HIGH_ARB, aMessage);
1103       
1104       return Standard_False;
1105     }
1106
1107     if (myIsRaytraceDataValid)
1108     {
1109       myTraversalStackSize = Max (THE_DEFAULT_STACK_SIZE,
1110         myRaytraceGeometry.HighLevelTreeDepth() + myRaytraceGeometry.BottomLevelTreeDepth());
1111     }
1112
1113     {
1114       Handle(OpenGl_ShaderObject) aBasicVertShader = LoadShader (
1115         ShaderSource (aFolder + "/RaytraceBase.vs"), GL_VERTEX_SHADER);
1116
1117       if (aBasicVertShader.IsNull())
1118       {
1119         return SafeFailBack ("Failed to set vertex shader source");
1120       }
1121
1122       TCollection_AsciiString aFiles[] = { aFolder + "/RaytraceBase.fs", aFolder + "/RaytraceRender.fs" };
1123
1124       myRaytraceShaderSource.Load (aFiles, 2);
1125
1126       TCollection_AsciiString aStackSizeStr =
1127         TCollection_AsciiString ("#define STACK_SIZE ") + TCollection_AsciiString (myTraversalStackSize);
1128
1129       myRaytraceShaderSource.SetPrefix (aStackSizeStr);
1130
1131       myRaytraceShader = LoadShader (myRaytraceShaderSource, GL_FRAGMENT_SHADER);
1132
1133       if (myRaytraceShader.IsNull())
1134       {
1135         aBasicVertShader->Release (myGlContext.operator->());
1136
1137         return SafeFailBack ("Failed to set ray-trace fragment shader source");
1138       }
1139
1140       myRaytraceProgram = new OpenGl_ShaderProgram;
1141
1142       if (!myRaytraceProgram->Create (myGlContext))
1143       {
1144         aBasicVertShader->Release (myGlContext.operator->());
1145
1146         return SafeFailBack ("Failed to create ray-trace shader program");
1147       }
1148
1149       if (!myRaytraceProgram->AttachShader (myGlContext, aBasicVertShader)
1150        || !myRaytraceProgram->AttachShader (myGlContext, myRaytraceShader))
1151       {
1152         aBasicVertShader->Release (myGlContext.operator->());
1153
1154         return SafeFailBack ("Failed to attach ray-trace shader objects");
1155       }
1156
1157       if (!myRaytraceProgram->Link (myGlContext))
1158       {
1159         TCollection_AsciiString aLinkLog;
1160
1161         if (myRaytraceProgram->FetchInfoLog (myGlContext, aLinkLog))
1162         {
1163   #ifdef RAY_TRACE_PRINT_INFO
1164           std::cout << aLinkLog << std::endl;
1165   #endif
1166         }
1167
1168         return SafeFailBack ("Failed to link ray-trace shader program");
1169       }
1170     }
1171
1172     {
1173       Handle(OpenGl_ShaderObject) aBasicVertShader = LoadShader (
1174         ShaderSource (aFolder + "/RaytraceBase.vs"), GL_VERTEX_SHADER);
1175
1176       if (aBasicVertShader.IsNull())
1177       {
1178         return SafeFailBack ("Failed to set vertex shader source");
1179       }
1180
1181       TCollection_AsciiString aFiles[] = { aFolder + "/RaytraceBase.fs", aFolder + "/RaytraceSmooth.fs" };
1182
1183       myPostFSAAShaderSource.Load (aFiles, 2);
1184
1185       TCollection_AsciiString aStackSizeStr =
1186         TCollection_AsciiString ("#define STACK_SIZE ") + TCollection_AsciiString (myTraversalStackSize);
1187
1188       myPostFSAAShaderSource.SetPrefix (aStackSizeStr);
1189     
1190       myPostFSAAShader = LoadShader (myPostFSAAShaderSource, GL_FRAGMENT_SHADER);
1191
1192       if (myPostFSAAShader.IsNull())
1193       {
1194         aBasicVertShader->Release (myGlContext.operator->());
1195
1196         return SafeFailBack ("Failed to set FSAA fragment shader source");
1197       }
1198
1199       myPostFSAAProgram = new OpenGl_ShaderProgram;
1200
1201       if (!myPostFSAAProgram->Create (myGlContext))
1202       {
1203         aBasicVertShader->Release (myGlContext.operator->());
1204
1205         return SafeFailBack ("Failed to create FSAA shader program");
1206       }
1207
1208       if (!myPostFSAAProgram->AttachShader (myGlContext, aBasicVertShader)
1209        || !myPostFSAAProgram->AttachShader (myGlContext, myPostFSAAShader))
1210       {
1211         aBasicVertShader->Release (myGlContext.operator->());
1212
1213         return SafeFailBack ("Failed to attach FSAA shader objects");
1214       }
1215
1216       if (!myPostFSAAProgram->Link (myGlContext))
1217       {
1218         TCollection_AsciiString aLinkLog;
1219
1220         if (myPostFSAAProgram->FetchInfoLog (myGlContext, aLinkLog))
1221         {
1222   #ifdef RAY_TRACE_PRINT_INFO
1223           std::cout << aLinkLog << std::endl;
1224   #endif
1225         }
1226       
1227         return SafeFailBack ("Failed to link FSAA shader program");
1228       }
1229     }
1230   }
1231
1232   if (myComputeInitStatus == OpenGl_RT_NONE || aToRebuildShaders)
1233   {
1234     for (Standard_Integer anIndex = 0; anIndex < 2; ++anIndex)
1235     {
1236       Handle(OpenGl_ShaderProgram)& aShaderProgram =
1237         (anIndex == 0) ? myRaytraceProgram : myPostFSAAProgram;
1238
1239       aShaderProgram->Bind (myGlContext);
1240
1241       aShaderProgram->SetSampler (myGlContext,
1242         "uSceneMinPointTexture", OpenGl_RT_SceneMinPointTexture);
1243       aShaderProgram->SetSampler (myGlContext,
1244         "uSceneMaxPointTexture", OpenGl_RT_SceneMaxPointTexture);
1245       aShaderProgram->SetSampler (myGlContext,
1246         "uSceneNodeInfoTexture", OpenGl_RT_SceneNodeInfoTexture);
1247       aShaderProgram->SetSampler (myGlContext,
1248         "uObjectMinPointTexture", OpenGl_RT_ObjectMinPointTexture);
1249       aShaderProgram->SetSampler (myGlContext,
1250         "uObjectMaxPointTexture", OpenGl_RT_ObjectMaxPointTexture);
1251       aShaderProgram->SetSampler (myGlContext,
1252         "uObjectNodeInfoTexture", OpenGl_RT_ObjectNodeInfoTexture);
1253       aShaderProgram->SetSampler (myGlContext,
1254         "uGeometryVertexTexture", OpenGl_RT_GeometryVertexTexture);
1255       aShaderProgram->SetSampler (myGlContext,
1256         "uGeometryNormalTexture", OpenGl_RT_GeometryNormalTexture);
1257       aShaderProgram->SetSampler (myGlContext,
1258         "uGeometryTriangTexture", OpenGl_RT_GeometryTriangTexture);
1259       aShaderProgram->SetSampler (myGlContext,
1260         "uRaytraceMaterialTexture", OpenGl_RT_RaytraceMaterialTexture);
1261       aShaderProgram->SetSampler (myGlContext,
1262         "uRaytraceLightSrcTexture", OpenGl_RT_RaytraceLightSrcTexture);
1263
1264       if (anIndex == 1)
1265       {
1266         aShaderProgram->SetSampler (myGlContext,
1267           "uFSAAInputTexture", OpenGl_RT_FSAAInputTexture);
1268       }
1269
1270       myUniformLocations[anIndex][OpenGl_RT_aPosition] =
1271         aShaderProgram->GetAttributeLocation (myGlContext, "aPosition");
1272
1273       myUniformLocations[anIndex][OpenGl_RT_uOriginLB] =
1274         aShaderProgram->GetUniformLocation (myGlContext, "uOriginLB");
1275       myUniformLocations[anIndex][OpenGl_RT_uOriginRB] =
1276         aShaderProgram->GetUniformLocation (myGlContext, "uOriginRB");
1277       myUniformLocations[anIndex][OpenGl_RT_uOriginLT] =
1278         aShaderProgram->GetUniformLocation (myGlContext, "uOriginLT");
1279       myUniformLocations[anIndex][OpenGl_RT_uOriginRT] =
1280         aShaderProgram->GetUniformLocation (myGlContext, "uOriginRT");
1281       myUniformLocations[anIndex][OpenGl_RT_uDirectLB] =
1282         aShaderProgram->GetUniformLocation (myGlContext, "uDirectLB");
1283       myUniformLocations[anIndex][OpenGl_RT_uDirectRB] =
1284         aShaderProgram->GetUniformLocation (myGlContext, "uDirectRB");
1285       myUniformLocations[anIndex][OpenGl_RT_uDirectLT] =
1286         aShaderProgram->GetUniformLocation (myGlContext, "uDirectLT");
1287       myUniformLocations[anIndex][OpenGl_RT_uDirectRT] =
1288         aShaderProgram->GetUniformLocation (myGlContext, "uDirectRT");
1289
1290       myUniformLocations[anIndex][OpenGl_RT_uLightCount] =
1291         aShaderProgram->GetUniformLocation (myGlContext, "uLightCount");
1292       myUniformLocations[anIndex][OpenGl_RT_uLightAmbnt] =
1293         aShaderProgram->GetUniformLocation (myGlContext, "uGlobalAmbient");
1294
1295       myUniformLocations[anIndex][OpenGl_RT_uSceneRad] =
1296         aShaderProgram->GetUniformLocation (myGlContext, "uSceneRadius");
1297       myUniformLocations[anIndex][OpenGl_RT_uSceneEps] =
1298         aShaderProgram->GetUniformLocation (myGlContext, "uSceneEpsilon");
1299
1300       myUniformLocations[anIndex][OpenGl_RT_uShadEnabled] =
1301         aShaderProgram->GetUniformLocation (myGlContext, "uShadowsEnable");
1302       myUniformLocations[anIndex][OpenGl_RT_uReflEnabled] =
1303         aShaderProgram->GetUniformLocation (myGlContext, "uReflectionsEnable");
1304
1305       myUniformLocations[anIndex][OpenGl_RT_uOffsetX] =
1306         aShaderProgram->GetUniformLocation (myGlContext, "uOffsetX");
1307       myUniformLocations[anIndex][OpenGl_RT_uOffsetY] =
1308         aShaderProgram->GetUniformLocation (myGlContext, "uOffsetY");
1309       myUniformLocations[anIndex][OpenGl_RT_uSamples] =
1310         aShaderProgram->GetUniformLocation (myGlContext, "uSamples");
1311     }
1312
1313     OpenGl_ShaderProgram::Unbind (myGlContext);
1314   }
1315
1316   if (myComputeInitStatus != OpenGl_RT_NONE)
1317   {
1318     return myComputeInitStatus == OpenGl_RT_INIT;
1319   }
1320
1321   if (myRaytraceFBO1.IsNull())
1322   {
1323     myRaytraceFBO1 = new OpenGl_FrameBuffer;
1324   }
1325
1326   if (myRaytraceFBO2.IsNull())
1327   {
1328     myRaytraceFBO2 = new OpenGl_FrameBuffer;
1329   }
1330
1331   const GLfloat aVertices[] = { -1.f, -1.f,  0.f,
1332                                 -1.f,  1.f,  0.f,
1333                                  1.f,  1.f,  0.f,
1334                                  1.f,  1.f,  0.f,
1335                                  1.f, -1.f,  0.f,
1336                                 -1.f, -1.f,  0.f };
1337
1338   myRaytraceScreenQuad.Init (myGlContext, 3, 6, aVertices);
1339
1340   myComputeInitStatus = OpenGl_RT_INIT; // initialized in normal way
1341   
1342   return Standard_True;
1343 }
1344
1345 // =======================================================================
1346 // function : NullifyResource
1347 // purpose  :
1348 // =======================================================================
1349 inline void NullifyResource (const Handle(OpenGl_Context)& theContext,
1350                              Handle(OpenGl_Resource)&      theResource)
1351 {
1352   if (!theResource.IsNull())
1353   {
1354     theResource->Release (theContext.operator->());
1355     theResource.Nullify();
1356   }
1357 }
1358
1359 // =======================================================================
1360 // function : ReleaseRaytraceResources
1361 // purpose  : Releases OpenGL/GLSL shader programs
1362 // =======================================================================
1363 void OpenGl_Workspace::ReleaseRaytraceResources()
1364 {
1365   NullifyResource (myGlContext, myRaytraceFBO1);
1366   NullifyResource (myGlContext, myRaytraceFBO2);
1367
1368   NullifyResource (myGlContext, myRaytraceShader);
1369   NullifyResource (myGlContext, myPostFSAAShader);
1370
1371   NullifyResource (myGlContext, myRaytraceProgram);
1372   NullifyResource (myGlContext, myPostFSAAProgram);
1373
1374   NullifyResource (myGlContext, mySceneNodeInfoTexture);
1375   NullifyResource (myGlContext, mySceneMinPointTexture);
1376   NullifyResource (myGlContext, mySceneMaxPointTexture);
1377
1378   NullifyResource (myGlContext, myObjectNodeInfoTexture);
1379   NullifyResource (myGlContext, myObjectMinPointTexture);
1380   NullifyResource (myGlContext, myObjectMaxPointTexture);
1381
1382   NullifyResource (myGlContext, myGeometryVertexTexture);
1383   NullifyResource (myGlContext, myGeometryNormalTexture);
1384   NullifyResource (myGlContext, myGeometryTriangTexture);
1385
1386   NullifyResource (myGlContext, myRaytraceLightSrcTexture);
1387   NullifyResource (myGlContext, myRaytraceMaterialTexture);
1388
1389   if (myRaytraceScreenQuad.IsValid())
1390     myRaytraceScreenQuad.Release (myGlContext.operator->());
1391 }
1392
1393 // =======================================================================
1394 // function : UploadRaytraceData
1395 // purpose  : Uploads ray-trace data to the GPU
1396 // =======================================================================
1397 Standard_Boolean OpenGl_Workspace::UploadRaytraceData()
1398 {
1399   if (!myGlContext->IsGlGreaterEqual (3, 1))
1400   {
1401 #ifdef RAY_TRACE_PRINT_INFO
1402     std::cout << "Error: OpenGL version is less than 3.1" << std::endl;
1403 #endif
1404     return Standard_False;
1405   }
1406
1407   /////////////////////////////////////////////////////////////////////////////
1408   // Create OpenGL texture buffers
1409
1410   if (mySceneNodeInfoTexture.IsNull())  // create hight-level BVH buffers
1411   {
1412     mySceneNodeInfoTexture = new OpenGl_TextureBufferArb;
1413     mySceneMinPointTexture = new OpenGl_TextureBufferArb;
1414     mySceneMaxPointTexture = new OpenGl_TextureBufferArb;
1415
1416     if (!mySceneNodeInfoTexture->Create (myGlContext)
1417       || !mySceneMinPointTexture->Create (myGlContext)
1418       || !mySceneMaxPointTexture->Create (myGlContext))
1419     {
1420 #ifdef RAY_TRACE_PRINT_INFO
1421       std::cout << "Error: Failed to create buffers for high-level scene BVH" << std::endl;
1422 #endif
1423       return Standard_False;
1424     }
1425   }
1426
1427   if (myObjectNodeInfoTexture.IsNull())  // create bottom-level BVH buffers
1428   {
1429     myObjectNodeInfoTexture = new OpenGl_TextureBufferArb;
1430     myObjectMinPointTexture = new OpenGl_TextureBufferArb;
1431     myObjectMaxPointTexture = new OpenGl_TextureBufferArb;
1432
1433     if (!myObjectNodeInfoTexture->Create (myGlContext)
1434       || !myObjectMinPointTexture->Create (myGlContext)
1435       || !myObjectMaxPointTexture->Create (myGlContext))
1436     {
1437 #ifdef RAY_TRACE_PRINT_INFO
1438       std::cout << "Error: Failed to create buffers for bottom-level scene BVH" << std::endl;
1439 #endif
1440       return Standard_False;
1441     }
1442   }
1443
1444   if (myGeometryVertexTexture.IsNull())  // create geometry buffers
1445   {
1446     myGeometryVertexTexture = new OpenGl_TextureBufferArb;
1447     myGeometryNormalTexture = new OpenGl_TextureBufferArb;
1448     myGeometryTriangTexture = new OpenGl_TextureBufferArb;
1449
1450     if (!myGeometryVertexTexture->Create (myGlContext)
1451       || !myGeometryNormalTexture->Create (myGlContext)
1452       || !myGeometryTriangTexture->Create (myGlContext))
1453     {
1454 #ifdef RAY_TRACE_PRINT_INFO
1455       std::cout << "Error: Failed to create buffers for triangulation data" << std::endl;
1456 #endif
1457       return Standard_False;
1458     }
1459   }
1460
1461   if (myRaytraceMaterialTexture.IsNull())  // create material buffer
1462   {
1463     myRaytraceMaterialTexture = new OpenGl_TextureBufferArb;
1464
1465     if (!myRaytraceMaterialTexture->Create (myGlContext))
1466     {
1467 #ifdef RAY_TRACE_PRINT_INFO
1468       std::cout << "Error: Failed to create buffers for material data" << std::endl;
1469 #endif
1470       return Standard_False;
1471     }
1472   }
1473
1474   /////////////////////////////////////////////////////////////////////////////
1475   // Write OpenGL texture buffers
1476
1477   const NCollection_Handle<BVH_Tree<Standard_ShortReal, 4> >& aBVH = myRaytraceGeometry.BVH();
1478
1479   bool aResult = true;
1480
1481   if (!aBVH->NodeInfoBuffer().empty())
1482   {
1483     aResult &= mySceneNodeInfoTexture->Init (myGlContext, 4,
1484       aBVH->NodeInfoBuffer().size(), reinterpret_cast<const GLuint*> (&aBVH->NodeInfoBuffer().front()));
1485
1486     aResult &= mySceneMinPointTexture->Init (myGlContext, 4,
1487       aBVH->MinPointBuffer().size(), reinterpret_cast<const GLfloat*> (&aBVH->MinPointBuffer().front()));
1488
1489     aResult &= mySceneMaxPointTexture->Init (myGlContext, 4,
1490       aBVH->MaxPointBuffer().size(), reinterpret_cast<const GLfloat*> (&aBVH->MaxPointBuffer().front()));
1491   }
1492
1493   if (!aResult)
1494   {
1495 #ifdef RAY_TRACE_PRINT_INFO
1496     std::cout << "Error: Failed to upload buffers for high-level scene BVH" << std::endl;
1497 #endif
1498     return Standard_False;
1499   }
1500
1501   Standard_Size aTotalVerticesNb = 0;
1502   Standard_Size aTotalElementsNb = 0;
1503   Standard_Size aTotalBVHNodesNb = 0;
1504
1505   for (Standard_Integer anElemIndex = 0; anElemIndex < myRaytraceGeometry.Size(); ++anElemIndex)
1506   {
1507     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
1508       myRaytraceGeometry.Objects().ChangeValue (anElemIndex).operator->());
1509
1510     Standard_ASSERT_RETURN (aTriangleSet != NULL,
1511       "Error: Failed to get triangulation of OpenGL element", Standard_False);
1512
1513     aTotalVerticesNb += aTriangleSet->Vertices.size();
1514     aTotalElementsNb += aTriangleSet->Elements.size();
1515
1516     Standard_ASSERT_RETURN (!aTriangleSet->BVH().IsNull(),
1517       "Error: Failed to get bottom-level BVH of OpenGL element", Standard_False);
1518
1519     aTotalBVHNodesNb += aTriangleSet->BVH()->NodeInfoBuffer().size();
1520   }
1521
1522   if (aTotalBVHNodesNb != 0)
1523   {
1524     aResult &= myObjectNodeInfoTexture->Init (
1525       myGlContext, 4, aTotalBVHNodesNb, static_cast<const GLuint*> (NULL));
1526
1527     aResult &= myObjectMinPointTexture->Init (
1528       myGlContext, 4, aTotalBVHNodesNb, static_cast<const GLfloat*> (NULL));
1529
1530     aResult &= myObjectMaxPointTexture->Init (
1531       myGlContext, 4, aTotalBVHNodesNb, static_cast<const GLfloat*> (NULL));
1532   }
1533
1534   if (!aResult)
1535   {
1536 #ifdef RAY_TRACE_PRINT_INFO
1537     std::cout << "Error: Failed to upload buffers for bottom-level scene BVH" << std::endl;
1538 #endif
1539     return Standard_False;
1540   }
1541
1542   if (aTotalElementsNb != 0)
1543   {
1544     aResult &= myGeometryTriangTexture->Init (
1545       myGlContext, 4, aTotalElementsNb, static_cast<const GLuint*> (NULL));
1546   }
1547
1548   if (aTotalVerticesNb != 0)
1549   {
1550     aResult &= myGeometryVertexTexture->Init (
1551       myGlContext, 4, aTotalVerticesNb, static_cast<const GLfloat*> (NULL));
1552
1553     aResult &= myGeometryNormalTexture->Init (
1554       myGlContext, 4, aTotalVerticesNb, static_cast<const GLfloat*> (NULL));
1555   }
1556
1557   if (!aResult)
1558   {
1559 #ifdef RAY_TRACE_PRINT_INFO
1560     std::cout << "Error: Failed to upload buffers for scene geometry" << std::endl;
1561 #endif
1562     return Standard_False;
1563   }
1564
1565   for (Standard_Integer aNodeIdx = 0; aNodeIdx < aBVH->Length(); ++aNodeIdx)
1566   {
1567     if (!aBVH->IsOuter (aNodeIdx))
1568       continue;
1569
1570     OpenGl_TriangleSet* aTriangleSet = myRaytraceGeometry.TriangleSet (aNodeIdx);
1571
1572     Standard_ASSERT_RETURN (aTriangleSet != NULL,
1573       "Error: Failed to get triangulation of OpenGL element", Standard_False);
1574
1575     const Standard_Integer aBVHOffset = myRaytraceGeometry.AccelerationOffset (aNodeIdx);
1576
1577     Standard_ASSERT_RETURN (aBVHOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1578       "Error: Failed to get offset for bottom-level BVH", Standard_False);
1579
1580     const size_t aBVHBuffserSize = aTriangleSet->BVH()->NodeInfoBuffer().size();
1581
1582     if (aBVHBuffserSize != 0)
1583     {
1584       aResult &= myObjectNodeInfoTexture->SubData (myGlContext, aBVHOffset,
1585         aBVHBuffserSize, reinterpret_cast<const GLuint*> (&aTriangleSet->BVH()->NodeInfoBuffer().front()));
1586
1587       aResult &= myObjectMinPointTexture->SubData (myGlContext, aBVHOffset,
1588         aBVHBuffserSize, reinterpret_cast<const GLfloat*> (&aTriangleSet->BVH()->MinPointBuffer().front()));
1589
1590       aResult &= myObjectMaxPointTexture->SubData (myGlContext, aBVHOffset,
1591         aBVHBuffserSize, reinterpret_cast<const GLfloat*> (&aTriangleSet->BVH()->MaxPointBuffer().front()));
1592
1593       if (!aResult)
1594       {
1595 #ifdef RAY_TRACE_PRINT_INFO
1596         std::cout << "Error: Failed to upload buffers for bottom-level scene BVHs" << std::endl;
1597 #endif
1598         return Standard_False;
1599       }
1600     }
1601
1602     const Standard_Integer aVerticesOffset = myRaytraceGeometry.VerticesOffset (aNodeIdx);
1603
1604     Standard_ASSERT_RETURN (aVerticesOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1605       "Error: Failed to get offset for triangulation vertices of OpenGL element", Standard_False);
1606
1607     if (!aTriangleSet->Vertices.empty())
1608     {
1609       aResult &= myGeometryNormalTexture->SubData (myGlContext, aVerticesOffset,
1610         aTriangleSet->Normals.size(), reinterpret_cast<const GLfloat*> (&aTriangleSet->Normals.front()));
1611
1612       aResult &= myGeometryVertexTexture->SubData (myGlContext, aVerticesOffset,
1613         aTriangleSet->Vertices.size(), reinterpret_cast<const GLfloat*> (&aTriangleSet->Vertices.front()));
1614     }
1615
1616     const Standard_Integer anElementsOffset = myRaytraceGeometry.ElementsOffset (aNodeIdx);
1617
1618     Standard_ASSERT_RETURN (anElementsOffset != OpenGl_RaytraceGeometry::INVALID_OFFSET,
1619       "Error: Failed to get offset for triangulation elements of OpenGL element", Standard_False);
1620
1621     if (!aTriangleSet->Elements.empty())
1622     {
1623       aResult &= myGeometryTriangTexture->SubData (myGlContext, anElementsOffset,
1624         aTriangleSet->Elements.size(), reinterpret_cast<const GLuint*> (&aTriangleSet->Elements.front()));
1625     }
1626
1627     if (!aResult)
1628     {
1629 #ifdef RAY_TRACE_PRINT_INFO
1630       std::cout << "Error: Failed to upload triangulation buffers for OpenGL element" << std::endl;
1631 #endif
1632       return Standard_False;
1633     }
1634   }
1635
1636   if (myRaytraceGeometry.Materials.size() != 0)
1637   {
1638     const GLfloat* aDataPtr = myRaytraceGeometry.Materials.front().Packed();
1639
1640     aResult &= myRaytraceMaterialTexture->Init (
1641       myGlContext, 4, myRaytraceGeometry.Materials.size() * 7, aDataPtr);
1642
1643     if (!aResult)
1644     {
1645 #ifdef RAY_TRACE_PRINT_INFO
1646       std::cout << "Error: Failed to upload material buffer" << std::endl;
1647 #endif
1648       return Standard_False;
1649     }
1650   }
1651
1652   myIsRaytraceDataValid = myRaytraceGeometry.Objects().Size() != 0;
1653
1654 #ifdef RAY_TRACE_PRINT_INFO
1655
1656   Standard_ShortReal aMemUsed = 0.f;
1657
1658   for (Standard_Integer anElemIdx = 0; anElemIdx < myRaytraceGeometry.Size(); ++anElemIdx)
1659   {
1660     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
1661       myRaytraceGeometry.Objects().ChangeValue (anElemIdx).operator->());
1662
1663     aMemUsed += static_cast<Standard_ShortReal> (
1664       aTriangleSet->Vertices.size() * sizeof (BVH_Vec4f));
1665     aMemUsed += static_cast<Standard_ShortReal> (
1666       aTriangleSet->Normals.size() * sizeof (BVH_Vec4f));
1667     aMemUsed += static_cast<Standard_ShortReal> (
1668       aTriangleSet->Elements.size() * sizeof (BVH_Vec4i));
1669
1670     aMemUsed += static_cast<Standard_ShortReal> (
1671       aTriangleSet->BVH()->NodeInfoBuffer().size() * sizeof (BVH_Vec4i));
1672     aMemUsed += static_cast<Standard_ShortReal> (
1673       aTriangleSet->BVH()->MinPointBuffer().size() * sizeof (BVH_Vec4f));
1674     aMemUsed += static_cast<Standard_ShortReal> (
1675       aTriangleSet->BVH()->MaxPointBuffer().size() * sizeof (BVH_Vec4f));
1676   }
1677
1678   aMemUsed += static_cast<Standard_ShortReal> (
1679     myRaytraceGeometry.BVH()->NodeInfoBuffer().size() * sizeof (BVH_Vec4i));
1680   aMemUsed += static_cast<Standard_ShortReal> (
1681     myRaytraceGeometry.BVH()->MinPointBuffer().size() * sizeof (BVH_Vec4f));
1682   aMemUsed += static_cast<Standard_ShortReal> (
1683     myRaytraceGeometry.BVH()->MaxPointBuffer().size() * sizeof (BVH_Vec4f));
1684
1685   std::cout << "GPU Memory Used (MB): ~" << aMemUsed / 1048576 << std::endl;
1686
1687 #endif
1688
1689   return aResult;
1690 }
1691
1692 // =======================================================================
1693 // function : ResizeRaytraceBuffers
1694 // purpose  : Resizes OpenGL frame buffers
1695 // =======================================================================
1696 Standard_Boolean OpenGl_Workspace::ResizeRaytraceBuffers (const Standard_Integer theSizeX,
1697                                                           const Standard_Integer theSizeY)
1698 {
1699   if (myRaytraceFBO1->GetVPSizeX() != theSizeX
1700    || myRaytraceFBO1->GetVPSizeY() != theSizeY)
1701   {
1702     myRaytraceFBO1->Init (myGlContext, theSizeX, theSizeY);
1703     myRaytraceFBO2->Init (myGlContext, theSizeX, theSizeY);
1704   }
1705
1706   return Standard_True;
1707 }
1708
1709 // =======================================================================
1710 // function : UpdateCamera
1711 // purpose  : Generates viewing rays for corners of screen quad
1712 // =======================================================================
1713 void OpenGl_Workspace::UpdateCamera (const NCollection_Mat4<GLdouble>& theOrientation,
1714                                      const NCollection_Mat4<GLdouble>& theViewMapping,
1715                                      OpenGl_Vec3                       theOrigins[4],
1716                                      OpenGl_Vec3                       theDirects[4])
1717 {
1718   NCollection_Mat4<GLdouble> aInvModelProj;
1719
1720   // compute invserse model-view-projection matrix
1721   (theViewMapping * theOrientation).Inverted (aInvModelProj);
1722
1723   Standard_Integer aOriginIndex = 0;
1724   Standard_Integer aDirectIndex = 0;
1725
1726   for (Standard_Integer aY = -1; aY <= 1; aY += 2)
1727   {
1728     for (Standard_Integer aX = -1; aX <= 1; aX += 2)
1729     {
1730       OpenGl_Vec4d aOrigin (GLdouble(aX),
1731                             GLdouble(aY),
1732                            -1.0,
1733                             1.0);
1734
1735       aOrigin = aInvModelProj * aOrigin;
1736
1737       aOrigin.x() = aOrigin.x() / aOrigin.w();
1738       aOrigin.y() = aOrigin.y() / aOrigin.w();
1739       aOrigin.z() = aOrigin.z() / aOrigin.w();
1740
1741       OpenGl_Vec4d aDirect (GLdouble(aX),
1742                             GLdouble(aY),
1743                             1.0,
1744                             1.0);
1745
1746       aDirect = aInvModelProj * aDirect;
1747
1748       aDirect.x() = aDirect.x() / aDirect.w();
1749       aDirect.y() = aDirect.y() / aDirect.w();
1750       aDirect.z() = aDirect.z() / aDirect.w();
1751
1752       aDirect = aDirect - aOrigin;
1753
1754       GLdouble aInvLen = 1.0 / sqrt (aDirect.x() * aDirect.x() +
1755                                      aDirect.y() * aDirect.y() +
1756                                      aDirect.z() * aDirect.z());
1757
1758       theOrigins[aOriginIndex++] = OpenGl_Vec3 (static_cast<GLfloat> (aOrigin.x()),
1759                                                 static_cast<GLfloat> (aOrigin.y()),
1760                                                 static_cast<GLfloat> (aOrigin.z()));
1761
1762       theDirects[aDirectIndex++] = OpenGl_Vec3 (static_cast<GLfloat> (aDirect.x() * aInvLen),
1763                                                 static_cast<GLfloat> (aDirect.y() * aInvLen),
1764                                                 static_cast<GLfloat> (aDirect.z() * aInvLen));
1765     }
1766   }
1767 }
1768
1769 // =======================================================================
1770 // function : RunRaytraceShaders
1771 // purpose  : Runs ray-tracing shader programs
1772 // =======================================================================
1773 Standard_Boolean OpenGl_Workspace::RunRaytraceShaders (const Graphic3d_CView& theCView,
1774                                                        const Standard_Integer theSizeX,
1775                                                        const Standard_Integer theSizeY,
1776                                                        const OpenGl_Vec3      theOrigins[4],
1777                                                        const OpenGl_Vec3      theDirects[4],
1778                                                        OpenGl_FrameBuffer*    theFrameBuffer)
1779 {
1780   mySceneMinPointTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMinPointTexture);
1781   mySceneMaxPointTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMaxPointTexture);
1782   mySceneNodeInfoTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_SceneNodeInfoTexture);
1783   myObjectMinPointTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_ObjectMinPointTexture);
1784   myObjectMaxPointTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_ObjectMaxPointTexture);
1785   myObjectNodeInfoTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_ObjectNodeInfoTexture);
1786   myGeometryVertexTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryVertexTexture);
1787   myGeometryNormalTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryNormalTexture);
1788   myGeometryTriangTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_GeometryTriangTexture);
1789   myRaytraceMaterialTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceMaterialTexture);
1790   myRaytraceLightSrcTexture->BindTexture (myGlContext, GL_TEXTURE0 + OpenGl_RT_RaytraceLightSrcTexture);
1791
1792   if (theCView.IsAntialiasingEnabled) // render source image to FBO
1793   {
1794     myRaytraceFBO1->BindBuffer (myGlContext);
1795     
1796     glDisable (GL_BLEND);
1797   }
1798
1799   myRaytraceProgram->Bind (myGlContext);
1800
1801   Standard_Integer aLightSourceBufferSize =
1802     static_cast<Standard_Integer> (myRaytraceGeometry.Sources.size());
1803
1804   myRaytraceProgram->SetUniform (myGlContext,
1805     myUniformLocations[0][OpenGl_RT_uOriginLB], theOrigins[0]);
1806   myRaytraceProgram->SetUniform (myGlContext,
1807     myUniformLocations[0][OpenGl_RT_uOriginRB], theOrigins[1]);
1808   myRaytraceProgram->SetUniform (myGlContext,
1809     myUniformLocations[0][OpenGl_RT_uOriginLT], theOrigins[2]);
1810   myRaytraceProgram->SetUniform (myGlContext,
1811     myUniformLocations[0][OpenGl_RT_uOriginRT], theOrigins[3]);
1812   myRaytraceProgram->SetUniform (myGlContext,
1813     myUniformLocations[0][OpenGl_RT_uDirectLB], theDirects[0]);
1814   myRaytraceProgram->SetUniform (myGlContext,
1815     myUniformLocations[0][OpenGl_RT_uDirectRB], theDirects[1]);
1816   myRaytraceProgram->SetUniform (myGlContext,
1817     myUniformLocations[0][OpenGl_RT_uDirectLT], theDirects[2]);
1818   myRaytraceProgram->SetUniform (myGlContext,
1819     myUniformLocations[0][OpenGl_RT_uDirectRT], theDirects[3]);
1820   myRaytraceProgram->SetUniform (myGlContext,
1821     myUniformLocations[0][OpenGl_RT_uSceneRad], myRaytraceSceneRadius);
1822   myRaytraceProgram->SetUniform (myGlContext,
1823     myUniformLocations[0][OpenGl_RT_uSceneEps], myRaytraceSceneEpsilon);
1824   myRaytraceProgram->SetUniform (myGlContext,
1825     myUniformLocations[0][OpenGl_RT_uLightCount], aLightSourceBufferSize);
1826   myRaytraceProgram->SetUniform (myGlContext,
1827     myUniformLocations[0][OpenGl_RT_uLightAmbnt], myRaytraceGeometry.Ambient);
1828   myRaytraceProgram->SetUniform (myGlContext,
1829     myUniformLocations[0][OpenGl_RT_uShadEnabled], theCView.IsShadowsEnabled);
1830   myRaytraceProgram->SetUniform (myGlContext,
1831     myUniformLocations[0][OpenGl_RT_uReflEnabled], theCView.IsReflectionsEnabled);
1832
1833   myGlContext->core20fwd->glEnableVertexAttribArray (
1834     myUniformLocations[0][OpenGl_RT_aPosition]);
1835   {
1836     myGlContext->core20fwd->glVertexAttribPointer (
1837       myUniformLocations[0][OpenGl_RT_aPosition], 3, GL_FLOAT, GL_FALSE, 0, NULL);
1838
1839     myGlContext->core15fwd->glDrawArrays (GL_TRIANGLES, 0, 6);
1840   }
1841   myGlContext->core20fwd->glDisableVertexAttribArray (
1842     myUniformLocations[0][OpenGl_RT_aPosition]);
1843   
1844   if (!theCView.IsAntialiasingEnabled)
1845   {
1846     myRaytraceProgram->Unbind (myGlContext);
1847
1848     return Standard_True;
1849   }
1850
1851   myGlContext->core20fwd->glActiveTexture (
1852     GL_TEXTURE0 + OpenGl_RT_FSAAInputTexture); // texture unit for FBO texture
1853
1854   myRaytraceFBO1->BindTexture (myGlContext);
1855
1856   myPostFSAAProgram->Bind (myGlContext);
1857
1858   myPostFSAAProgram->SetUniform (myGlContext,
1859     myUniformLocations[1][OpenGl_RT_uOriginLB], theOrigins[0]);
1860   myPostFSAAProgram->SetUniform (myGlContext,
1861     myUniformLocations[1][OpenGl_RT_uOriginRB], theOrigins[1]);
1862   myPostFSAAProgram->SetUniform (myGlContext,
1863     myUniformLocations[1][OpenGl_RT_uOriginLT], theOrigins[2]);
1864   myPostFSAAProgram->SetUniform (myGlContext,
1865     myUniformLocations[1][OpenGl_RT_uOriginRT], theOrigins[3]);
1866   myPostFSAAProgram->SetUniform (myGlContext,
1867     myUniformLocations[1][OpenGl_RT_uDirectLB], theDirects[0]);
1868   myPostFSAAProgram->SetUniform (myGlContext,
1869     myUniformLocations[1][OpenGl_RT_uDirectRB], theDirects[1]);
1870   myPostFSAAProgram->SetUniform (myGlContext,
1871     myUniformLocations[1][OpenGl_RT_uDirectLT], theDirects[2]);
1872   myPostFSAAProgram->SetUniform (myGlContext,
1873     myUniformLocations[1][OpenGl_RT_uDirectRT], theDirects[3]);
1874   myPostFSAAProgram->SetUniform (myGlContext,
1875     myUniformLocations[1][OpenGl_RT_uSceneRad], myRaytraceSceneRadius);
1876   myPostFSAAProgram->SetUniform (myGlContext,
1877     myUniformLocations[1][OpenGl_RT_uSceneEps], myRaytraceSceneEpsilon);
1878   myPostFSAAProgram->SetUniform (myGlContext,
1879     myUniformLocations[1][OpenGl_RT_uLightCount], aLightSourceBufferSize);
1880   myPostFSAAProgram->SetUniform (myGlContext,
1881     myUniformLocations[1][OpenGl_RT_uLightAmbnt], myRaytraceGeometry.Ambient);
1882   myPostFSAAProgram->SetUniform (myGlContext,
1883     myUniformLocations[1][OpenGl_RT_uShadEnabled], theCView.IsShadowsEnabled);
1884   myPostFSAAProgram->SetUniform (myGlContext,
1885     myUniformLocations[1][OpenGl_RT_uReflEnabled], theCView.IsReflectionsEnabled);
1886
1887   const Standard_ShortReal aMaxOffset = 0.559017f;
1888   const Standard_ShortReal aMinOffset = 0.186339f;
1889
1890   myGlContext->core20fwd->glEnableVertexAttribArray (
1891     myUniformLocations[1][OpenGl_RT_aPosition]);
1892   
1893   myGlContext->core20fwd->glVertexAttribPointer (
1894     myUniformLocations[1][OpenGl_RT_aPosition], 3, GL_FLOAT, GL_FALSE, 0, NULL);
1895
1896   // Perform multi-pass adaptive FSAA using ping-pong technique
1897   for (Standard_Integer anIt = 0; anIt < 4; ++anIt)
1898   {
1899     GLfloat aOffsetX = 1.f / theSizeX;
1900     GLfloat aOffsetY = 1.f / theSizeY;
1901
1902     if (anIt < 2)
1903     {
1904       aOffsetX *= anIt < 1 ? aMinOffset : -aMaxOffset;
1905       aOffsetY *= anIt < 1 ? aMaxOffset :  aMinOffset;
1906     }
1907     else
1908     {
1909       aOffsetX *= anIt > 2 ?  aMaxOffset : -aMinOffset;
1910       aOffsetY *= anIt > 2 ? -aMinOffset : -aMaxOffset;
1911     }
1912     
1913     myPostFSAAProgram->SetUniform (myGlContext,
1914       myUniformLocations[1][OpenGl_RT_uSamples], anIt + 2);
1915     myPostFSAAProgram->SetUniform (myGlContext,
1916       myUniformLocations[1][OpenGl_RT_uOffsetX], aOffsetX);
1917     myPostFSAAProgram->SetUniform (myGlContext,
1918       myUniformLocations[1][OpenGl_RT_uOffsetY], aOffsetY);
1919
1920     Handle(OpenGl_FrameBuffer)& aFramebuffer = anIt % 2 ? myRaytraceFBO1 : myRaytraceFBO2;
1921
1922     if (anIt == 3) // disable FBO on last iteration
1923     {
1924       glEnable (GL_BLEND);
1925
1926       if (theFrameBuffer != NULL)
1927         theFrameBuffer->BindBuffer (myGlContext);
1928     }
1929     else
1930     {
1931       aFramebuffer->BindBuffer (myGlContext);
1932     }
1933     
1934     myGlContext->core15fwd->glDrawArrays (GL_TRIANGLES, 0, 6);
1935
1936     if (anIt != 3) // set input for the next pass
1937     {
1938       aFramebuffer->BindTexture  (myGlContext);
1939       aFramebuffer->UnbindBuffer (myGlContext);
1940     }
1941   }
1942
1943   myGlContext->core20fwd->glDisableVertexAttribArray (
1944     myUniformLocations[1][OpenGl_RT_aPosition]);
1945
1946   myPostFSAAProgram->Unbind (myGlContext);
1947
1948   return Standard_True;
1949 }
1950
1951 // =======================================================================
1952 // function : Raytrace
1953 // purpose  : Redraws the window using OpenGL/GLSL ray-tracing
1954 // =======================================================================
1955 Standard_Boolean OpenGl_Workspace::Raytrace (const Graphic3d_CView& theCView,
1956                                              const Standard_Integer theSizeX,
1957                                              const Standard_Integer theSizeY,
1958                                              const Standard_Boolean theToSwap,
1959                                              OpenGl_FrameBuffer*    theFrameBuffer)
1960 {
1961   if (!UpdateRaytraceGeometry (Standard_True))
1962     return Standard_False;
1963
1964   if (!InitRaytraceResources())
1965     return Standard_False;
1966
1967   if (!ResizeRaytraceBuffers (theSizeX, theSizeY))
1968     return Standard_False;
1969
1970   if (!UpdateRaytraceEnvironmentMap())
1971     return Standard_False;
1972
1973   // Get model-view and projection matrices
1974   TColStd_Array2OfReal theOrientation (0, 3, 0, 3);
1975   TColStd_Array2OfReal theViewMapping (0, 3, 0, 3);
1976
1977   myView->GetMatrices (theOrientation, theViewMapping);
1978
1979   NCollection_Mat4<GLdouble> aOrientationMatrix;
1980   NCollection_Mat4<GLdouble> aViewMappingMatrix;
1981
1982   for (Standard_Integer j = 0; j < 4; ++j)
1983   {
1984     for (Standard_Integer i = 0; i < 4; ++i)
1985     {
1986       aOrientationMatrix [4 * j + i] = theOrientation (i, j);
1987       aViewMappingMatrix [4 * j + i] = theViewMapping (i, j);
1988     }
1989   }
1990   
1991   NCollection_Mat4<GLdouble> aInvOrientationMatrix;
1992   aOrientationMatrix.Inverted (aInvOrientationMatrix);
1993
1994   if (!UpdateRaytraceLightSources (aInvOrientationMatrix))
1995     return Standard_False;
1996
1997   OpenGl_Vec3 aOrigins[4];
1998   OpenGl_Vec3 aDirects[4];
1999
2000   UpdateCamera (aOrientationMatrix,
2001                 aViewMappingMatrix,
2002                 aOrigins,
2003                 aDirects);
2004
2005   // Draw background
2006   glPushAttrib (GL_ENABLE_BIT |
2007                 GL_CURRENT_BIT |
2008                 GL_COLOR_BUFFER_BIT |
2009                 GL_DEPTH_BUFFER_BIT);
2010
2011   glDisable (GL_DEPTH_TEST);
2012
2013   if (NamedStatus & OPENGL_NS_WHITEBACK)
2014   {
2015     glClearColor (1.0f, 1.0f, 1.0f, 1.0f);
2016   }
2017   else
2018   {
2019     glClearColor (myBgColor.rgb[0],
2020                   myBgColor.rgb[1],
2021                   myBgColor.rgb[2],
2022                   1.0f);
2023   }
2024
2025   glClear (GL_COLOR_BUFFER_BIT);
2026
2027   if (theFrameBuffer != NULL)
2028     theFrameBuffer->BindBuffer (myGlContext);
2029
2030   myView->DrawBackground (*this);
2031
2032   // Generate ray-traced image
2033   glMatrixMode (GL_PROJECTION);
2034   glLoadIdentity();
2035
2036   glMatrixMode (GL_MODELVIEW);
2037   glLoadIdentity();
2038
2039   glEnable (GL_BLEND);
2040   glBlendFunc (GL_ONE, GL_SRC_ALPHA);
2041
2042   if (myIsRaytraceDataValid)
2043   {
2044     myRaytraceScreenQuad.Bind (myGlContext);
2045
2046     RunRaytraceShaders (theCView,
2047                         theSizeX,
2048                         theSizeY,
2049                         aOrigins,
2050                         aDirects,
2051                         theFrameBuffer);
2052
2053     myRaytraceScreenQuad.Unbind (myGlContext);
2054   }
2055
2056   if (theFrameBuffer != NULL)
2057     theFrameBuffer->UnbindBuffer (myGlContext);
2058
2059   glPopAttrib();
2060
2061   // Swap the buffers
2062   if (theToSwap)
2063   {
2064     GetGlContext()->SwapBuffers();
2065     myBackBufferRestored = Standard_False;
2066   }
2067   else
2068   {
2069     glFlush();
2070   }
2071
2072   return Standard_True;
2073 }