GLESRenderObject.h

#pragma once
#include "GLBuffer.h"
#include "GLESGraphicsDevice.h"
#include <NDEVR/GraphicsUpdateArguments.h>
#include <NDEVR/Material.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Model.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/Set.h>
class QOpenGLVertexArrayObject;
namespace NDEVR
{
    class Camera;
    class GLESVertexManager;
    class GLESMaterialManager;
    class GLESRenderObject
    {
    private:
        struct ModelProperties
        {
            ModelProperties(const Model& model, const Material& material)
                : model(model)
                , material(material)
            {}
            Model model;               
            Material material;         
            bool should_render = true; 
        };
        struct GeoProperties
        {
            Time last_updated_time = Time(0);                       
            Buffer<ModelProperties> model_parents;                   
            Geometry geometry;                                       
            fltp04 pixel_thickness = Constant<fltp04>::Invalid;      
            uint04 vertex_start = 0;                                 
            uint04 vertex_size = 0;                                  
            uint04 primitive_start = 0;                              
            uint04 primitive_size = 0;                               
            uint04 matrix_start = 0;                                 
            uint04 matrix_size = 0;                                  
            uint04 matrix_visible_size = 0;                          
            uint04 matrix_reserved = 0;                              
            bool is_visible = true;                                  
            bool is_deleted = false;                                 
        };
 
    public:
        GLESRenderObject(const DynamicPointer<GLESGraphicsDevice>& pipeline);
        GLESRenderObject(const GLESRenderObject& instance) = delete;
        ~GLESRenderObject();
        void cleanup();
        bool removeInstance(const Geometry& geo);
        bool shouldRender(const Model& model) const;
        void setDevice(const DynamicPointer<GLESGraphicsDevice>& instance);
        void updateUniformBuffer(GraphicsUpdateArguments& args);
        void commit(GraphicsUpdateArguments& args);
        bool hasOpacity() const;
        bool hasImage() const;
        bool isFilledShape() const;
        fltp04 fadeDistance() const;
        uint01 parity() const { return m_parity; }
        static GLint RenderType(PrimitiveMode mode);
        bool createPipeline(GraphicsUpdateArguments& args);
        bool hasCommand() const;
        bool runCommand(GraphicsUpdateArguments& args, bool opacity_pass);

        void setPrimitiveMode(const PrimitiveMode& type) { m_index_mode = type; }
        void setVertexManager(const DynamicPointer<GLESVertexManager>& vertex_manager);
        void setMaterialManager(const DynamicPointer<GLESMaterialManager>& material_manager);
        const DynamicPointer<GLESMaterialManager>& materialManager() const { return m_material_manager; }
        void setParity(uint01 parity);
        void setRelativeToCamera(bool reletive_to_camera);
        const ConstPointer<GLESVertexManager>& vertexManager() const { return m_vertex_manager; }
        PrimitiveMode indexMode() const { return m_index_mode; };
        void addInstance(const Geometry& geo, const Material& material);
    private:
        void swapMatrixIdx(uint04 idx, uint04 swap_location);
        void geometryUpdate(GeoProperties& props);
        bool modelUpdate(GeoProperties& props, const Time& geo_mod_time, uint04 idx, uint04 matrix_index_count, bool& should_remove);
        void updatePixelThickness(GeoProperties& props);
        void processGeoUniformUpdates(GeoProperties& properties, GraphicsUpdateArguments& args, uint04& matrix_index, const Time& geo_mod_time);
        void getMatrixUniformObject(const Geometry& mesh, const Model& model, Matrix<fltp04>& matrix, Vector<4, sint04>& offset, Vector<2, uint04>& flag) const;
    private:
        PrimitiveProperty m_primitive_prop = PrimitiveProperty::Outline;
        PrimitiveMode m_index_mode = PrimitiveMode::e_index_mode_size;
        Dictionary<UUID, uint04> m_geometry_lookup;
        Buffer<GeoProperties> m_geometries;
        DynamicPointer<GLESVertexManager> m_vertex_manager;
        DynamicPointer<GLESMaterialManager> m_material_manager;
        Buffer<Matrix<fltp04>> m_model_matrix_uniforms;
        Buffer<Vector<4, sint04>> m_model_offset_uniforms;
        Buffer<Vector<2, uint04>> m_model_flag_uniforms;
        DynamicPointer<OpenGLBuffer> m_matrix_instance_buffer;
        DynamicPointer<OpenGLBuffer> m_offset_instance_buffer;
        DynamicPointer<OpenGLBuffer> m_flags_instance_buffer;
        DynamicPointer<GLESGraphicsDevice> m_instance;
        uint04 m_vao = Constant<uint04>::Invalid;
        volatile mutable bool m_needs_matrix_commit = false;
        volatile mutable bool m_needs_flags_commit = false;
        volatile mutable bool m_needs_offset_commit = false;
        volatile mutable bool m_needs_geometry_commit = true;
        uint01 m_parity = Constant<uint01>::Invalid;
        bool m_is_integer_shader = false;
        bool m_is_tbn_shader = false;
        bool m_is_normal_shader = false;
        bool m_relative_to_camera = false;
        bool m_has_tangent = false;
    };
}