HeatmapShapeCreateParams.h

#pragma once

#include "HeatmapShapes.h"
#include "ShapeCreateParamsBase.h"
#include "WeightedLatLongAltitude.h"


namespace Eegeo
{
    namespace Shapes
    {
        namespace Heatmaps
        {
            class HeatmapShapeCreateParams : public ShapeCreateParamsBase
            {
            public:
                HeatmapShapeCreateParams();

                HeatmapShapeCreateParams(
                    Eegeo::Positioning::ElevationMode::Type elevationMode,
                    double elevation,
                    const Eegeo::Resources::Interiors::InteriorId& indoorMapId,
                    int indoorMapFloorId,
                    const std::vector<Space::LatLongAltitude>& polygonVertexCoords,
                    const std::vector<int>& polygonRingVertexCounts,
                    const std::vector<Eegeo::Space::WeightedLatLongAltitude>& weightedPoints,
                    double weightMin,
                    double weightMax,
                    const v2& textureDimensions,
                    float textureBorderPercent,
                    const std::vector<float>& heatmapDensityStops,
                    const std::vector<double>& heatmapRadiiMeters,
                    const std::vector<double>& heatmapGains,
                    bool useApproximation,
                    float densityBlend,
                    bool interpolateDensityByZoom,
                    double zoomMin,
                    double zoomMax,
                    float opacity,
                    float intensityBias,
                    float intensityScale,
                    u32 occludedStencilMapLayerMask,
                    float occludedAlpha,
                    float occludedSaturation,
                    float occludedBrightness,
                    const std::vector<float>& gradientStops,
                    const std::vector<v4>& gradientColors
                );

                const std::vector<Space::LatLongAltitude>& GetPolygonVertexCoords() const { return m_polygonVertexCoords; }
                const std::vector<int>& GetPolygonRingVertexCounts() const { return m_polygonRingVertexCounts; }
                const std::vector<Eegeo::Space::WeightedLatLongAltitude>& GetWeightedPoints() const { return m_weightedPoints; }
                double GetWeightMin() const { return m_weightMin; }
                double GetWeightMax() const { return m_weightMax; }
                const v2& GetTextureDimensions() const { return m_textureDimensions; }
                float GetTextureBorderPercent() const { return m_textureBorderPercent; }
                const std::vector<float>& GetHeatmapDensityStops() const { return m_heatmapDensityStops; }
                const std::vector<double>& GetHeatmapRadiiMeters() const { return m_heatmapRadiiMeters; }
                const std::vector<double>& GetHeatmapGains() const { return m_heatmapGains; }
                bool GetUseApproximation() const { return m_useApproximation; }
                float GetDensityBlend() const { return m_densityBlend; }
                bool GetInterpolateDensityByZoom() const { return m_interpolateDensityByZoom; }
                double GetZoomMin() const { return m_zoomMin; }
                double GetZoomMax() const { return m_zoomMax; }
                float GetOpacity() const { return m_opacity; }
                float GetIntensityBias() const { return m_intensityBias; }
                float GetIntensityScale() const { return m_intensityScale; }
                u32 GetOccludedStencilMapLayerMask() const { return m_occludedStencilMapLayerMask; }
                float GetOccludedAlpha() const { return m_occludedAlpha; };
                float GetOccludedSaturation() const { return m_occludedSaturation; }
                float GetOccludedBrightness() const { return m_occludedBrightness; }
                const std::vector<float>& GetGradientStops() const { return m_gradientStops; }
                const std::vector<v4>& GetGradientColors() const { return m_gradientColors; }

            private:
                std::vector<Space::LatLongAltitude> m_polygonVertexCoords;
                std::vector<int> m_polygonRingVertexCounts;
                std::vector<Eegeo::Space::WeightedLatLongAltitude> m_weightedPoints;
                double m_weightMin;
                double m_weightMax;
                v2 m_textureDimensions;
                float m_textureBorderPercent;
                std::vector<float> m_heatmapDensityStops;
                std::vector<double> m_heatmapRadiiMeters;
                std::vector<double> m_heatmapGains;
                bool m_useApproximation;
                float m_densityBlend;
                bool m_interpolateDensityByZoom;
                double m_zoomMin;
                double m_zoomMax;
                float m_opacity;
                float m_intensityBias;
                float m_intensityScale;
                u32 m_occludedStencilMapLayerMask;
                float m_occludedAlpha;
                float m_occludedSaturation;
                float m_occludedBrightness;
                const std::vector<float> m_gradientStops;
                const std::vector<v4> m_gradientColors;
            };

        }
    }
}