render.h

#ifndef __VIOLET_RENDE_H__
#define __VIOLET_RENDE_H__
 
#include <array>
#include <functional>
#include <optional>
#include <vector>
 
#include "error.h"
#include "id.h"
#include "result.h"
 
namespace violet {
 
enum class VertexAttributeType { Position, Normal, Color, Texcoord };
enum class VertexAttributeSize { Float2, Float3, Float4 };
 
struct VertexAttribute {
    VertexAttributeSize size;
    VertexAttributeType type;
    size_t offset;
};
 
class VertexLayoutDescriptor {
  public:
    void add_attribute(
        VertexAttributeSize size,
        VertexAttributeType type,
        size_t offset
    ) {
        attributes.emplace_back(VertexAttribute {size, type, offset});
    }
 
    size_t stride {0};
    std::vector<VertexAttribute> attributes;
};
 
struct RendererInitDescriptor {
    float view_width {0.f};
    float view_height {0.f};
    void* native_handle {nullptr};
};
 
struct RenderTarget {
    enum class Type { Screen, Texture };
    Type type;
 
    static const RenderTarget SCREEN;
};
 
struct DepthTarget {
    enum class Type { Default, Texture };
    Type type;
 
    static const DepthTarget DEFAULT;
};
 
inline const RenderTarget RenderTarget::SCREEN =
    RenderTarget {RenderTarget::Type::Screen};
inline const DepthTarget DepthTarget::DEFAULT =
    DepthTarget {DepthTarget::Type::Default};
 
enum class LoadAction { Clear };
enum class StoreAction { Store };
 
struct RenderPipeline {};
 
struct ClearColor {
    float r {0.1f};
    float g {0.1f};
    float b {0.1f};
    float a {0.f};
};
 
struct RenderPassColorAttachment {
    RenderTarget target;
    ClearColor clear_color;
    LoadAction load_action {LoadAction::Clear};
    StoreAction store_action {StoreAction::Store};
};
 
struct RenderPassDepthAttachment {
    DepthTarget target;
    LoadAction load_action {LoadAction::Clear};
    StoreAction store_action {StoreAction::Store};
    bool clear_depth {false};
};
 
struct RenderPassDescriptor {
    void add_color_attachment(
        const RenderTarget& target,
        const ClearColor& clear_color = {},
        LoadAction load_action = LoadAction::Clear,
        StoreAction store_action = StoreAction::Store
    ) {
        color_attachments.emplace_back(RenderPassColorAttachment {
            target,
            clear_color,
            load_action,
            store_action
        });
    }
 
    void set_depth_attachment(
        const DepthTarget& target,
        bool clear_depth = true,
        LoadAction load_action = LoadAction::Clear,
        StoreAction store_action = StoreAction::Store
    ) {
        depth_attachment = RenderPassDepthAttachment {
            target,
            load_action,
            store_action,
            clear_depth
        };
    }
 
