ht_renderer.h

#pragma once

#include <ht_platform.h>
#include <Hatchit/HatchitGraphics/include/ht_color.h>
#include <ht_types.h>
#include <ht_string.h>
#include <ht_renderpass.h>
#include <ht_camera.h>
#include <Hatchit/HatchitGraphics/include/ht_device.h>
#include <ht_gpuqueue.h>
#include <ht_threadqueue.h>
#include <ht_shadervariable.h>
#include <ht_renderthread.h>

namespace Hatchit {

    namespace Graphics {

        class SwapChain;

        enum class ClearArgs
        {
            Color,
            Depth,
            Stencil,
            ColorDepth,
            ColorStencil,
            ColorDepthStencil
        };

        enum RendererType
        {
            UNKNOWN,
            OPENGL,
            DIRECTX11,
            DIRECTX12,
            VULKAN
        };

        struct RendererParams
        {
            RendererType    renderer;
            bool            validate;
            void*           window;
            uint32_t        viewportWidth;
            uint32_t        viewportHeight;
            void*           display;
            Color           clearColor;
            std::string     applicationName;
        };

        class HT_API Renderer
        {
        public:
            Renderer();

            ~Renderer();
            
            bool Initialize(const RendererParams& params);

            void ResizeBuffers(uint32_t width, uint32_t height);

            void Render();

            void Present();

            void RegisterRenderRequest(RenderPassHandle pass, MaterialHandle material, MeshHandle mesh, ShaderVariableChunk* instanceVariables);

            void RegisterCamera(Camera camera);

            static IDevice* const GetDevice();

            static SwapChain* const GetSwapChain();

            static RendererType GetType();

        protected:
            static IDevice*     _Device;
            static GPUQueue*    _Queue;
            static RendererType _Type;
            static SwapChain*   _SwapChain;

            //A collection of renderpass layers. Each layer may contain multiple render passes.
            std::vector<std::vector<RenderPassHandle>> m_renderPassLayers = std::vector<std::vector<RenderPassHandle>>(64);
            //A collection of cameras sorted by renderpass layer. Repopulated each frame.
            std::vector<std::vector<Graphics::Camera>> m_renderPassCameras = std::vector<std::vector<Graphics::Camera>>(64);
            
            std::vector<RenderThread*> m_threads;
            std::mutex m_mutex;
            std::unique_lock<std::mutex> m_lock;
            std::condition_variable m_cv;
            bool m_locked;
            bool m_processed;

            Core::ThreadsafeQueue<RenderPassHandle> m_threadQueue;

            RendererParams  m_params;
            
            TextureHandle test;

            void initThreads();
        };

    }
}