CollisionVisualizationRenderable.h

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

#pragma once


#include "RenderableBase.h"
#include "Types.h"
#include "Collision.h"
#include "CollisionVisualization.h"
#include "Rendering.h"
#include "SingleSphere.h"

#include <array>
#include <string>

namespace Eegeo
{
    namespace CollisionVisualization
    {
        class CollisionVisualizationRenderable : public Eegeo::Rendering::RenderableBase
        {
        public:
            CollisionVisualizationRenderable(Rendering::Mesh* pMesh,
                                             Rendering::LayerIds::Values layerId,
                                             const dv3& ecefPosition,
                                             const Rendering::Materials::IMaterial& material,
                                             const Rendering::VertexLayouts::VertexBinding& vertexBinding,
                                             const Eegeo::Geometry::SingleSphere& boundingSphere,
                                             const Eegeo::v4& initialColor,
                                             bool depthTest,
                                             bool depthWrite,
                                             bool depthBias,
                                             bool alphaBlend);
            
            virtual ~CollisionVisualizationRenderable();
            
            virtual m44 CalcModelViewProjection(const dv3& ecefCameraPosition, const m44& viewProjection, const float environmentFlatteningScale) const;
            
            virtual void Render(Rendering::GLState& glState) const;
            
            virtual void OnMaterialChanged(const Rendering::Materials::IMaterial* pMaterial, Eegeo::Rendering::VertexLayouts::VertexBindingPool& vertexBindingPool);

            virtual const v4& GetColor() const { return m_color; }
            virtual const std::vector<std::array<v4, 2>>& GetHeightClipPlanes() const { return m_heightClipPlanes; }
            virtual bool IsDepthTest() const { return m_depthTest; }
            virtual bool IsDepthWrite() const { return m_depthWrite; }
            virtual bool IsDepthBias() const { return m_depthBias; }
            virtual bool IsAlphaBlend() const { return m_alphaBlend; }

            virtual const std::array<v4, 2>& GetCurrentHeightClipPlanePair() const;

            virtual void SetColor(const v4& color) { m_color = color; }
            virtual void SetHeightClipPlanes(const std::vector<std::array<v4, 2>>& heightClipPlanes) { m_heightClipPlanes = heightClipPlanes; }
            virtual void SetDepthTest(bool enabled) { m_depthTest = enabled; }
            virtual void SetDepthWrite(bool enabled) { m_depthWrite = enabled; }
            virtual void SetDepthBias(bool enabled) { m_depthBias = enabled; }
            virtual void SetAlphaBlend(bool enabled) { m_alphaBlend = enabled; }
            
            virtual Eegeo::Geometry::SingleSphere GetBoundingSphere() const { return m_boundingSphere; }
            
        private:
            Rendering::Mesh* m_pMesh;
            const Eegeo::Geometry::SingleSphere m_boundingSphere;
            v4 m_color;
            std::vector<std::array<v4, 2>> m_heightClipPlanes;
            bool m_depthTest;
            bool m_depthWrite;
            bool m_depthBias;
            bool m_alphaBlend;

            mutable std::vector<std::array<v4, 2>>::const_iterator m_currentHeightClipPlanePair;
        };
    }
}