Geometry.hpp

#pragma once 
#ifndef KJY_OBJECT_ORIENTED_OPENGL_GEOMETRY_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_GEOMETRY_HPP_
#include "../OOOGL_Core.hpp"
#include "../GLobjects/VertexArrayObject.hpp"
#include <glm/glm.hpp>
#include <vector>


namespace OOOGL{



class VertexGeometry : public ObjectTag{
 public:
    VertexGeometry() {
        vertex_array_object.linkArrayBuffer(0, vertex_position_buffer);
        sync_status_ = GpuSyncStatus::GPU_CURRENT;
    }

    VertexGeometry(const std::vector<glm::vec3>& vertices, const std::vector<GLuint> elements, bool skip_gpu_upload = false, bool skip_measurement = false) {
        cpu_vertex_buffer_ = vertices;
        cpu_element_buffers_.emplace_back(elements);
        if(!skip_gpu_upload) uploadToGpu();
        vertex_array_object.linkArrayBuffer(msPositionAttrIndex, vertex_position_buffer);
        linkElementBuffers(); 
        sync_status_ = GpuSyncStatus::GPU_CURRENT;
    }

    static const GLuint msPositionAttrIndex; // = 0;

    virtual void autoSetupForDraw();
    virtual void autoCleanupAfterDraw();

    virtual const glm::vec3& getMinPoint() {return(min_point_);}
    virtual const glm::vec3& getMaxPoint() {return(max_point_);}

    virtual void normalize();
    virtual void uploadToGpu();
    virtual GpuSyncStatus getSyncStatus() const {return(sync_status_);}

    virtual const std::vector<glm::vec3>& getVertices() const {return(cpu_vertex_buffer_);}
    virtual std::vector<glm::vec3>& getMutableVertices() {return(cpu_vertex_buffer_); sync_status_ = GpuSyncStatus::GPU_STALE; measurement_current_ = false;}
    virtual void replaceVertices(const std::vector<glm::vec3>& new_buffer) {cpu_vertex_buffer_ = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE; measurement_current_ = false;}

    virtual size_t numElementBuffers() const {return(cpu_element_buffers_.size());}
    virtual const std::vector<GLuint>& getElements(size_t index) const {_assert_element_index_inbounds_(index); return(cpu_element_buffers_[index]);}
    virtual std::vector<GLuint>& getMutableElements(size_t index) {_assert_element_index_inbounds_(index); return(cpu_element_buffers_[index]); sync_status_ = GpuSyncStatus::GPU_STALE; measurement_current_ = false;}
    virtual void replaceElements(size_t index, const std::vector<GLuint>& new_buffer) {_assert_element_index_inbounds_(index); cpu_element_buffers_[index] = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE; measurement_current_ = false;}
    virtual void addElements(const std::vector<GLuint>& new_buffer, bool auto_add_element_array_buffer = true) {
        cpu_element_buffers_.emplace_back(new_buffer);
        if(auto_add_element_array_buffer){
            vertex_elements_buffers_.emplace_back();
        }
        sync_status_ = GpuSyncStatus::GPU_STALE; measurement_current_ = false;
    }
    virtual ElementArrayBuffer getElementArrayBuffer(size_t index) {_assert_element_index_inbounds_(index); return(vertex_elements_buffers_[index]);}
    virtual void replaceElementArrayBuffer(size_t index, const ElementArrayBuffer& buffer){_assert_element_index_inbounds_(index);vertex_elements_buffers_[index] = buffer;}

    CommonVertexFormatVAO vertex_array_object;
    ArrayBuffer vertex_position_buffer;

 protected:

    virtual void updateMeasurement();
    virtual void linkElementBuffers();

    virtual void _startGpuUpload();
    virtual void _uploadData();
    virtual void _finishGpuUpload();

    void _measure_min_max_(const std::vector<glm::vec3>& vertices, glm::vec3* min_point, glm::vec3* max_point);
    void _normalize_vertices(std::vector<glm::vec3>& vertices, const glm::vec3& min, const glm::vec3& max);

    bool measurement_current_ = false;
    GpuSyncStatus sync_status_ = GpuSyncStatus::GPU_UNINITIALIZED;

    std::vector<glm::vec3> cpu_vertex_buffer_;
    std::vector<std::vector<GLuint>> cpu_element_buffers_;
    std::vector<ElementArrayBuffer> vertex_elements_buffers_;

    glm::vec3 min_point_ = glm::vec3(0.0);
    glm::vec3 max_point_ = glm::vec3(0.0);

 private:
    inline void _assert_element_index_inbounds_(size_t index) const {if(index >= cpu_element_buffers_.size()) throw GenericIndexOutOfBoundsException(index, "VertexGeometry element buffers");}
};

class TriangleMesh : public VertexGeometry{
 public:
    TriangleMesh();

    TriangleMesh(
        const std::vector<glm::vec3>& vertices, const std::vector<GLuint> elements,
        const std::vector<glm::vec3>& normals, const std::vector<glm::vec2>& texcoords,
        bool skip_gpu_upload = false);

    static const GLuint msNormalAttrIndex; // = 1;
    static const GLuint msTexCoordAttrIndex; // = 2;

    virtual void autoSetupForDraw() override;
    virtual void autoCleanupAfterDraw() override;

    virtual const std::vector<glm::vec3>& getNormals() const {return(cpu_normals_buffer_);}
    virtual std::vector<glm::vec3>& getMutableNormals() {return(cpu_normals_buffer_); sync_status_ = GpuSyncStatus::GPU_STALE; }
    virtual void replaceNormals(const std::vector<glm::vec3>& new_buffer) {cpu_normals_buffer_ = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE; }
    virtual bool areNormalsEnabled() const { return(mNormalsEnabled); }
    virtual void disableNormals() {mNormalsEnabled = false;}
    virtual void enableNormals() {mNormalsEnabled = true;}

    virtual const std::vector<glm::vec2>& getTextureCoords() const {return(cpu_texture_coords_);}
    virtual std::vector<glm::vec2>& getMutableTextureCoords() {return(cpu_texture_coords_); sync_status_ = GpuSyncStatus::GPU_STALE; }
    virtual void replaceTextureCoords(const std::vector<glm::vec2>& new_buffer) {cpu_texture_coords_ = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE; }
    virtual bool areTextureCoordsEnabled() const { return(mCoordsEnabled); }
    virtual void disableTextureCoords() {mCoordsEnabled = false;}
    virtual void enableTextureCoords() {mCoordsEnabled = true;}
    

    ArrayBuffer vertex_normals_buffer;
    ArrayBuffer vertex_coordinate_buffer;

 protected:

    virtual void _uploadData() override;

    std::vector<glm::vec3> cpu_normals_buffer_;
    bool mNormalsEnabled = true;
    std::vector<glm::vec2> cpu_texture_coords_;
    bool mCoordsEnabled = true;

};


struct TriangleMeshAggregate : public std::vector<TriangleMesh>{
    using base_vector = std::vector<TriangleMesh>;
    using size_type = base_vector::size_type;
    using value_type = base_vector::value_type;
    using allocator_type = base_vector::allocator_type;
    TriangleMeshAggregate() : base_vector() {}
    TriangleMeshAggregate(size_type n, const allocator_type& alloc = allocator_type()) : base_vector(n, alloc) {}
    TriangleMeshAggregate(size_type n, const value_type& value, const allocator_type& alloc = allocator_type()) : base_vector(n, value, alloc) {}
    TriangleMeshAggregate(std::initializer_list<TriangleMesh> init, const allocator_type& alloc = allocator_type()) : base_vector(init, alloc) {}
};

}


#endif