RenderCommands.hpp

Go to the documentation of this file.

#ifndef _RENDERCOMMANDS_H
#define _RENDERCOMMANDS_H
 
#include <mutex>
#include <Memory/RefPtr.hpp>
#include <Utility/Container/List.hpp>
#include <Graphics/Common/ConstantBuffer.hpp>
#include "BufferBase.hpp"
#include <Graphics/Common/Renderer.hpp>
 
#define RENDER_COMMAND(Type) void Execute(RenderContext* context) override; \
                CommandType GetType() const override { return CommandType::Type;}
 
namespace Sleak {
    class Texture;
 
    namespace RenderEngine {
 
        class BufferBase;
        class RenderContext;
        class Shader;
    } // close RenderEngine temporarily
 
    class Material;
 
    namespace RenderEngine {
 
        /// Discriminator for RenderCommandBase subclasses, used for sorting and batching.
        enum class CommandType {
            Draw = 0,
            DrawIndexed = 1,
            DrawInstanced = 2,
            UpdateConstantBuffer = 3,
            BindConstantBuffer = 4,
            SetRenderTarget = 5,
            ClearRenderTarget = 6,
            SetViewport = 7,
            SetShader = 8,
            SetTexture = 9,
            SetMode = 10,
            SetFace = 11,      
            SetBlendStae = 12,
            SetDepthStencilState = 13,
            SetRasterizerState = 14,
            CustomCommand = 15,
            BindMaterial = 16
        };
 
        /// One recorded draw plus the state it needs to replay into a command list.
        class RenderCommandBase {
        public:
            virtual ~RenderCommandBase() = default;
            /// Replays this command into the main forward/deferred pass.
            virtual void Execute(RenderContext* context) = 0;
            virtual CommandType GetType() const = 0;
            virtual void ExecuteShadow(RenderContext* context) { /* no-op for non-draw commands */ }
            virtual bool IsSkinned() const { return false; }
 
            void SetOwnerObjectID(uint32_t id) { m_ownerObjectID = id; }
            uint32_t GetOwnerObjectID() const { return m_ownerObjectID; }
 
            // Shadow-caster cull: distant draws render to the camera but skip the
            // shadow pass (their shadows are imperceptible). Default true.
            void SetCastsShadow(bool v) { m_castsShadow = v; }
            bool CastsShadow() const { return m_castsShadow; }
 
        private:
            uint32_t m_ownerObjectID = 0;
            bool m_castsShadow = true;
        };
 
        /// Non-indexed draw command with its vertex and constant buffers.
        class DrawCommand : public RenderCommandBase {
            public:
                DrawCommand(
                    RefPtr<BufferBase> vertexBuffer,
                    List<RefPtr<BufferBase>> constantBuffers,
                    uint32_t vertexCount,
                    uint32_t startVertexLocation = 0
                );
 
                RENDER_COMMAND(Draw)
                void ExecuteShadow(RenderContext* context) override;
                bool IsSkinned() const override;
 
            private:
                RefPtr<BufferBase> m_vertexBuffer;
                List<RefPtr<BufferBase>> m_constantBuffers;
                uint32_t m_vertexCount;
                uint32_t m_startVertexLocation;
        };
 
        /// Indexed draw command with its vertex, index, and constant buffers.
        class DrawIndexedCommand : public RenderCommandBase {
        public:
            DrawIndexedCommand(RefPtr<BufferBase> vertexBuffer,
                 RefPtr<BufferBase> indexBuffer,
                 List<RefPtr<BufferBase>> constantBuffers,
                 uint32_t indexCount,
                 uint32_t startIndexLocation = 0,
                 int32_t baseVertexLocation = 0
                );
 
            RENDER_COMMAND(DrawIndexed)
            void ExecuteShadow(RenderContext* context) override;
            bool IsSkinned() const override;
 
