src/OpenGl/OpenGl_SceneGeometry.hxx

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