MultiLineObject.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_MultiLineObject_h
#define GlobeEngine_MultiLineObject_h

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

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

        int addLine(vmml::Vector3d _start, vmml::Vector3d _end);

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

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

        void removePolyline(int _id);

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

        void createVAO(enum GEOMETRYMODE _mode=LINES);

        void setLineWeight(int _lineIdx, double _wheight);
        void setLineWeightAndColor(int _idx, double _wheight, vmml::Vector3f _color);
        void addToLineWeight(int _idx, double _value);
        double getLineWeight(int _idx);
        vmml::Vector3f getLineWeightColor(int _idx);

        void setLineThickness(double _input);
        int getLineCount();
        void setLineCount(int _input);
        int getLineSize();
        int getGraphPointCount() const;
        double getLineThickness();
        void setWheightedColorBuffer(int _bufferID);
        
        enum GEOMETRYMODE getDrawMode() const{ return this->geometryDrawmode; };
        
        void setExtrusionXZ(double _input);
        void setExtrusionY(double _input);
        
        // geometry setup
        void setGeometryBuffer(int _bufferID);
        void setGeometryBufferAsRibbons(int _bufferID);
        void setColorBuffer(int _bufferID, const vmml::Vector3f* _color=NULL);
        void setAnimatedColorBuffer(int _bufferID, const vmml::Vector3f* _animationColor);
        void setPickIDBuffer(int _bufferID);

        void setLinestripIndices();
        void setIndicesForLines();
        void setIndicesForOverlappingTriangles();
        void setIndicesForRibbons();
        void clearGeometryMemory();
        
        bool isAnimatedColorUpdated() {
            return animatedColorUpdate;
        };
        
        void moveAnimationForward();
        void moveAnimationBackward();
        
        void setAnimatedTimeStep(float _timeStep);

    private:  
        void allocateLineStripArray(int _size);
        void createPointerList();

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

        GEOMETRYMODE geometryDrawmode;

        // number of line segments per line
        int lineSize;
        // number of lines
        int lineCount;
        double lineThickness;
        // Rendering structures
        GLsizei* lineStripLenght;
        
        // line info
        int maxPointCountInALine;
        bool animatedColorUpdate;

        // Extrusion variables
        float extrusionXZ;
        float extrusionY;

        // animation variables
        float animatedTimeStep;
    };
}
#endif