    std::optional<RenderPassDepthAttachment> depth_attachment;
    std::vector<RenderPassColorAttachment> color_attachments;
};
 
enum class IndexType { Uint16, Uint32 };
 
struct Buffer {};
template<typename Backend>
class RendererImpl;
 
struct Texture {};
 
struct Sampler {};
 
// struct RenderCommandEncoder {
//     RenderCommandEncoder() = default;
//     RenderCommandEncoder(const RenderCommandEncoder&) = delete;
//     RenderCommandEncoder(RenderCommandEncoder&&) noexcept = default;
//     RenderCommandEncoder& operator=(RenderCommandEncoder&&) noexcept = default;
 
//     struct IndexedDrawCall {
//         Handle<Buffer> buffer;
//         size_t count {0};
//         IndexType index_type;
//     };
 
//     struct InstancedDrawCall {
//         size_t start {0};
//         size_t end {0};
//         size_t count {0};
//     };
 
//     struct VertexDrawCall {
//         size_t start {0};
//         size_t end {0};
//     };
 
//     using DrawCall =
//         std::variant<IndexedDrawCall, InstancedDrawCall, VertexDrawCall>;
 
//     struct RenderState {
//         Handle<RenderPipeline> pipeline;
//         size_t current_vertex_slot {0};
//         std::vector<std::pair<Handle<Buffer>, size_t>> vertex_buffers;
//         std::vector<std::tuple<std::unique_ptr<uint8_t[]>, size_t, size_t>>
//             vertex_bytes;
//         std::vector<Handle<Texture>> textures;
//         std::vector<Handle<Sampler>> samplers;
//         std::vector<DrawCall> draws;
//     };
 
//     RenderPassDescriptor m_desc;
 
//     // static constexpr size_t MAX_PIPELINE_STATES = 16;
//     // std::array<RenderState, MAX_PIPELINE_STATES> pipeline_states;
//     std::vector<RenderState> pipeline_states;
//     size_t m_pipeline_count {0};
 
//     RenderState* current_state {nullptr};
 
//     void set_pipeline(const Handle<RenderPipeline>& pipeline) {
//         pipeline_states.push_back(RenderState {pipeline});
//         current_state = &pipeline_states.back();
//         current_state->pipeline = pipeline;
//         current_state->vertex_buffers.clear();
//         current_state->vertex_bytes.clear();
//         ++m_pipeline_count;
//     }
 
//     void set_vertex_buffer(const Handle<Buffer>& handle) {
//         if (!current_state) {
//             return;
//         }
 
//         current_state->vertex_buffers.emplace_back(
//             std::make_pair(handle, current_state->current_vertex_slot)
//         );
 
//         ++current_state->current_vertex_slot;
//     }
 
//     template<typename T>
//     void set_vertex_bytes(T* data, size_t size) {
//         if (!current_state) {
//             return;
//         }
 
//         auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
//         std::memcpy(buffer.get(), data, size);
 
//         current_state->vertex_bytes.emplace_back(std::make_tuple(
//             std::move(buffer),
//             size,
//             current_state->current_vertex_slot
//         ));
//         ++current_state->current_vertex_slot;
//     }
 
//     void set_texture(const Handle<Texture>& handle) {
//         current_state->textures.emplace_back(handle);
//     }
 
//     void set_sampler(const Handle<Sampler>& handle) {
//         current_state->samplers.emplace_back(handle);
//     }
 
//     void draw(size_t start, size_t end) {
//         current_state->draws.emplace_back(VertexDrawCall {start, end});
//     }
 
//     void draw_indexed(
//         const Handle<Buffer>& handle,
//         size_t count,
//         IndexType index_type = IndexType::Uint16
//     ) {
//         current_state->draws.emplace_back(
//             IndexedDrawCall {handle, count, index_type}
//         );
//     }
 
//     void draw_instanced(size_t start, size_t end, size_t count) {
//         current_state->draws.emplace_back(InstancedDrawCall {start, end, count}
//         );
//     }
// };
 
enum class TextureWrapMode { ClampToEdge, Repeat, Mirror };
enum class TextureFilterMode { Linear, Nearest };
 
enum class TextureFormat { RGBA8Unorm };
enum class TextureDimension { D2, D3, D2Array };
 
struct CreateTextureDesc {
    int width {0};
    int height {0};
    int channels {0};
    void* data {nullptr};
    size_t array_layers {2};  
    TextureDimension dimension {TextureDimension::D2};
    TextureFormat format {TextureFormat::RGBA8Unorm};
    size_t len {0};
};
 
struct CreateSamplerDesc {
    TextureWrapMode wrap_mode {TextureWrapMode::ClampToEdge};
    TextureFilterMode filter_mode {TextureFilterMode::Linear};
};
 
template<typename Encoder>
struct RenderCommandEncoder {
    Encoder encoder;
 
    inline void set_pipeline(const Handle<RenderPipeline>& pipeline);
 
    inline void set_vertex_buffer(const Handle<Buffer>& handle);
 
    template<typename T>
    inline void set_vertex_bytes(const T* data, size_t size);
 
    inline void set_texture(const Handle<Texture>& handle);
 
    inline void set_sampler(const Handle<Sampler>& handle);
 
    inline void draw(size_t start, size_t end);
 
    inline void draw_indexed(
        const Handle<Buffer>& handle,
        size_t count,
        IndexType index_type = IndexType::Uint16
    );
 
    inline void draw_instanced(size_t start, size_t end, size_t count);
 
    inline void submit();
};
 
template<typename Backend>
class RendererImpl {
  public:
    using EncoderType = typename Backend::EncoderType;
 
    // template<typename RenderEncoder>
    // struct RenderCommandEncoder {
    //     RenderCommandEncoder(const RenderPassDescriptor& desc) :
 
    //         descriptor(desc) {}
 
    //     RenderCommandEncoder(const RenderCommandEncoder&) = delete;
    //     RenderCommandEncoder(RenderCommandEncoder&&) noexcept = default;
    //     RenderCommandEncoder&
    //     operator=(RenderCommandEncoder&&) noexcept = default;
 
    //     Backend& m_backend;
    //     RenderPassDescriptor descriptor;
 
    //     struct IndexedDrawCall {
    //         Handle<Buffer> buffer;
    //         size_t count {0};
    //         IndexType index_type;
    //     };
 
    //     struct InstancedDrawCall {
    //         size_t start {0};
    //         size_t end {0};
    //         size_t count {0};
    //     };
 
    //     struct VertexDrawCall {
    //         size_t start {0};
    //         size_t end {0};
    //     };
 
