GeometryHandler.h

Go to the documentation of this file.

 
#ifndef VISUALIZER_GEOMETRY_HANDLER_H
#define VISUALIZER_GEOMETRY_HANDLER_H
 
#include <unordered_set>
#include "global.h"
 
class GeometryHandler {
private:
    struct PrimitiveIndexMap;
 
public:
 
    enum VisualizerGeometryType { GEOMETRY_TYPE_RECTANGLE = 1, GEOMETRY_TYPE_TRIANGLE = 2, GEOMETRY_TYPE_POINT = 3, GEOMETRY_TYPE_LINE = 4 };
 
    GeometryHandler() : random_generator(std::random_device{}()) {
        for (const auto &geometry_type: all_geometry_types) {
            face_index_data[geometry_type] = {};
            vertex_data[geometry_type] = {};
            normal_data[geometry_type] = {};
            color_data[geometry_type] = {};
            uv_data[geometry_type] = {};
            texture_flag_data[geometry_type] = {};
            texture_ID_data[geometry_type] = {};
            coordinate_flag_data[geometry_type] = {};
            visible_flag_data[geometry_type] = {};
            context_geometry_flag_data[geometry_type] = {};
            delete_flag_data[geometry_type] = {};
            size_data[geometry_type] = {};
        }
    }
 
 
    void allocateBufferSize(size_t primitive_count, VisualizerGeometryType geometry_type);
 
    void addGeometry(size_t UUID, const VisualizerGeometryType &geometry_type, const std::vector<helios::vec3> &vertices, const helios::RGBAcolor &color, const std::vector<helios::vec2> &uvs, int textureID, bool override_texture_color,
                     bool has_glyph_texture, uint coordinate_system, bool visible_flag, bool iscontextgeometry, int size = 0);
 
    void markDirty(size_t UUID);
 
    [[nodiscard]] const std::unordered_set<size_t> &getDirtyUUIDs() const;
 
    void clearDirtyUUIDs();
 
    [[nodiscard]] bool doesGeometryExist(size_t UUID) const;
 
    [[nodiscard]] std::vector<size_t> getAllGeometryIDs() const;
 
    [[nodiscard]] size_t getPrimitiveCount(bool include_deleted = true) const;
 
    [[nodiscard]] size_t getRectangleCount(bool include_deleted = true) const;
 
    [[nodiscard]] size_t getTriangleCount(bool include_deleted = true) const;
 
    [[nodiscard]] size_t getPointCount(bool include_deleted = true) const;
 
    [[nodiscard]] size_t getLineCount(bool include_deleted = true) const;
 
    [[nodiscard]] const std::vector<int> *getFaceIndexData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setVertices(size_t UUID, const std::vector<helios::vec3> &vertices);
 
    [[nodiscard]] std::vector<helios::vec3> getVertices(size_t UUID) const;
 
    static char getVertexCount(const VisualizerGeometryType &geometry_type);
 
    [[nodiscard]] const std::vector<float> *getVertexData_ptr(VisualizerGeometryType geometry_type) const;
 
    [[nodiscard]] helios::vec3 getNormal(size_t UUID) const;
 
    [[nodiscard]] const std::vector<float> *getNormalData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setColor(size_t UUID, const helios::RGBAcolor &color);
 
    [[nodiscard]] helios::RGBAcolor getColor(size_t UUID) const;
 
    [[nodiscard]] const std::vector<float> *getColorData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setUVs(size_t UUID, const std::vector<helios::vec2> &uvs);
 
    [[nodiscard]] std::vector<helios::vec2> getUVs(size_t UUID) const;
 
    [[nodiscard]] const std::vector<float> *getUVData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setTextureID(size_t UUID, int textureID);
 
    [[nodiscard]] int getTextureID(size_t UUID) const;
 
    [[nodiscard]] const std::vector<int> *getTextureIDData_ptr(VisualizerGeometryType geometry_type) const;
 
    void overrideTextureColor(size_t UUID);
 
    void useTextureColor(size_t UUID);
 
    [[nodiscard]] const std::vector<int> *getTextureFlagData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setVisibility(size_t UUID, bool isvisible);
 
    [[nodiscard]] bool isPrimitiveVisible(size_t UUID) const;
 
    [[nodiscard]] const std::vector<char> *getVisibilityFlagData_ptr(VisualizerGeometryType geometry_type) const;
 
    [[nodiscard]] const std::vector<int> *getCoordinateFlagData_ptr(VisualizerGeometryType geometry_type) const;
 
    void setSize(size_t UUID, float size);
 
    [[nodiscard]] float getSize(size_t UUID) const;
 
    [[nodiscard]] const std::vector<float> *getSizeData_ptr(VisualizerGeometryType geometry_type) const;
 
    [[nodiscard]] bool getDeleteFlag(size_t UUID) const;
 
    void deleteGeometry(size_t UUID);
 
    void deleteGeometry(const std::vector<size_t> &UUIDs);
 
    void clearAllGeometry();
 
    void clearContextGeometry();
 
    void getDomainBoundingBox(helios::vec2 &xbounds, helios::vec2 &ybounds, helios::vec2 &zbounds) const;
 
    void getDomainBoundingSphere(helios::vec3 &center, helios::vec3 &radius) const;
 
    size_t sampleUUID();
 
    [[nodiscard]] const PrimitiveIndexMap &getIndexMap(size_t UUID) const;
 
    constexpr static std::array<VisualizerGeometryType, 4> all_geometry_types = {GEOMETRY_TYPE_RECTANGLE, GEOMETRY_TYPE_TRIANGLE, GEOMETRY_TYPE_POINT, GEOMETRY_TYPE_LINE};
 
private:
    struct PrimitiveIndexMap {
        VisualizerGeometryType geometry_type;
        size_t face_index_index;
        size_t vertex_index;
        size_t normal_index;
        size_t uv_index;
        size_t color_index;
        size_t texture_flag_index;
        size_t texture_ID_index;
        size_t coordinate_flag_index;
        size_t visible_index;
        size_t context_geometry_flag_index;
        size_t delete_flag_index;
        size_t size_index;
    };
 
    std::mt19937_64 random_generator;
 
    std::unordered_map<size_t, PrimitiveIndexMap> UUID_map;
 
    std::unordered_map<VisualizerGeometryType, std::vector<int>> face_index_data;
    std::unordered_map<VisualizerGeometryType, std::vector<float>> vertex_data;
    std::unordered_map<VisualizerGeometryType, std::vector<float>> normal_data;
    std::unordered_map<VisualizerGeometryType, std::vector<float>> uv_data;
    std::unordered_map<VisualizerGeometryType, std::vector<float>> color_data;
    std::unordered_map<VisualizerGeometryType, std::vector<int>> texture_flag_data;
    std::unordered_map<VisualizerGeometryType, std::vector<int>> texture_ID_data;
    std::unordered_map<VisualizerGeometryType, std::vector<int>> coordinate_flag_data;
    std::unordered_map<VisualizerGeometryType, std::vector<char>> visible_flag_data;
    std::unordered_map<VisualizerGeometryType, std::vector<bool>> context_geometry_flag_data;
    std::unordered_map<VisualizerGeometryType, std::vector<bool>> delete_flag_data;
    std::unordered_map<VisualizerGeometryType, std::vector<float>> size_data;
 
    std::unordered_set<size_t> dirty_UUIDs;
 
    size_t deleted_primitive_count = 0;
 
    void defragmentBuffers();
 
    void registerUUID(size_t UUID, const VisualizerGeometryType &geometry_type);
};
 
#endif