LineFeatureObject.h

Go to the documentation of this file.

#ifndef GlobeEngine_LineFeatureObject_h
#define GlobeEngine_LineFeatureObject_h

#include <vector>
#include "FeatureObject.h"
#include "MultiLineObject.h"
#include "BufferArray.h"
#include "MortonOrder.h"
#include "ClusterGrid.h"
#include "StyleCollection.h"

namespace geGIS {
    
    class LineFeatureObject : public FeatureObject
    {
        
    public:
        LineFeatureObject();
        ~LineFeatureObject();
        void clear() override;
        void create(std::shared_ptr<ge::Shader> _shader, std::string _name, vmml::Vector3f _color);
        void create(std::shared_ptr<ge::Shader> _shader, std::string _name, const GLuint _uid, const GLuint _guid, vmml::Vector3f _color, vmml::Vector3d _position, vmml::Vector3d _scale, vmml::Vector3d _rotations);
        void recreateMultiLineObject(std::string _name);
        virtual void update() override;
        virtual void draw(std::shared_ptr<ge::Camera> _cam) override;
        virtual void createVAO(enum geData::MultiLineObject::GEOMETRYMODE _in);
        
        /* load geometry functions */
        void load2DLines(geGIS::FeatureRange _range);
        void load3DLines(geGIS::FeatureRange _range);
        void load2DPolygonsWithLimitedLines(geGIS::FeatureRange _entityRange, geGIS::FeatureRange _lineRange);
        
        void setExtrusionXZ(double _input);
        void setExtrusionY(double _input);
        void setLineThickness(float _input);
        float getLineThickness() const;
        enum GEOMETRYDRAWMODE getDrawMode() const{ return this->drawMode; };
        int getGraphPointCount() const;
        
        void addPolyline(std::shared_ptr<geData::PolyLine> _polyline);
        const std::shared_ptr<geData::PolyLine> getEntity(int _idx) const;
        virtual void performAnimationStep();
        
        vmml::Vector4d expandBoundWith2DPoint(ge::Vertex2d _point, vmml::Vector4d _bound);
        ge::Vertex4d expandBound(ge::Vertex4d _point, ge::Vertex4d _bound);
        ge::Vertex4d expandBoundWithRadius(ge::Vertex4d _point, ge::Vertex4d _bound, double _radius);
        
        // overrides
        void resetColor();
        void setColor(vmml::Vector3f _color) override;
        void setUID(GLuint _input) override;
        void setGroupID(GLuint _input) override;
        void setScale(vmml::Vector3d _scale) override;
        void setPosition(vmml::Vector3d _position) override;
        void setRotation(vmml::Vector3d _rotations) override;
        void setColorPerVertex(unsigned int _in) override;

        // GPU Feature buffer properties for morton curves
        void createGPUFeatureBufferAsMortonCurve();
        GLuint getGPUFeatureBufferHandle(GLuint _layer);
        unsigned int getGPUFeatureMaxDepth();
        void loadAttributeGPUBuffer(int _bufferLayerID, std::shared_ptr<StyleCollection> _styling, bool _spaceFillingCurve);
        std::vector<size_t> loadMortonOrderForGPUBuffer(const std::vector<ge::Vertex2d>& _linesegmentList, ge::AABB3f _AABB);
        void copyLineSegmentToGPUBuffer(int _bufferLayerID, bool _spaceFillingCurve);
        void copyBoundsArrayToGPUBuffer(int _bufferLayerID);
        void createLineSegmentListForGPUBuffer();
        void createMortonLineSegmentBounds();
        vmml::Vector4d getBounds2DWithLineWidth();

        // GPU Feature buffer properties for clustered shading
        void createGPUFeatureBufferForClusteredShading(vmml::Vector2ui _clusterCount, double _linewidth, std::shared_ptr<StyleCollection> _styling);
        void createClusteredMortonLineSegmentBounds();
        vmml::Vector2f getClusterSize();

        const ClusterGridTextures* getClusterHandles();

    private:
        void create() override;
        void createVAO(enum GEOMETRYDRAWMODE _in) override {};
        void clearInitial();
        ge::Vertex4d setBoundCorrectly(ge::Vertex2d _p1, ge::Vertex2d _p2);

    protected:
        
        std::shared_ptr<geData::MultiLineObject> multilineGeometry;
        double lineThickness;

        // GPU Feature buffer properties
#ifdef __APPLE__
        ge::PixelUnpackBufferArray gpuFeatureInfo;
#else
        ge::ShaderStorageBufferArray gpuFeatureInfo;
#endif
        std::vector<size_t> resMorton;

        unsigned int gpuFeatureMaxLevel;
        unsigned int gpulineSegmentCount;
        unsigned int gpulineSegmentListPointCount;
        /* set up line information */
        std::vector<ge::Vertex2d> gpulinesegmentList;

        // array to copy the bounds
        std::vector<ge::Vertex4d> boundsFinal;

        // GPU Feature buffer for clustered shading properties
        ClusterGrid cgrid;

        // polygon rendering
        bool fillLineFeature;
        void loadPolygonAttributesToGPUBuffer(int _bufferLayerID, bool _spaceFillingCurve);

    };
}

#endif