        private:
            RefPtr<BufferBase> m_vertexBuffer;
            RefPtr<BufferBase> m_indexBuffer;
            List<RefPtr<BufferBase>> m_constantBuffers;
            uint32_t m_indexCount;
            uint32_t m_startIndexLocation;
            int32_t m_baseVertexLocation;
        };
 
        /// Constant buffer write, captured by value into inline storage or a heap fallback for larger payloads.
        class UpdateConstantBufferCommand : public RenderCommandBase {
            public:
                UpdateConstantBufferCommand(RefPtr<BufferBase> buffer, void* Data, uint16_t Size);
                ~UpdateConstantBufferCommand() override {
                    if (m_heapData) free(m_heapData);
                }
 
                RENDER_COMMAND(UpdateConstantBuffer)
 
                /// Returns a pointer to the captured payload, inline or heap-backed.
                void* GetData() const
                {
                    return m_heapData ? m_heapData
                                      : const_cast<void*>(static_cast<const void*>(m_inlineData));
                }
 
            private:
                RefPtr<BufferBase> constantBuffer;
                // Inline storage avoids malloc/free for small buffers (≤256 bytes).
                // TransformBuffer=128B, MaterialBuffer=128B — both fit inline.
                static constexpr uint16_t INLINE_CAPACITY = 256;
                alignas(16) uint8_t m_inlineData[INLINE_CAPACITY];
                void* m_heapData = nullptr;
                uint16_t Size;
        };
 
        /// Binds a constant buffer to a pipeline slot.
        class BindConstantBufferCommand : public RenderCommandBase {
            public:
                BindConstantBufferCommand(RefPtr<BufferBase> buffer, int slot);
 
                RENDER_COMMAND(BindConstantBuffer)
 
                RefPtr<BufferBase> GetBuffer() const { return constantBuffer; }
                int GetSlot() const { return slot; }
 
            private:
                RefPtr<BufferBase> constantBuffer;
                int slot;
        };
 
        /// Binds a texture for subsequent draws.
        class BindTextureCommand : public RenderCommandBase {
            public:
            BindTextureCommand(RefPtr<Texture> texture);
 
                RENDER_COMMAND(SetTexture)
 
            private:
                RefPtr<Texture> texture;
        };
 
        /// Binds a shader program for subsequent draws.
        class BindShaderCommand : public RenderCommandBase {
            public:
            BindShaderCommand(RefPtr<Shader> shader);
 
                RENDER_COMMAND(SetShader)
 
            private:
                RefPtr<Shader> shader;
        };
 
        /// Switches the rasterizer fill mode.
        class SetRenderModeCommand : public RenderCommandBase {
            public:
                SetRenderModeCommand(RenderMode mode);
 
                RENDER_COMMAND(SetMode)
 
            private:
                RenderMode mode;
        };
 
        /// Switches the cull-face mode.
        class SetRenderFaceCommand : public RenderCommandBase {
            public:
                SetRenderFaceCommand(RenderFace face);
 
                RENDER_COMMAND(SetFace)
 
            private:
                RenderFace face;
        };
 
        /// Binds a material's shader and textures for subsequent draws.
        class BindMaterialCommand : public RenderCommandBase {
            public:
                BindMaterialCommand(::Sleak::Material* material);
 
                void Execute(RenderContext* context) override;
                CommandType GetType() const override { return CommandType::BindMaterial; }
 
                ::Sleak::Material* GetMaterial() const { return m_material; }
 
            private:
                ::Sleak::Material* m_material;
        };
 
        /// Wraps an arbitrary callback as a queueable render command.
        class CustomCommand : public RenderCommandBase {
            public:
                using ExecuteFunction = std::function<void(RenderContext*)>;
                
                CustomCommand(ExecuteFunction executeFunction);
                
                void Execute(RenderContext* context) override;           
 
                CommandType GetType() const override { return CommandType::CustomCommand; }
            private:
                ExecuteFunction m_executeFunction;
            };
    }
}
 
#endif