DrawablePolyLine.h

Go to the documentation of this file.

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

#ifndef GlobeEngine_DrawablePolyLine_h
#define GlobeEngine_DrawablePolyLine_h

#include "PolyLine.h"
#include "VBOVertex.h"
#include "OpenGL_Includes.h"
#include "DrawableComponent.h"

namespace geData {
    class DrawablePolyLine : public ge::DrawableComponent, public PolyLine
    {
        
    public:
        /*  0 = line,
         1 = triangulated with overlaps,
         2 = triangulated as nice ribbon,
         3 = gputriangulated
         */
        enum GEOMETRYDRAWMODE { LINES=0,
            TRIANGLES_OVERLAPPING,
            RIBBON,
            TRIANGLE_OCCLUSION,
            GPU_LINES};
        
        DrawablePolyLine();
        ~DrawablePolyLine();
        void clear();
        void create() {};
        void create(std::vector<vmml::Vector3d> _points);
        void create(std::shared_ptr<geData::PolyLine> _polyLine);
        void create(int _pointCount, double* _points);
        void create(int _pointCount, const vmml::Vector3d* _points);
        void create(int _pointCount, double* _points_x, double* _points_y, double* _points_alti, int _start);
        void update();
        void createVAO(GEOMETRYDRAWMODE _in);
        void createTriangleIndices();
        void createRibbonIndices();
        void setupGeometryBuffersWithLineStripInformation();
        void setupGeometryBuffersWithBSPlineInformation();
        void setupGeometryBuffersAsRibbons();
        void recreate(int _pointCount, double* _points);
        void recreate(int _pointCount, const vmml::Vector3d* _points);
        
        /* 0=line, 1=lineWithThickness, 2=triangulated, 3=gputriangulated */
        enum GEOMETRYDRAWMODE getDrawMode() const {
            return this->drawMode;
        };
        
        // inherited
        void draw(std::shared_ptr<ge::Camera> _cam);
        void drawWithOcclusionQueries(DrawableComponent::RENDERSTATE _state, std::shared_ptr<ge::Camera> _cam);
        void drawWithMultipleLines(std::shared_ptr<ge::Camera> _cam);
        
        bool isNeedingRefinement() const;
        void isNeedingRefinement(bool _in);
        
        // protected methods
        void setLineThickness(double _thickness);
        void activateGPUSplineInterpolation(bool _in);
        
        void setGPUSplineKnotVectorSize(int _size);
    private:
        void computeIntervals(int* u, int n, int t);
        void clearInitial();
        void getOpenGLError(std::string _input);
        
        GEOMETRYDRAWMODE drawMode;
        // Spline property
        bool needsRefinement;
        
        // Ribbon info
        unsigned int triangleCount;
        // occlusion queries
        // 0=not set 1=requested 2=finished
        // pixels showed the ground truth
        GLuint occlusionGroundTruth;
        GLuint renderPixelInLastFrame;
        GLuint checkForOcclusionResult;
        
        // GPU splines activated
        bool gpusplinesOn;
        int gpusplinesKnotVectorSize;
        
    };
}
#endif