GLESRenderObject.h

Go to the documentation of this file.

#pragma once
#include "GLESInterface/Headers/GLBuffer.h"
#include "GLESInterface/Headers/GLESGraphicsDevice.h"
#include "NDEVRGraphics/Headers/GraphicsUpdateArguments.h"
#include "Design/Headers/Material.h"
#include "Design/Headers/Geometry.h"
#include "Design/Headers/Model.h"
#include "Base/Headers/Matrix.hpp"
#include "Base/Headers/Pointer.hpp"
class QOpenGLVertexArrayObject;
namespace NDEVR
{
    class Camera;
    class GLESVertexManager;
    class GLESMaterialManager;
 
    class GLESRenderObject
    {
    protected:
        struct ModelProperties
        {
            ModelProperties(const Model& model, const Material& material)
                : model(model)
                , material(material)
            {}
            Model model;
            Material material;
            bool should_render = false;
        };
        struct GeoProperties
        {
            Buffer<ModelProperties> model_parents;
            Geometry geometry;
            fltp04 pixel_thickness = Constant<fltp04>::NaN;
            uint04 vertex_start = 0;
            uint04 vertex_size = 0;
            uint04 index_start = 0;
            uint04 index_size = 0;
            bool is_visible = false;
        };
 
    public:
        GLESRenderObject(const DynamicPointer<GLESGraphicsDevice>& pipeline);
        GLESRenderObject(const GLESRenderObject& instance);
        ~GLESRenderObject();
        void cleanup();
        bool shouldRender(const GraphicsUpdateArguments& args, const Model& model) const;
        void setDevice(const DynamicPointer<GLESGraphicsDevice>& instance);
        void updateUniformBuffer(GraphicsUpdateArguments& args);
        void commit(GraphicsUpdateArguments& args);
        bool hasOpacity() const;
        bool hasImage() const;
        fltp04 fadeDistance() const;
        uint01 parity() const { return m_parity; }
        static GLint RenderType(PrimitiveMode mode);
        bool createPipeline(GraphicsUpdateArguments& args);
 
        //void resetPool() { m_descriptor_pool = nullptr; }
        bool hasCommand() const;
        bool runCommand(GraphicsUpdateArguments& args);
        bool isFilledShape() const;
 
        void setPrimitiveMode(const PrimitiveMode& type) { m_index_mode = type; }
        void setIndexProperty(const PrimitiveProperty& property) { m_index_property = property; }
        void setVertexManager(const DynamicPointer<GLESVertexManager>& vertex_manager);
        void setMaterialManager(const DynamicPointer<GLESMaterialManager>& material_manager);
        void setParity(uint01 parity);
        const ConstPointer<GLESVertexManager>& vertexManager() const { return m_vertex_manager; }
        PrimitiveMode indexMode() const { return m_index_mode; };
        PrimitiveProperty indexProperty() const { return m_index_property; };
        void addInstance(const Geometry& geo, const Model& parent, const Material& material);
        void clearInstances();
    private:
        void processGeoUniformUpdates(GeoProperties& properties, GraphicsUpdateArguments& args, uint04& matrix_index, const Time& geo_mod_time);
        void getMatrixUniformObject(Buffer<Matrix<fltp04>>& matrix, Buffer<Vector<3, sint04>>& offset, Buffer<Vector<2, uint04>>& flags) const;
        void getMatrixUniformObject(const Geometry& mesh, const Model& model, Matrix<fltp04>& matrix, Vector<3, sint04>& offset, Vector<2, uint04>& flag) const;
    private:
        PrimitiveProperty m_index_property;
        PrimitiveMode m_index_mode = PrimitiveMode::e_index_mode_size;
        GeoProperties m_geometry;
        //ExtraPropertySettings m_extra_settings;
 
        //DynamicPointer<VulkanBuffer> m_bitf_uniform_buffer;
        DynamicPointer<GLESVertexManager> m_vertex_manager;
        DynamicPointer<GLESMaterialManager> m_material_manager;
        Buffer<Matrix<fltp04>> m_model_matrix_uniforms;
        Buffer<Vector<3, 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;
        //VkDescriptorPool_T* m_descriptor_pool;
        //VkDescriptorSet_T*  m_descriptor_set;
        uint04 m_vao = Constant<uint04>::NaN;
        Time m_last_updated_time = Time(0);
        volatile mutable bool m_needs_matrix_commit = false;
        //volatile mutable bool m_needs_bitf_commit;
        uint01 m_parity = Constant<uint01>::NaN;
        bool m_is_integer_shader = false;
    };
}