RenderPass.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_RENDER_PASS_HPP
#define DONUT_GRAPHICS_RENDER_PASS_HPP
 
#include <donut/Color.hpp>
#include <donut/LinearAllocator.hpp>
#include <donut/LinearBuffer.hpp>
#include <donut/graphics/Model.hpp>
#include <donut/graphics/Shader2D.hpp>
#include <donut/graphics/Shader3D.hpp>
#include <donut/graphics/SpriteAtlas.hpp>
#include <donut/graphics/Text.hpp>
#include <donut/graphics/Texture.hpp>
#include <donut/graphics/TexturedQuad.hpp>
#include <donut/math.hpp>
 
#include <cstddef>     // std::byte
#include <span>        // std::span
#include <string_view> // std::string_view, std::u8string_view
#include <vector>      // std::vector
 
namespace donut::graphics {
 
struct ModelInstance {
    Shader3D* shader = Shader3D::BLINN_PHONG;
 
    const Model* model;
 
    const Texture* diffuseMapOverride = nullptr;
 
    const Texture* specularMapOverride = nullptr;
 
    const Texture* normalMapOverride = nullptr;
 
    const Texture* emissiveMapOverride = nullptr;
 
    mat4 transformation = identity<mat4>();
 
    vec2 textureOffset{0.0f, 0.0f};
 
    vec2 textureScale{1.0f, 1.0f};
 
    Color tintColor = Color::WHITE;
 
    vec3 specularFactor{1.0f, 1.0f, 1.0f};
 
    vec3 emissiveFactor{1.0f, 1.0f, 1.0f};
};
 
struct QuadInstance {
    Shader2D* shader = Shader2D::PLAIN;
 
    const Texture* texture = Texture::WHITE;
 
    mat3 transformation = identity<mat3>();
 
    vec2 textureOffset{0.0f, 0.0f};
 
    vec2 textureScale{1.0f, 1.0f};
 
    Color tintColor = Color::WHITE;
};
 
struct TextureInstance {
    Shader2D* shader = Shader2D::PLAIN;
 
    const Texture* texture;
 
    vec2 position{0.0f, 0.0f};
 
    vec2 scale{1.0f, 1.0f};
 
    float angle = 0.0f;
 
    vec2 origin{0.0f, 0.0f};
 
    vec2 textureOffset{0.0f, 0.0f};
 
    vec2 textureScale{1.0f, 1.0f};
 
    Color tintColor = Color::WHITE;
};
 
struct RectangleInstance {
    Shader2D* shader = Shader2D::PLAIN;
 
    const Texture* texture = Texture::WHITE;
 
    vec2 position{0.0f, 0.0f};
 
    vec2 size{1.0f, 1.0f};
 
    float angle = 0.0f;
 
    vec2 origin{0.0f, 0.0f};
 
    vec2 textureOffset{0.0f, 0.0f};
 
    vec2 textureScale{1.0f, 1.0f};
 
    Color tintColor = Color::WHITE;
};
 
struct SpriteInstance {
    Shader2D* shader = Shader2D::PLAIN;
 
    const SpriteAtlas* atlas;
 
    SpriteAtlas::SpriteId id;
 
    vec2 position{0.0f, 0.0f};
 
    vec2 scale{1.0f, 1.0f};
 
    float angle = 0.0f;
 
    vec2 origin{0.0f, 0.0f};
 
    Color tintColor = Color::WHITE;
};
 
struct TextInstance {
    Shader2D* shader = Shader2D::ALPHA;
 
    const Text* text;
 
    vec2 position{0.0f, 0.0f};
 
    Color color = Color::WHITE;
};
 
struct TextCopyInstance {
    Shader2D* shader = Shader2D::ALPHA;
 
    const Text* text;
 
    vec2 position{0.0f, 0.0f};
 
    Color color = Color::WHITE;
};
 
struct TextUTF8StringInstance {
    Shader2D* shader = Shader2D::ALPHA;
 
    Font* font;
 
    u32 characterSize;
 
    vec2 position{0.0f, 0.0f};
 
    vec2 scale{1.0f, 1.0f};
 
    vec2 origin{0.0f, 0.0f};
 
    Color color = Color::WHITE;
 
    std::u8string_view string;
};
 
struct TextStringInstance {
    Shader2D* shader = Shader2D::ALPHA;
 
    Font* font;
 
    u32 characterSize;
 
    vec2 position{0.0f, 0.0f};
 
    vec2 scale{1.0f, 1.0f};
 
