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