ImplicitGridOcclusionResolver.h

#pragma once

#include "Labels.h"
#include "IOcclusionResolver.h"
#include "Types.h"
#include "IndexPairSet.h"
#include "VectorMath.h"

#include <vector>

namespace Eegeo
{
    namespace Labels
    {


        class ImplicitGridOcclusionResolver : public IOcclusionResolver, private Eegeo::NonCopyable
        {
        public:
            ImplicitGridOcclusionResolver(const v2& screenDimensions,
                                          int cellWidth,
                                          OcclusionResolverMode::Type occlusionMode);

            void Clear();

            void Shrink();

            InputListType& InputList() { return m_inputList; }

            InputLodListType& InputLodList() { return m_inputLodList; }

            void SetScreenDimensions(const v2& screenDimensions) { m_screenDimensions = screenDimensions; }

            void Resolve(const IOcclusionIntersectionPredicate& intersectionPredicate);

            const ResultsListType& GetResults() const { return m_resultsList; }

            void SetMode(OcclusionResolverMode::Type occlusionMode) { m_occlusionMode = occlusionMode; }


        private:
            struct GridAABB
            {
                int gridMinX;
                int gridMinY;
                int gridMaxX;
                int gridMaxY;
            };
            
            void ClearAllExceptInputLists();

            void ResetImplicitGrid();

            void StageLod(const int objectIndex);

            void UnstageLod(const int objectIndex);

            void PopulateDisabledOcclusionResults();

            void FindLodsIntersectingAABB(const int inputLodIndexA,
                                          std::vector<u32>& mergedXScratch,
                                          std::vector<u32>& mergedYScratch,
                                          std::vector<int>& out_inputLodsIntersectingAABB) const;

            bool Intersects(const int inputLodIndexA,
                            const std::vector<int>& potentiallyIntersectingInputLods,
                            const IOcclusionIntersectionPredicate& intersectionPredicate) const;

            inline int CellIndexFromGridCoord(int cellX, int cellY) const
            {
                return m_gridSizeX*cellY + cellX;
            }

            inline int GridCoordX(float x) const
            {
                return Math::Clamp(static_cast<int>(x / m_cellWidth), 0, m_gridSizeX - 1);
            }
            inline int GridCoordY(float y) const
            {
                return Math::Clamp(static_cast<int>(y / m_cellWidth), 0, m_gridSizeY - 1);
            }

            void PopulateGridAABBs(const std::vector<OcclusionInputLod>& inputAABBs, std::vector<GridAABB>& out_gridAABBs) const;

            size_t CalcStoreElementsPerCell() const
            {
                return (m_inputLodList.size() + 31) / 32;
            }

            bool Intersects(const int objectIndexA) const;

            struct SolutionEntry
            {
                s8 lod;
                s8 lodCount;
                s8 previousLod;
                bool solutionFound;
            };


            v2 m_screenDimensions;
            int m_cellWidth;
            OcclusionResolverMode::Type m_occlusionMode;
            float m_oneOverCellWidth;
            int m_gridSizeX;
            int m_gridSizeY;
            int m_storeElementsPerCell;

            InputListType m_inputList;
            InputLodListType m_inputLodList;
            ResultsListType m_resultsList;

            std::vector<int> m_inputLodsOrderedByPriority;
            std::vector<SolutionEntry> m_solutionVector;

            std::vector<GridAABB> m_gridAABBs;
            std::vector<u32> m_storeX;
            std::vector<u32> m_storeY;

            std::vector<u32> m_scratchMergedX;
            std::vector<u32> m_scratchMergedY;
            std::vector<int> m_scratchInputLodsIntersectingAABB;
        };
    }
}