GLESGraphicsSession.h

#pragma once
#include "GLESGraphicsDevice.h"
#include "GLESCameraManager.h"
#include "GLESImage.h"
#include <NDEVR/GraphicsSession.h>
#include <NDEVR/ViewportOptions.h>
#include <NDEVR/GraphicsUpdateArguments.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/UUID.h>
#include <QOpenGLTexture>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>
namespace NDEVR
{
    class OpenGLBuffer;
    class GLESShader;
    class GLESRenderObject;
    class GLESVertexManager;
    class GLESMaterialManager;
    class GLESGraphicsSession : public GraphicsSession, public QObject
    {
    public:
        GLESGraphicsSession(const DynamicPointer<GLESGraphicsDevice>& device);
        virtual ~GLESGraphicsSession() override;
        void clearAll();
        virtual void readShader(const StringView&) override {}
        virtual DynamicPointer<GraphicsPipeline> createRenderPipeline()  override;
        DynamicPointer<GLESCameraManager> getCameraManager(const UUID& camera);
        virtual void postClearAll() override
        {}

        static UUID GLESRenderEngineID() { return UUID::CreateUUID("GLES Render Engine"); }
        static const DynamicPointer<GraphicsSession>& DefaultSession()
        {
            static DynamicPointer<GraphicsSession> s_session;
            if (s_session.isNull())
            {
                s_session = new GLESGraphicsSession(GLESGraphicsDevice::DefaultGLESDevice());
                ViewportOptions::default_render_engine.addListener(new QTResourceListener([]
                {
                    bool active = ViewportOptions::default_render_engine.get() == GLESGraphicsSession::GLESRenderEngineID();
                    s_session->setActive(active);
                    if (active)
                        GraphicsDevice::SetDefaultGraphicsDevice(s_session->device());
                }, s_session.as<GLESGraphicsSession>().rawptr()));
            }
            return s_session;
        }

        void removeRenderGeometry(const Geometry& geo) override;
        bool addRenderGeometry(const Geometry& geo) override;

        virtual UUID uuid() override
        {
            return GLESRenderEngineID();
        };

        bool checkPipeline(bool add_if_needed);
        bool checkPipeline(GeometryUpdateObject& geo_prop, bool add_if_needed);
        virtual bool runCommand(GraphicsUpdateArguments&) override
        {
            return true;
        }

        virtual void checkModelStructure(GraphicsUpdateArguments& args);
        virtual void commit(GraphicsUpdateArguments& args) override;
        virtual void updateUniformBuffer(GraphicsUpdateArguments& args) override;
        virtual bool createPipeline(GraphicsUpdateArguments& args) override;
        virtual const ConstPointer<GraphicsDevice>& device() const override;
        virtual const DynamicPointer<GraphicsDevice>& device() override;
        virtual bool hasCommand() const override
        {
            return true;
        }

        virtual void drawFrame(GraphicsUpdateArguments& args) override;
        virtual void ensureLastRenderComplete() override {};
        virtual void cleanup() override {};
        virtual void setWindowInstance(WindowInstance*) override {};
        virtual void cleanResources() override {};
        virtual void init(GraphicsUpdateArguments& args) override;
    protected:
        Dictionary<UUID, DynamicPointer<GLESCameraManager>> m_camera_managers;       
        Dictionary<UUID, DynamicPointer<GLESVertexManager>> m_vertex_managers;        
        Dictionary<uint08, DynamicPointer<GLESMaterialManager>> m_material_managers;  
        Buffer<GeometryUpdateObject> m_geometries;                                    
        Dictionary<uint08, GLESRenderObject*> m_pipelines;                            
        DynamicPointer<GLESGraphicsDevice> m_device;                                  
        DynamicPointer<GraphicsDevice> m_graphics_device;                             
        DynamicPointer<GLESShaderManager> m_shader_manager;                           
        DynamicPointer<GLESImageManager> m_image_manager;                             
    private:
        bool m_is_init = false;                
        bool m_needs_pipeline_update = false;  
    };
 
}