314 lines
8.3 KiB
C++
314 lines
8.3 KiB
C++
/*
|
|
* <Short Description>
|
|
* Copyright (C) 2023 Brett Terpstra
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H
|
|
#define BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H
|
|
|
|
#include "blt/gfx/model.h"
|
|
#include "blt/gfx/shader.h"
|
|
#include "blt/gfx/framebuffer.h"
|
|
#include "blt/gfx/renderer/resource_manager.h"
|
|
#include "blt/gfx/renderer/postprocess.h"
|
|
#include <blt/std/hashmap.h>
|
|
#include <blt/std/memory_util.h>
|
|
#include <blt/math/vectors.h>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
namespace blt::gfx
|
|
{
|
|
struct rectangle2d_t
|
|
{
|
|
vec2f pos, size;
|
|
f32 rotation = 0;
|
|
|
|
rectangle2d_t(const f32 x, const f32 y, const f32 width, const f32 height, const f32 rotation): pos(x, y), size(width, height),
|
|
rotation(rotation)
|
|
{}
|
|
|
|
rectangle2d_t(const f32 x, const f32 y, const f32 width, const f32 height): pos(x, y), size(width, height)
|
|
{}
|
|
|
|
rectangle2d_t(const vec2f pos, const vec2f size, const f32 rotation): pos(pos), size(size), rotation(rotation)
|
|
{}
|
|
|
|
rectangle2d_t(const vec2f pos, const vec2f size): pos(pos), size(size)
|
|
{}
|
|
};
|
|
|
|
struct line2d_t
|
|
{
|
|
vec2f p1;
|
|
vec2f p2;
|
|
f32 thickness = 1;
|
|
|
|
line2d_t(const f32 px1, const f32 py1, const f32 px2, const f32 py2): p1(px1, py1), p2(px2, py2)
|
|
{}
|
|
|
|
line2d_t(const vec2f p1, const vec2f p2): p1(p1), p2(p2)
|
|
{}
|
|
|
|
line2d_t(const f32 px1, const f32 py1, const f32 px2, const f32 py2, const f32 thickness): p1(px1, py1), p2(px2, py2), thickness(thickness)
|
|
{}
|
|
|
|
line2d_t(const vec2f p1, const vec2f p2, const f32 thickness): p1(p1), p2(p2), thickness(thickness)
|
|
{}
|
|
};
|
|
|
|
struct curve2d_mesh_data_t
|
|
{
|
|
struct line_vertex_t
|
|
{
|
|
vec3 pos;
|
|
vec2 uv;
|
|
};
|
|
|
|
struct draw_t
|
|
{
|
|
std::unique_ptr<vertex_array_t> vao;
|
|
i32 count;
|
|
};
|
|
|
|
[[nodiscard]] draw_t to_vertex_array() const;
|
|
size_t populate_vertex_array(vertex_array_t& va) const;
|
|
|
|
[[nodiscard]] std::vector<line_vertex_t> calculate_vertices() const;
|
|
|
|
curve2d_mesh_data_t& with(const curve2d_mesh_data_t& mesh)
|
|
{
|
|
lines.insert(lines.end(), mesh.lines.begin(), mesh.lines.end());
|
|
return *this;
|
|
}
|
|
|
|
curve2d_mesh_data_t& set_thickness(const f32 thickness)
|
|
{
|
|
for (auto& line : lines)
|
|
line.thickness = thickness;
|
|
return *this;
|
|
}
|
|
|
|
std::vector<line2d_t> lines;
|
|
};
|
|
|
|
class curve2d_t
|
|
{
|
|
public:
|
|
curve2d_t(vec2 p0, vec2 p1, vec2 p2);
|
|
curve2d_t(vec2 p0, vec2 p1, vec2 p2, vec2 p3);
|
|
|
|
[[nodiscard]] vec2 get_point(f32 t) const;
|
|
|
|
[[nodiscard]] std::vector<line2d_t> to_lines(i32 segments, f32 thickness = 1.0) const;
|
|
|
|
[[nodiscard]] curve2d_mesh_data_t to_mesh(i32 segments, f32 thickness = 1.0) const;
|
|
|
|
private:
|
|
vec2 m_p0, m_p1, m_p2, m_p3;
|
|
};
|
|
|
|
struct point2d_t
|
|
{
|
|
vec2f pos;
|
|
f32 scale = 1;
|
|
|
|
point2d_t(const f32 x, const f32 y, const f32 scale): pos(x, y), scale(scale)
|
|
{}
|
|
|
|
point2d_t(const f32 x, const f32 y): pos(x, y)
|
|
{}
|
|
|
|
point2d_t(const vec2f pos, const f32 scale): pos(pos), scale(scale)
|
|
{}
|
|
|
|
explicit point2d_t(const vec2f pos): pos(pos)
|
|
{}
|
|
|
|
[[nodiscard]] point2d_t apply_scale(const f32 s) const
|
|
{
|
|
return {pos, scale * s};
|
|
}
|
|
};
|
|
|
|
struct render_info_t
|
|
{
|
|
private:
|
|
constexpr static color4 disabled = color4(0, 0, 0, 0);
|
|
constexpr static vec4 empty{0, 0, 0, 1};
|
|
constexpr static vec4 full{1, 1, 1, 1};
|
|
|
|
render_info_t(const std::string_view texture, color4 color, color4 blend): texture_name(texture), color(color), blend(blend)
|
|
{}
|
|
|
|
public:
|
|
// texture to use
|
|
std::string texture_name;
|
|
// color to use
|
|
color4 color;
|
|
// how much to blend the texture into the color? note blending is always additive!
|
|
color4 blend;
|
|
|
|
render_info_t() = default;
|
|
|
|
static render_info_t make_info(const std::string_view texture)
|
|
{
|
|
render_info_t info{texture, empty, full};
|
|
return info;
|
|
}
|
|
|
|
static render_info_t make_info(const color4 color)
|
|
{
|
|
render_info_t info{"", color, empty};
|
|
return info;
|
|
}
|
|
|
|
static render_info_t make_info(const std::string_view texture, const color4 color, const color4 blend)
|
|
{
|
|
render_info_t info{texture, color, blend};
|
|
return info;
|
|
}
|
|
};
|
|
|
|
class batch_renderer_2d
|
|
{
|
|
private:
|
|
std::unique_ptr<pp_engine_t> engine;
|
|
|
|
template <typename T>
|
|
struct render_object_t
|
|
{
|
|
f32 z_index;
|
|
T obj;
|
|
|
|
render_object_t(const f32 z_index, const T obj): z_index(z_index), obj(obj)
|
|
{}
|
|
};
|
|
|
|
using rectangle2d_obj_t = render_object_t<rectangle2d_t>;
|
|
using point2d_obj_t = render_object_t<point2d_t>;
|
|
using line2d_obj_t = render_object_t<line2d_t>;
|
|
using curve2d_obj_t = render_object_t<curve2d_mesh_data_t>;
|
|
|
|
template <typename T>
|
|
using object_container = hashmap_t<std::string, std::vector<std::pair<render_info_t, T>>>;
|
|
|
|
private:
|
|
std::unique_ptr<vertex_array_t> square_vao;
|
|
std::unique_ptr<vertex_array_t> line_vao;
|
|
std::unique_ptr<vertex_array_t> curve_vao;
|
|
std::unique_ptr<shader_t> square_shader;
|
|
std::unique_ptr<shader_t> point_shader;
|
|
resource_manager& resources;
|
|
matrix_state_manager& state;
|
|
|
|
// texture name -> draw info
|
|
struct
|
|
{
|
|
object_container<rectangle2d_obj_t> complex_rectangles;
|
|
object_container<point2d_obj_t> complex_points;
|
|
object_container<line2d_obj_t> complex_lines;
|
|
object_container<curve2d_obj_t> complex_curves;
|
|
size_t draw_count = 0;
|
|
f32 z_min = std::numeric_limits<f32>::max();
|
|
f32 z_max = std::numeric_limits<f32>::min();
|
|
} draw;
|
|
|
|
template <typename E>
|
|
static void insert_obj(object_container<E>& map, const render_info_t& info, const E& obj)
|
|
{
|
|
map[info.texture_name].emplace_back(info, obj);
|
|
}
|
|
|
|
// called at the end of the render function
|
|
void render_reset();
|
|
|
|
// called before invocation of draw_objects
|
|
void pre_reset();
|
|
|
|
// called after draw_objects()
|
|
void post_reset();
|
|
|
|
void draw_points(f32 denominator);
|
|
|
|
void draw_lines(f32 denominator);
|
|
|
|
void draw_rectangles(f32 denominator);
|
|
|
|
void draw_curves(f32 denominator);
|
|
|
|
void draw_objects();
|
|
|
|
void update_z_index(const f32 z_index)
|
|
{
|
|
draw.z_min = std::min(draw.z_min, -z_index);
|
|
draw.z_max = std::max(draw.z_max, -z_index);
|
|
}
|
|
|
|
public:
|
|
explicit batch_renderer_2d(resource_manager& resources, matrix_state_manager& state): resources(resources), state(state)
|
|
{
|
|
engine = pp_engine_t::make_multi_pp(std::make_unique<pp_render_target_t>());
|
|
}
|
|
|
|
explicit batch_renderer_2d(resource_manager& resources, matrix_state_manager& state, std::unique_ptr<pp_engine_t> ppEngine):
|
|
engine(std::move(ppEngine)), resources(resources), state(state)
|
|
{}
|
|
|
|
void create();
|
|
|
|
void drawRectangle(const rectangle2d_t& rectangle, std::string_view texture, f32 z_index = 0);
|
|
|
|
void drawRectangle(const rectangle2d_t& rectangle, const vec4& color, f32 z_index = 0);
|
|
|
|
void drawRectangle(const rectangle2d_t& rectangle, const render_info_t& draw_info, f32 z_index = 0);
|
|
|
|
void drawLine(const line2d_t& line, std::string_view texture, f32 z_index = 0);
|
|
|
|
void drawLine(const line2d_t& line, const vec4& color, f32 z_index = 0);
|
|
|
|
void drawLine(const line2d_t& line, const render_info_t& draw_info, f32 z_index = 0);
|
|
|
|
void drawPoint(const point2d_t& point, std::string_view texture, f32 z_index = 0);
|
|
|
|
void drawPoint(const point2d_t& point, const vec4& color, f32 z_index = 0);
|
|
|
|
void drawPoint(const point2d_t& point, const render_info_t& draw_info, f32 z_index = 0);
|
|
|
|
void drawCurve(const curve2d_mesh_data_t& curve, std::string_view texture, f32 z_index = 0);
|
|
|
|
void drawCurve(const curve2d_mesh_data_t& curve, const vec4& color, f32 z_index = 0);
|
|
|
|
void drawCurve(const curve2d_mesh_data_t& curve, const render_info_t& draw_info, f32 z_index = 0);
|
|
|
|
void render(i32 width, i32 height, bool transparency = true, bool postprocessing = false);
|
|
|
|
void cleanup();
|
|
|
|
[[nodiscard]] shader_t& get_square_shader() const
|
|
{
|
|
return *square_shader;
|
|
}
|
|
|
|
[[nodiscard]] size_t draw_count() const
|
|
{
|
|
return draw.draw_count;
|
|
}
|
|
};
|
|
}
|
|
|
|
#endif //BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H
|