canvas.h

Go to the documentation of this file.

#pragma once
 
// todo(Gustav): figure out a beter name than canvas
 
#include "eu/base/rect.h"
 
// #include "tred/types.h"
#include "eu/base/vec2.h"
#include "eu/base/vec3.h"
#include "eu/base/vec4.h"
 
#include "eu/render/shader.h"
#include "eu/render/texture.h"
 
#include "eu/base/colors.h"
 
 
namespace eu::render
{
 
struct SpriteBatch;
struct State;
struct ShaderProgram;
struct Render2;
 
 
enum class ViewportStyle { black_bars, extended};
 
 
struct Vertex2
{
    v3 position;
    Color color;
    v2 texturecoord;
};
 
struct RotateQuad
{
    An angle;
    v2 center;
};
 
struct Quad
{
    std::optional<const Texture2d*> texture = std::nullopt;
    std::optional<Rect> texturecoord = std::nullopt;
    Color tint = eu::colors::white;
    std::optional<RotateQuad> rotation = std::nullopt;
 
    void draw(SpriteBatch* batch, const Rect& screen);
};
 
struct SpriteBatch
{
    static constexpr int max_quads = 100;
 
    State* states;
    std::vector<float> data;
    int quads = 0;
    const Texture2d* current_texture = nullptr;
    u32 va = 0;
    u32 vb = 0;
    u32 ib = 0;
    Render2* render;
    Texture2d white_texture;
 
    SpriteBatch(State* states, ShaderProgram* shader, Render2* r);
    ~SpriteBatch();
 
    SpriteBatch(const SpriteBatch&) = delete;
    void operator=(const SpriteBatch&) = delete;
    SpriteBatch(SpriteBatch&&) = delete;
    void operator=(SpriteBatch&&) = delete;
 
    void quad(std::optional<const Texture2d*> texture, const Vertex2& v0, const Vertex2& v1, const Vertex2& v2, const Vertex2& v3);
 
    void submit();
};
 
struct Render2
{
    explicit Render2(State* states);
 
    core::ShaderVertexAttributes quad_description;
    core::CompiledShaderVertexAttributes quad_layout;
    ShaderProgram quad_shader;
    Uniform view_projection_uniform;
    Uniform transform_uniform;
    Uniform texture_uniform;
 
    SpriteBatch batch;
};
 
struct Layer
{
    Rect viewport_aabb_in_worldspace;
    Rect screen;
 
    [[nodiscard]] v2 mouse_to_world(const v2& p) const;
};
 
struct RenderLayer2 : Layer
{
    SpriteBatch* batch;
 
    RenderLayer2(const Layer& l, SpriteBatch* batch);
    ~RenderLayer2();
 
    RenderLayer2(RenderLayer2&&) = delete;
    RenderLayer2(const RenderLayer2&) = delete;
    void operator=(RenderLayer2&&) = delete;
    void operator=(const RenderLayer2&) = delete;
};
 
struct RenderLayer3 : Layer
{
    RenderLayer3(const Layer& l);
};
 
 
struct LayoutData
{
    ViewportStyle style;
    float requested_width;
    float requested_height;
};
 
struct LerpData
{
    LayoutData lhs;
    LayoutData rhs;
    float t;
};
 
 
struct InputCommand
{
    Size size;
};
 
struct RenderCommand
{
    State* states;
    Render2* render;
    Size size;
 
    // todo(Gustav): add clear to color function
    void clear(const Rgb& color, const LayoutData& ld) const;
    void clear(const Rgb& color, const LerpData& ld) const;
};
 

// Functions
 
 
// todo(Gustav): pass camera to with_ functions
// todo(Gustav): move to member functions
 
RenderLayer2 with_layer2(const RenderCommand& rc, const LayoutData& ld);
RenderLayer3 with_layer3(const RenderCommand& rc, const LayoutData& ld);
Layer with_layer(const InputCommand& rc, const LayoutData& ld);
 
RenderLayer2 with_layer2(const RenderCommand& rc, const LerpData& ld);
RenderLayer3 with_layer3(const RenderCommand& rc, const LerpData& ld);
Layer with_layer(const InputCommand& rc, const LerpData& ld);
 
}