IOcclusionResolver.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Labels.h"
#include "Types.h"
#include "VectorMathDecl.h"

#include <vector>

namespace Eegeo
{
    namespace Labels
    {
        struct OcclusionInput
        {
            int priority;
            int subPriority;
            int tiebreakPriority;
            int lodCount;
            int currentLod;
            
            OcclusionInput(int priority_,
                           int subPriority_,
                           int tiebreakPriority_,
                           int lodCount_,
                           int currentLod_)
            : priority(priority_)
            , subPriority(subPriority_)
            , tiebreakPriority(tiebreakPriority_)
            , lodCount(lodCount_)
            , currentLod(currentLod_)
            {
                
            }
        };
        
        struct OcclusionInputLod
        {
            int inputIndex;
            int lod;
            float minX;
            float minY;
            float maxX;
            float maxY;
            
            OcclusionInputLod(int inputIndex_,
                               int lod_,
                               float minX_,
                               float minY_,
                               float maxX_,
                               float maxY_)
            : inputIndex(inputIndex_)
            , lod(lod_)
            , minX(minX_)
            , minY(minY_)
            , maxX(maxX_)
            , maxY(maxY_)
            {}
        };
        
        struct OcclusionResult
        {
            int inputIndex;
            int desiredLod;
            
            bool IsCompletelyOccluded() const { return desiredLod < 0; }
            
            OcclusionResult(int inputIndex_, int desiredLod_)
            : inputIndex(inputIndex_)
            , desiredLod(desiredLod_)
            {
            }
        };
        
        class IOcclusionIntersectionPredicate
        {
        public:
            virtual ~IOcclusionIntersectionPredicate() {}
            virtual bool operator()(const OcclusionInputLod& a, const OcclusionInputLod& b) const = 0;
        };

        namespace OcclusionResolverMode
        {
            enum Type
            {
                Never,
                Always
            };
        };
        
        
        class IOcclusionResolver
        {
        public:
            typedef std::vector<OcclusionInput> InputListType;
            typedef std::vector<OcclusionInputLod> InputLodListType;
            typedef std::vector<OcclusionResult> ResultsListType;
            
            virtual ~IOcclusionResolver() {}
            
            virtual void Clear() = 0;
            
            virtual void Shrink() = 0;
            
            virtual void SetMode(OcclusionResolverMode::Type occlusionMode) = 0;
            
            virtual void SetScreenDimensions(const v2& screenDimensions) = 0;
            
            virtual InputListType& InputList() = 0;
            
            virtual InputLodListType& InputLodList() = 0;
            
            virtual void Resolve(const IOcclusionIntersectionPredicate& intersectionPredicate) = 0;
            
            // only objects that have changed occlusion state are present on results list
            virtual const ResultsListType& GetResults() const = 0;
        };
    }
}