    //     using DrawCall =
    //         std::variant<IndexedDrawCall, InstancedDrawCall, VertexDrawCall>;
 
    //     struct RenderPipelineState {
    //         Handle<RenderPipeline> pipeline_handle;
    //         std::vector<std::pair<size_t, Handle<Buffer>>> vertex_buffers;
    //         std::vector<std::tuple<size_t, const uint8_t*, size_t>>
    //             vertex_bytes;
    //         std::vector<std::pair<size_t, Handle<Texture>>> textures;
    //         std::vector<std::pair<size_t, Handle<Sampler>>> samplers;
    //         std::vector<DrawCall> draw_calls;
    //         // size_t current_vertex_buffer_slot {0};
    //         // size_t current_texture_slot {0};
    //         // size_t current_sampler_slot {0};
    //     };
 
    //     std::vector<RenderPipelineState> states;
 
    //     void set_pipeline(const Handle<RenderPipeline>& handle) {
    //         m_current_vertex_buffer_slot = 0;
    //         m_current_texture_slot = 0;
    //         m_current_sampler_slot = 0;
    //         states.push_back(RenderPipelineState {handle});
    //     }
 
    //     void set_vertex_buffer(const Handle<Buffer>& handle) {
    //         states.back().vertex_buffers.emplace_back(
    //             std::make_pair(m_current_vertex_buffer_slot, handle)
    //         );
    //         ++m_current_vertex_buffer_slot;
    //     }
 
    //     template<typename T>
    //     void set_vertex_bytes(const T* data, size_t size) {
    //         states.back().vertex_bytes.emplace_back(std::make_tuple(
    //             m_current_vertex_buffer_slot,
    //             reinterpret_cast<const uint8_t*>(data),
    //             size
    //         ));
    //         ++m_current_vertex_buffer_slot;
    //     }
 
    //     void set_texture(const Handle<Texture>& handle) {
    //         states.back().textures.emplace_back(
    //             std::make_pair(m_current_texture_slot, handle)
    //         );
    //         ++m_current_texture_slot;
    //     }
 
    //     void set_sampler(const Handle<Sampler>& handle) {
    //         states.back().samplers.emplace_back(
    //             std::make_pair(m_current_sampler_slot, handle)
    //         );
    //         ++m_current_sampler_slot;
    //     }
 
    //     void draw(size_t start, size_t end) {
    //         states.back().draw_calls.emplace_back(VertexDrawCall {start, end});
    //     }
 
    //     void draw_indexed(
    //         const Handle<Buffer>& handle,
    //         size_t count,
    //         IndexType index_type = IndexType::Uint16
    //     ) {
    //         states.back().draw_calls.emplace_back(
    //             IndexedDrawCall {handle, count, index_type}
    //         );
    //     }
 
    //     void draw_instanced(size_t start, size_t end, size_t count) {
    //         states.back().draw_calls.emplace_back(
    //             InstancedDrawCall {start, end, count}
    //         );
    //     }
 
    //   private:
    //     friend class RendererImpl<Backend>;
    //     size_t m_current_vertex_buffer_slot {0};
    //     size_t m_current_texture_slot {0};
    //     size_t m_current_sampler_slot {0};
 
    //     // void apply(EncoderType& encoder) {
    //     //     for (const auto& command : m_commands) {
    //     //         command(encoder);
    //     //     }
    //     // }
 
    //     std::vector<std::function<void(EncoderType&)>> m_commands;
    // };
 
    Result<Unit, Error> init(const RendererInitDescriptor& desc);
    Result<Handle<RenderPipeline>, Error> create_render_pipeline(
        const std::string& label,
        const std::string& shader_source,
        const VertexLayoutDescriptor& desc
    );
 
    RenderCommandEncoder<EncoderType>
    create_render_command_encoder(const RenderPassDescriptor& desc);
    // return RenderCommandEncoder
    // m_encoders.push_back(RenderCommandEncoder {m_backend, desc});
    // return m_encoders.back();
    // }
 
    Result<Handle<Texture>, Error> create_texture(const CreateTextureDesc& desc
    );
    Result<Handle<Sampler>, Error> create_sampler(const CreateSamplerDesc& desc
    );
 
    template<typename T>
    Result<Handle<Buffer>, Error> create_buffer(T data, size_t size);
 
    template<typename T>
    Result<Unit, Error>
    update_buffer(const Handle<Buffer>& handle, T data, size_t size);
 
    template<typename T>
    void
    update_buffer_unchecked(const Handle<Buffer>& handle, T data, size_t size);
 
    // void render();
 
  private:
    Backend m_backend;
    float m_view_width {0.f};
    float m_view_height {0.f};
};
 
}  // namespace violet
 
#endif