    vec2 origin{0.0f, 0.0f};
 
    Color color = Color::WHITE;
 
    std::string_view string;
};
 
class RenderPass {
public:
    RenderPass() noexcept = default;
 
    RenderPass(std::span<std::byte> initialMemory) noexcept
        : memoryResource(initialMemory) {}
 
    RenderPass& draw(const ModelInstance& model);
 
    RenderPass& draw(const QuadInstance& quad);
 
    RenderPass& draw(const TextureInstance& texture);
 
    RenderPass& draw(const RectangleInstance& rectangle);
 
    RenderPass& draw(const SpriteInstance& sprite);
 
    RenderPass& draw(const TextInstance& text);
 
    RenderPass& draw(const TextCopyInstance& text);
 
    RenderPass& draw(const TextUTF8StringInstance& text);
 
    RenderPass& draw(const TextStringInstance& text);
 
private:
    friend Renderer;
 
    struct CommandUseShader3D {
        Shader3D* shader;
    };
 
    struct CommandUseShader2D {
        Shader2D* shader;
    };
 
    struct CommandUseModel {
        const Model* model;
        const Texture* diffuseMapOverride;
        const Texture* specularMapOverride;
        const Texture* normalMapOverride;
        const Texture* emissiveMapOverride;
    };
 
    struct CommandUseTexture {
        const Texture* texture;
    };
 
    struct CommandUseSpriteAtlas {
        const SpriteAtlas* atlas;
    };
 
    struct CommandUseFont {
        Font* font;
    };
 
    struct CommandDrawModelInstance {
        mat4 transformation;
        Color tintColor;
        vec2 textureOffset;
        vec2 textureScale;
        vec3 specularFactor;
        vec3 emissiveFactor;
    };
 
    struct CommandDrawQuadInstance {
        mat3 transformation;
        Color tintColor;
        vec2 textureOffset;
        vec2 textureScale;
    };
 
    struct CommandDrawTextureInstance {
        Color tintColor;
        vec2 position;
        vec2 scale;
        vec2 origin;
        vec2 textureOffset;
        vec2 textureScale;
        float angle;
    };
 
    struct CommandDrawRectangleInstance {
        Color tintColor;
        vec2 position;
        vec2 size;
        vec2 origin;
        vec2 textureOffset;
        vec2 textureScale;
        float angle;
    };
 
    struct CommandDrawSpriteInstance {
        Color tintColor;
        vec2 position;
        vec2 scale;
        vec2 origin;
        float angle;
        SpriteAtlas::SpriteId id;
    };
 
    struct CommandDrawTextInstance {
        Color color;
        const Text* text;
        vec2 position;
    };
 
    struct CommandDrawTextCopyInstance {
        Color color;
        std::span<const Text::ShapedGlyph> shapedGlyphs;
        vec2 position;
    };
 
    struct CommandDrawTextStringInstance {
        Color color;
        std::string_view string;
        vec2 position;
        vec2 scale;
        vec2 origin;
        u32 characterSize;
    };
 
    LinearMemoryResource memoryResource{};
    LinearBuffer<                      //
        CommandUseShader3D,            //
        CommandUseShader2D,            //
        CommandUseModel,               //
        CommandUseTexture,             //
        CommandUseSpriteAtlas,         //
        CommandUseFont,                //
        CommandDrawModelInstance,      //
        CommandDrawQuadInstance,       //
        CommandDrawTextureInstance,    //
        CommandDrawRectangleInstance,  //
        CommandDrawSpriteInstance,     //
        CommandDrawTextInstance,       //
        CommandDrawTextCopyInstance,   //
        CommandDrawTextStringInstance, //
        Text::ShapedGlyph[],           //
        char[]>
        commandBuffer{&memoryResource, memoryResource.getRemainingCapacity()};
    std::vector<Font*, LinearAllocator<Font*>> fonts{&memoryResource};
    Shader3D* previousShader3D = nullptr;
    Shader2D* previousShader2D = nullptr;
    const Model* previousModel = nullptr;
    const Texture* previousDiffuseMapOverride = nullptr;
    const Texture* previousSpecularMapOverride = nullptr;
    const Texture* previousNormalMapOverride = nullptr;
    const Texture* previousEmissiveMapOverride = nullptr;
    const Texture* previousTexture = nullptr;
    const SpriteAtlas* previousSpriteAtlas = nullptr;
    Font* previousFont = nullptr;
};
 
} // namespace donut::graphics
 
#endif