0030483: Visualization, Path Tracing - make Tile Size configurable
[occt.git] / src / OpenGl / OpenGl_TileSampler.hxx
index 9fc9753..f956507 100644 (file)
 #include <OpenGl_Texture.hxx>
 #include <OpenGl_HaltonSampler.hxx>
 
+#include <Image_PixMapTypedData.hxx>
+
 #include <vector>
 
+class Graphic3d_RenderingParams;
+
 //! Tool object used for sampling screen tiles according to estimated pixel variance (used in path tracing engine).
 //! To improve GPU thread coherency, rendering window is split into pixel blocks or tiles. The important feature of
 //! this approach is that it is possible to keep the same number of tiles for any screen resolution (e.g. 256 tiles
@@ -32,85 +36,87 @@ class OpenGl_TileSampler
 {
 public:
 
-  //! Size of individual tile in pixels.
-  static int TileSize() { return 32; }
-
-public:
-
   //! Creates new tile sampler.
   Standard_EXPORT OpenGl_TileSampler();
 
-  //! Returns width of ray-tracing viewport.
-  int SizeX() const { return mySizeX; }
+  //! Size of individual tile in pixels.
+  Graphic3d_Vec2i TileSize() const { return Graphic3d_Vec2i (myTileSize, myTileSize); }
 
-  //! Returns height of ray-tracing viewport.
-  int SizeY() const { return mySizeY; }
+  //! Scale factor for quantization of visual error (float) into signed integer.
+  float VarianceScaleFactor() const { return myScaleFactor; }
 
   //! Returns number of tiles in X dimension.
-  int NbTilesX() const { return myTilesX; }
+  int NbTilesX() const { return (int)myTiles.SizeX; }
 
   //! Returns number of tiles in Y dimension.
-  int NbTilesY() const { return myTilesY; }
+  int NbTilesY() const { return (int)myTiles.SizeY; }
 
   //! Returns total number of tiles in viewport.
-  int NbTiles() const { return myTilesX * myTilesY; }
+  int NbTiles() const { return int(myTiles.SizeX * myTiles.SizeY); }
 
-  //! Specifies size of ray-tracing viewport.
-  Standard_EXPORT void SetSize (const int theSizeX,
-                                const int theSizeY);
+  //! Returns ray-tracing viewport.
+  const Graphic3d_Vec2i& ViewSize() const { return myViewSize; }
 
-  //! Returns number of pixels in the given tile.
-  int TileArea (const int theX,
-                const int theY) const
+  //! Number of tiles within offsets texture.
+  Graphic3d_Vec2i NbOffsetTiles (bool theAdaptive) const
   {
-    return Min (TileSize(), mySizeX - theX * TileSize())
-         * Min (TileSize(), mySizeY - theY * TileSize());
+    return theAdaptive
+         ? Graphic3d_Vec2i ((int )myOffsetsShrunk.SizeX, (int )myOffsetsShrunk.SizeY)
+         : Graphic3d_Vec2i ((int )myOffsets.SizeX,       (int )myOffsets.SizeY);
   }
 
+  //! Maximum number of tiles within offsets texture.
+  Graphic3d_Vec2i NbOffsetTilesMax() const { return NbOffsetTiles (true).cwiseMax (NbOffsetTiles (false)); }
+
+  //! Viewport for rendering using offsets texture.
+  Graphic3d_Vec2i OffsetTilesViewport (bool theAdaptive) const { return NbOffsetTiles (theAdaptive) * myTileSize; }
+
+  //! Maximum viewport for rendering using offsets texture.
+  Graphic3d_Vec2i OffsetTilesViewportMax() const { return NbOffsetTilesMax() * myTileSize; }
+
+  //! Specifies size of ray-tracing viewport and recomputes tile size.
+  Standard_EXPORT void SetSize (const Graphic3d_RenderingParams& theParams,
+                                const Graphic3d_Vec2i& theSize);
+
   //! Fetches current error estimation from the GPU and
   //! builds 2D discrete distribution for tile sampling.
-  Standard_EXPORT void GrabVarianceMap (const Handle(OpenGl_Context)& theContext);
-
-  //! Samples tile location according to estimated error.
-  Standard_EXPORT void Sample (int& theOffsetX,
-                               int& theOffsetY);
+  Standard_EXPORT void GrabVarianceMap (const Handle(OpenGl_Context)& theContext,
+                                        const Handle(OpenGl_Texture)& theTexture);
 
-  //! Resets tile sampler to initial state.
-  void Reset() { mySample = 0; }
+  //! Resets (restart) tile sampler to initial state.
+  void Reset() { myLastSample = 0; }
 
   //! Uploads offsets of sampled tiles to the given OpenGL texture.
-  Standard_EXPORT void Upload (const Handle(OpenGl_Context)& theContext,
-                               const Handle(OpenGl_Texture)& theTexture,
-                               const int                     theNbTilesX,
-                               const int                     theNbTilesY,
-                               const bool                    theAdaptive);
+  Standard_EXPORT bool UploadOffsets (const Handle(OpenGl_Context)& theContext,
+                                      const Handle(OpenGl_Texture)& theOffsetsTexture,
+                                      const bool theAdaptive);
 
 protected:
 
-  //! Returns tile value (estimated error).
-  float Tile (const int theX,
-              const int theY) const
+  //! Returns number of pixels in the given tile.
+  int tileArea (int theX, int theY) const
   {
-    return myVarianceMap[theY * myTilesX + theX];
+    const int aSizeX = Min (myTileSize, myViewSize.x() - theX * myTileSize);
+    const int aSizeY = Min (myTileSize, myViewSize.y() - theY * myTileSize);
+    return aSizeX * aSizeY;
   }
 
-  //! Returns tile value (estimated error).
-  float& ChangeTile (const int theX,
-                     const int theY)
-  {
-    return myVarianceMap[theY * myTilesX + theX];
-  }
+  //! Samples tile location according to estimated error.
+  Standard_EXPORT Graphic3d_Vec2i nextTileToSample();
 
 protected:
 
-  std::vector<float>   myVarianceMap; //!< Estimation of visual error per tile
-  std::vector<float>   myMarginalMap; //!< Marginal distribution of 2D error map
-  OpenGl_HaltonSampler mySampler;     //!< Halton sequence generator
-  int                  mySample;      //!< Index of generated sample
-  int                  mySizeX;       //!< Width of ray-tracing viewport
-  int                  mySizeY;       //!< Height of ray-tracing viewport
-  int                  myTilesX;      //!< Number of tiles in X dimension
-  int                  myTilesY;      //!< Number of tiles in Y dimension
+  Image_PixMapTypedData<unsigned int>    myTiles;         //!< number of samples per tile (initially all 1)
+  Image_PixMapTypedData<float>           myVarianceMap;   //!< Estimation of visual error per tile
+  Image_PixMapTypedData<int>             myVarianceRaw;   //!< Estimation of visual error per tile (raw data)
+  Image_PixMapTypedData<Graphic3d_Vec2i> myOffsets;       //!< 2D array of tiles redirecting to another tile
+  Image_PixMapTypedData<Graphic3d_Vec2i> myOffsetsShrunk; //!< 2D array of tiles redirecting to another tile (shrunk)
+  std::vector<float>                     myMarginalMap;   //!< Marginal distribution of 2D error map
+  OpenGl_HaltonSampler                   mySampler;       //!< Halton sequence generator
+  unsigned int                           myLastSample;    //!< Index of generated sample
+  float                                  myScaleFactor;   //!< scale factor for quantization of visual error (float) into signed integer
+  int                                    myTileSize;      //!< tile size
+  Graphic3d_Vec2i                        myViewSize;      //!< ray-tracing viewport
 
 };