MultiPolygonObject.h

Go to the documentation of this file.

//
//  Polyline.h
//  GlobeEngine
//
//  Created by Mathias Thöny on 27.12.11.
//  Copyright (c) 2011 University of Zurich. All rights reserved.
//

#ifndef GlobeEngine_MultiPolygonObject_h
#define GlobeEngine_MultiPolygonObject_h

#include <vmmlib/vmmlib.hpp>
#include "DrawableComponent.h"
#include "VBOVertex.h"
#include "OpenGL_Includes.h"
#include "PolyLine.h"
#include "PLYObject.h"
#include "ColorisationTable.h"
#include "MultiLineObject.h"

namespace geData {
    class MultiPolygonObject : public ge::DrawableComponent
    {
    public:
        /* 0 = line,
         1 = triangulated with overlaps,
         2 = triangulated as nice ribbon,
         3 = gputriangulated
         */
        enum GEOMETRYMODE { LINES=0,
            TRIANGLES_OVERLAPPING,
            EXTRUDED_GEOMETRY,
            RIBBON, TRIANGULATED };
        
        MultiPolygonObject();
        ~MultiPolygonObject();
        void clear();
        void create();
        void update();
        void draw(std::shared_ptr<ge::Camera> _cam);
        void drawWithStandardShader(std::shared_ptr<ge::Camera> _cam);
        void drawTextured(std::shared_ptr<ge::Camera> _cam, std::vector< GLuint > _texHandles);

        int addPolygon(std::shared_ptr<PolyLine> _polyline);

        void updatePolygon(int _id, std::shared_ptr<PolyLine> _polyline);

        void removePolygon(int _id);

        void insertPolygon(int _id, std::shared_ptr<PolyLine> _polyline);
        const std::shared_ptr<PolyLine> getPolygon(int _idx) const;

        void createVAO(enum GEOMETRYMODE _mode=LINES);
        
        void setPolygonWeight(int _lineIdx, double _wheight);
        void setPolygonWeightAndColor(int _idx, double _wheight, vmml::Vector3f _color);
        void addToPolygonWeight(int _idx, double _value);
        double getPolygonWeight(int _idx);
        vmml::Vector3f getPolygonWeightColor(int _idx);

        int getPolygonCount();
        void setWheightedColorBuffer(int _bufferID);
        
        enum GEOMETRYMODE getDrawMode() const{ return this->geometryDrawmode; };

        void setExtrusionY(double _input);
        
        void loadTriangulatedMesh(std::string _nameurl);
        void loadPolygonsFromPLY(std::string _nameurl);
        void savePolygonsToPLY(std::string _path);
        void copyColorInformationToGPU(vmml::Vector3d _pickcolor = vmml::Vector3d(0.0, 0.0, 0.0), int _picked = -1, const std::shared_ptr<geData::ColorisationTable>& _colorTable = NULL);

        // geometry setup
        void setGeometryBuffer(int _bufferID);
        void setTextureCoordBuffer(int _bufferID);
        //void setGeometryBufferAsRibbons(int _bufferID);
        void setColorBuffer(int _bufferID, const vmml::Vector3f* _color=NULL);
        void updateColorBuffer(vmml::Vector3f _color);
        void setPickIDBuffer(int _bufferID);

        void setPolygonIndices();
        void clearGeometryMemory();
        void createTriangleIndices();

        void createTriangulation(std::shared_ptr<geData::MultiLineObject> _multilineGeometry, std::vector<int> _entityAssociation);
        //void copyTriangleInformationToGPU();

        bool isTriangulated() {
            return this->triangulated;
        }

    private:  
        std::vector< std::shared_ptr<PolyLine> > entities;
        std::vector<double> weights;
        std::vector<vmml::Vector3f> weightColors;

        GEOMETRYMODE geometryDrawmode;

        // number of lines
        int polygonCount;
        int polygonLineSum;
        int triangleCount;
        // Rendering structures
        GLsizei* lineStripLenght;
        
        float extrusionY;

        bool triangulated;

        int colorBuffer;

        // Triangulated information
        std::vector< vmml::Vector3d > points;
        std::vector< vmml::Vector2d > minboundPerPolygon;
        std::vector< vmml::Vector2d > maxboundPerPolygon;
        std::vector<int> polygonStartIdx; 
        std::vector<int> polygonIndexCount;
        std::vector<int> polygonEntityAssociation;
    };

}
#endif