InstancedInteriorFloorRenderable.h

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

#pragma once

#include "Interiors.h"
#include "InteriorRenderable.h"
#include "LayerIds.h"
#include "Rendering.h"
#include "Culling.h"
#include "VectorMath.h"
#include "InteriorsStencilMirrorType.h"
#include "SingleSphere.h"
#include "InstancedRenderState.h"

#include <vector>
#include <string>

namespace Eegeo
{
    namespace Rendering
    {
        namespace Renderables
        {
            class InstancedInteriorFloorRenderable : public InteriorRenderable
            {
            public:
                
                InstancedInteriorFloorRenderable(LayerIds::Values layerId,
                                                 int floorIndex,
                                                 Materials::IMaterial* material,
                                                 Rendering::Mesh* pMesh,
                                                 Culling::CullingVolumeTree* pCullingVolumeTree,
                                                 const VertexLayouts::VertexBinding& vertexBinding,
                                                 Eegeo::dv3 ecefLocalOrigin,
                                                 Eegeo::v4 positionBoundsMin,
                                                 Eegeo::v4 positionBoundsMax,
                                                 Eegeo::v2 uvBoundsMin,
                                                 Eegeo::v2 uvBoundsMax,
                                                 const std::string& renderableId,
                                                 const Resources::Interiors::IInteriorsMaterialAssignmentObserver& materialAssignmentObserver,
                                                 const float interiorTerrainHeight,
                                                 bool ownsMesh,
                                                 const std::vector<m44>& instanceTransforms,
                                                 const std::string& interiorIdentifier);
                
                virtual ~InstancedInteriorFloorRenderable();
                
                void SetInstancedRenderState(const InstancedRenderState& renderState);

                bool UpdateVisibility(const Eegeo::Geometry::Frustum& viewFrustum, Culling::CullingVolumeVisibilityUpdater& visibilityUpdater, float environmentScale);

                virtual void Render(Rendering::GLState& glState) const;

                bool IsHighlighted(int instanceIndex) const;

                v4 GetHighlightColor(int instanceIndex) const;

                int GetInstanceCount() const;

                const m44& GetInstanceTransformAtIndex(int index) const;

                virtual void SetInstanceTransformAtIndex(int index, const m44& transform);

                virtual void AddInstanceTransform(const m44& transform);

                virtual void RemoveInstanceTransformAtIndex(int index);

                const InstancedRenderState& GetInstancedRenderState() const { return m_instancedRenderState; }
                
                virtual void UpdateIndexColor(int index, const v4& color);

                const Eegeo::Geometry::SingleSphere& GetInstancedBoundingSphere(int index) const { return m_instanceBounds.at(index); }

                const bool IsInstanceVisible(int index) const { return m_visibleInstances.at(index); }
                
            private:

                void UpdateCullingBounds();

                // mutable canonical state
                std::vector<m44> m_instanceTransforms;

                InstancedRenderState m_instancedRenderState;
                
                Eegeo::Geometry::SingleSphere m_overallBounds;
                std::vector<Eegeo::Geometry::SingleSphere> m_instanceBounds;
                std::vector<bool> m_visibleInstances;
                Eegeo::Geometry::SingleSphere m_localBounds;
                bool m_isCullingBoundsDirty;
            };
        }
    }
}