HeatmapShapeView.h

#pragma once

#include "HeatmapShapes.h"
#include "ShapeViewBase.h"
#include "Rendering.h"
#include "VectorMath.h"
#include "SingleSphere.h"
#include "Geometry.h"
#include "Space.h"
#include "AsyncTexturing.h"

#include <vector>
#include <string>

namespace Eegeo
{
    namespace Shapes
    {
        namespace Heatmaps
        {
            class HeatmapShapeView : public ShapeViewBase
            {
            public:
                HeatmapShapeView(
                    const HeatmapShapeModel& heatmapShapeModel,
                    bool isHidden,
                    const dv3& originEcef,
                    const std::vector<dv3>& boundingPointsEcef,
                    const Eegeo::Geometry::SingleSphere& boundingSphere,
                    const Rendering::VertexLayouts::VertexLayout& vertexLayout,
                    Rendering::GlBufferPool& glBufferPool,
                    const m44& worldToTextureTransform,
                    float parameterizationHalfExtentMeters,
                    float floatDecodeScale,
                    Rendering::Mesh* pMesh,
                    HeatmapShapeRenderable* pHeatmapShapeRenderable,
                    HeatmapShapeRenderable* pHeatmapShapeRenderableOccluded,
                    Rendering::AsyncTexturing::Texture* pGradientTexture,
                    const std::vector<Rendering::AsyncTexturing::Texture*>& intensityTextures,
                    const std::string& indoorMapId,
                    int indoorMapFloorIndex
                );

                ~HeatmapShapeView();

                void Update();

                void UpdateIntensityTextures(
                    const v2& textureDimensions,
                    const std::vector<Eegeo::Space::WeightedLatLongAltitude>& weightedPoints,
                    float weightMin,
                    float weightMax,
                    float intensityBias,
                    const std::vector<double>& heatmapRadiiMeters,
                    const std::vector<double>& heatmapGains,
                    bool useApproximation
                );

                void UpdateGradientTexture(
                    const std::vector<float>& gradientStops,
                    const std::vector<v4>& gradientColors
                );

                void UpdateGeometry(
                    const dv3& meshOriginEcef,
                    const std::vector<v3>& meshPoints,
                    const std::vector<u16>& meshTriListIndices
                    );

                void UpdateUniforms(
                    float opacity,
                    float intensityBias,
                    float intensityScale,
                    float occludedStyleAlpha,
                    float occludedStyleSaturation,
                    float occludedStyleBrightness,
                    u32 nonOccludedStencilMapLayerMask,
                    u32 occludedStencilMapLayerMask,
                    bool isIndoor
                );

                void UpdateDensityBlend(
                    const std::vector<float>& heatmapDensityStops,
                    float densityBlend
                );

                void UpdateIndoorMap(
                    const std::string& indoorMapId,
                    int indoorMapFloorIndex
                    );

                Rendering::RenderableBase& GetRenderable() const;

                void GetRenderables(std::vector<Rendering::RenderableBase*>& out_renderables) const;

                const std::string& GetIndoorMapId() const { return m_indoorMapId; }

                int GetIndoorMapFloorIndex() const { return m_indoorMapFloorIndex; }

            private:

                Rendering::Mesh* CreateMesh(
                    const dv3& meshOriginEcef,
                    const std::vector<v3>& meshPoints,
                    const std::vector<v2>& textureCoords,
                    const std::vector<u16>& meshTriListIndices
                );

                const Rendering::VertexLayouts::VertexLayout& m_vertexLayout;
                Rendering::GlBufferPool& m_glBufferPool;
                const m44 m_worldToTextureTransform;
                const float m_parameterizationHalfExtentMeters;
                const float m_floatEncodeScale;
                Rendering::Mesh* m_pMesh;
                HeatmapShapeRenderable* const m_pHeatmapShapeRenderable;
                HeatmapShapeRenderable* const m_pHeatmapShapeRenderableOccluded;
                Rendering::AsyncTexturing::Texture* const m_pGradientTexture;
                std::vector<Rendering::AsyncTexturing::Texture*> m_intensityTextures;
                std::string m_indoorMapId;
                int m_indoorMapFloorIndex;
            };
        }
    }
}