DtTileSpaceLightGrid.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2014 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 

#pragma once

#include "DtGraphicsUtilsPreReqs.h"
#include "DtMatrix4.h"

#pragma warning( push )
#pragma warning( disable : 4251 )

// the maximum number if lights supported, this is limited by constant buffer size, 
// commonly this is 64kb, but AMD only seem to allow 2048 lights...
#define NUM_POSSIBLE_LIGHTS (1024)

// Must be a power of two, configure to suit hardware/wishes, also limited at 
// runtime by glGet GL_MAX_COLOR_TEXTURE_SAMPLES. The smaller value is used.
#define MAX_ALLOWED_MSAA_SAMPLES 16

#include "DtCameraFwdDeclare.h"
#include "DtForwardDeclare.h"
FORWARD_DECLARE_DIFFERENT_SUFFIX(DtLight, Light)
#include "DtVector2.h"
#include "DtScreenRect.h"
#include "DtIntSize.h"

   namespace makVrv {

      typedef std::vector<uint32> VectorAreas;

      class DT_DLL_VRVGRAPHICSUTILS DtTileSpaceLightGrid
      {
      public:
         DtTileSpaceLightGrid();

         virtual ~DtTileSpaceLightGrid();


         void setTileSize(Vector2_uint32 tileSize);
         const Vector2_uint32& tileSize(void) const;

         
         const Vector2_uint32& gridMaxDims(void) const;
         uint32 getGridMaxDimsFlattened(void) const;

      

         void update(const VectorLights& frustumVisibleLights
            , const Camera_64* pCamera
            , const Vector2_uint32& viewportSize);

         void update(const VectorLights& frustumVisibleLights
            , const Matrix4_64& view_projection_matrix
            , const Vector2_uint32& viewportSize);
         


         int tileLightCount(uint32 x, uint32 y) const;
         const int *tileLightIndexList(uint32 x, uint32 y) const;




         const int *tileDataPtr() const 
         { 
            return myGridOffsets; 
         }
         const int *tileCountsDataPtr() const 
         { 
            return myGridCounts; 
         }
         const int *tileLightIndexListsPtr() const 
         { 
            return &myTileLightIndexLists[0]; 
         }

         uint32 totalTileLightIndexListLength() const 
         { 
            return uint32(myTileLightIndexLists.size()); 
         }

         

         void setScreenAreaCullSize(uint32 val);
         uint32 screenAreaCullSize(void) const;

      private:
         void updateScreenSpaceRectangles(const VectorLights& frustumVisibleLights
            , const Matrix4_64& view_projection_matrix
            , const Vector2_uint32& viewportSize
            , const Vector2_uint32& tileSize);

         Vector2_uint32 myTileSize;

#if 0
         const Vector2_32 getTileMinMax(uint32 x, uint32 y) const 
         { 
            return m_minMaxGridValid ? 
               m_gridMinMaxZ[x + y * m_gridDim.x] 
             : chag::make_vector(0.0f, 0.0f); 
         }
         std::vector<chag::float2> m_gridMinMaxZ;
#endif

         static const Vector2_uint32 m_InitialMaxScreenResolution;
         Vector2_uint32 myCurrentMaxScreenResolution;
         void updateToAccountForScreenRes(const Vector2_uint32& viewport_size);

         Vector2_uint32 myGridMaxDims;

         int32* myGridOffsets;
         int32* myGridCounts;

         std::vector<int> myTileLightIndexLists;
         uint32 myMaxTileLightCount;
         bool myMinMaxGridValid;

         ConstVectorLights myViewSpaceLights;
         VectorScreenRectangles myScreenRects;

         VectorAreas myScreenRectAreas;

         int& GridOffset(int x, int y)
            {
               return myGridOffsets[x + y * myGridMaxDims.x];
            }
         int& GridCount(int x, int y)
            {
               return myGridCounts[x + y * myGridMaxDims.x];
            }

         uint32 myRejectArea;
      };

} //namespace makVrv

#pragma warning(pop)