KPatchBintree.h

Go to the documentation of this file.

#ifndef GlobeEngine_Raster_KPatchbintree_h
#define GlobeEngine_Raster_KPatchbintree_h

#include "OpenGL_Includes.h"
#include "KPatchBase.h"
#include "KPatchBintreeNode.h"
#include "DrawableComponent.h"
#include "MBlockQuadtree.h"
#include "MBlock.h"
#include "ArrayTree.h"
#include "BufferArray.h"
#include "Buffer.h"
#include "DrawCommand.h"
#include "Timer.h"
#include "TerrainConfigStructs.h"

namespace geRaster {
    
    class KPatchBintree : public ge::DrawableComponent
    {
    
    public:
        KPatchBintree();
        ~KPatchBintree();
        void clear();
        void clearBintree();
        void create() {};
        void create(std::shared_ptr<MBlockQuadtree> _quadtree, short _max_lod, double _max_dist_error, KPatchBase::PatchMode _mode, vmml::Vector3d _pos,short _maxQuadtreeLodLevels);
        void draw(std::shared_ptr<ge::Camera> _cam);
        void update();
        void drawPrimitives();
        
        void saturateError(int _uid, vmml::Vector3d _pos);
        void generateBintree(const vmml::Vector3d _pos);
        //void generateBintreeNodes(int _uid, const vmml::Vector3d& _pos);
        void generateBintreeNodesAtLod(int _uid, int _lod, const vmml::Vector3d& _pos);

        //void assignKPatchesToMBlocks();
        void sortVisibleKPatchToMBlocks();
        void createGeometry();
        void updateUniformBuffers();
        
        void printKPatchBintree(unsigned int _lod);
        void printKPatchBintreeGeometryInformation(unsigned int _lod);
        void printVertexArray();
        void printIndexArray();
        void printBuffers();
        void drawDebug(std::shared_ptr<ge::Camera> _cam);
        
        void rescale(float _input);

        void setVisualizationType(TerrainVis::VisualizationMode _input);
        void updateVisualizationTypeInShader();

        void updateUniformBlockBinding();

    private:
        bool checkDistanceCriterionForBin(int _uid, const vmml::Vector3d& _pos);
        //void balanceUp(int _searchID);
        void restrictNeighbour(int _nodeId, bool _order);
        int getIDFromBitset(std::bitset<40> const& _bitset, short _lod, short _bintreeRoot);
        void setMBlockRef(int _uid, int _refID);
        void clearInitial();
        //Tree resolution interface
        void createRootChildren();
        void forceSplitOnBin(int _nodeId);
        
    private:

        std::shared_ptr<MBlockQuadtree> quadtree;
        std::vector< std::shared_ptr<KPatchBintreeNode> > bins;
        
        // draw state
        TerrainVis::VisualizationMode visMode;

        // contains information if bin is visible or not
        int binCapacity;
        
        // visibleIndices are sorted according to MBlocks
        std::vector<int> visibleKPatches;
        int visibleKPatchesSize;
        bool isParent;
        double bounds[4];
        double edgelength;
        int children[2];
        short patchSize;
        
        bool updateShader;
        
        // Error metrix parameters
        short maxBintreeLod;
        double max_dist_for_error_metric;
        double distErrorStepPerLod;
        
        //BintreeGPUBuffer frontbuffer;
        TriangulationGPUBuffer backbuffer;
        
        KPatchBase::PatchMode mode;
        TerrainVis::ErrorMetricType metrictype;
        
        // Reference KPatch info
        std::shared_ptr<KPatchBase> basePatch;
        int kPatchIndexCount; 
        int kPatchSideLenght;
        // should only be necessary when changing kpatch properties
        //  or only the first time generating geometry
        bool kpatchInfoUpdateNecessary; 

        float rescaleValue;
        // uniform buffer
        ge::UniformBufferArray triangulationInfo;
        
#ifndef GENGINE_GL_BELOW_410
        ge::DrawIndirectBuffer indirectCommandBuffer;
#endif
        ge::Timer openglTimer;

        // avoid allocation in createGeometry()
        std::vector<ge::DrawArraysIndirectCommand> indirectCommands;
    };
}
#endif