BLT-With-Graphics-Template/include/blt/gfx/renderer/batch_2d_renderer.h

195 lines
6.8 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/renderer/resource_manager.h"
#include <blt/std/hashmap.h>
#include <blt/std/memory_util.h>
#include <blt/math/vectors.h>
#include <string_view>
#include <vector>
#include <memory>
namespace blt::gfx
{
struct rectangle2d_t
{
blt::vec2f pos, size;
float rotation = 0;
rectangle2d_t(float x, float y, float width, float height, float rotation): pos(x, y), size(width, height), rotation(rotation)
{}
rectangle2d_t(float x, float y, float width, float height): pos(x, y), size(width, height)
{}
rectangle2d_t(blt::vec2f pos, blt::vec2f size, float rotation): pos(pos), size(size), rotation(rotation)
{}
rectangle2d_t(blt::vec2f pos, blt::vec2f size): pos(pos), size(size)
{}
};
struct line2d_t
{
blt::vec2f p1;
blt::vec2f p2;
line2d_t(float px1, float py1, float px2, float py2): p1(px1, py1), p2(px2, py2)
{}
line2d_t(blt::vec2f p1, blt::vec2f p2): p1(p1), p2(p2)
{}
};
struct point2d_t
{
blt::vec2f pos;
float scale = 1;
point2d_t(float x, float y, float scale): pos(x, y), scale(scale)
{}
point2d_t(float x, float y): pos(x, y)
{}
};
struct draw_state
{
// texture to use
std::string texture_name;
// color to use
blt::vec4 color;
// how much to blend the texture into the color? note blending is always additive!
blt::vec4 blend;
};
class batch_renderer_2d
{
private:
struct vec_hash
{
std::size_t operator()(const blt::vec4& key) const
{
using namespace blt::mem;
return type_cast<blt::i32>(key.x()) ^ type_cast<blt::i32>(key.y()) ^ type_cast<blt::i32>(key.y()) ^ type_cast<blt::i32>(key.z());
}
};
private:
vertex_array* square_vao = nullptr;
vertex_array* line_vao = nullptr;
shader_t* square_shader = nullptr;
shader_t* line_shader = nullptr;
shader_t* point_shader = nullptr;
resource_manager& resources;
// texture -> color -> blend factor -> list of rectangles
blt::hashmap_t<std::string, blt::hashmap_t<blt::vec4, blt::hashmap_t<blt::vec4, std::vector<rectangle2d_t>, vec_hash>, vec_hash>> complex_rectangles;
blt::hashmap_t<std::string, blt::hashmap_t<blt::vec4, blt::hashmap_t<blt::vec4, std::vector<point2d_t>, vec_hash>, vec_hash>> complex_points;
// color -> blend factor -> list of lines
blt::hashmap_t<blt::vec4, blt::hashmap_t<blt::vec4, std::vector<line2d_t>, vec_hash>, vec_hash> complex_lines;
size_t draw_count_ = 0;
public:
explicit batch_renderer_2d(resource_manager& resources): resources(resources)
{}
void create();
inline void drawRectangle(std::string_view texture, const rectangle2d_t& rectangle)
{
const static blt::vec4 empty{0, 0, 0, 1};
const static blt::vec4 full{1, 1, 1, 1};
complex_rectangles[texture][empty][full].push_back(rectangle);
}
inline void drawRectangle(const blt::vec4& color, const rectangle2d_t& rectangle)
{
const static blt::vec4 empty{0, 0, 0, 0};
complex_rectangles[""][color][empty].push_back(rectangle);
}
inline void drawRectangle(const draw_state& draw_info, const rectangle2d_t& rectangle)
{
complex_rectangles[draw_info.texture_name][draw_info.color][draw_info.blend].push_back(rectangle);
}
inline void drawLine(const blt::vec4& color, const line2d_t& line)
{
const static blt::vec4 empty{0, 0, 0, 0};
complex_lines[color][empty].push_back(line);
}
inline void drawLine(const draw_state& draw_info, const line2d_t& line)
{
complex_lines[draw_info.color][draw_info.blend].push_back(line);
}
inline void drawPoint(std::string_view texture, const point2d_t& point)
{
const static blt::vec4 empty{0, 0, 0, 1};
const static blt::vec4 full{1, 1, 1, 1};
complex_points[texture][empty][full].push_back(point);
}
inline void drawPoint(const blt::vec4& color, const point2d_t& point)
{
const static blt::vec4 empty{0, 0, 0, 0};
complex_points[""][color][empty].push_back(point);
}
inline void drawPoint(const draw_state& draw_info, const point2d_t& point)
{
complex_points[draw_info.texture_name][draw_info.color][draw_info.blend].push_back(point);
}
template<typename T, typename... P>
inline void drawRectangle(const T& render_info, P... p)
{
drawRectangle(render_info, {p...});
}
template<typename T, typename... P>
inline void drawPoint(const T& render_info, P... p)
{
drawPoint(render_info, {p...});
}
template<typename T, typename... P>
inline void drawLine(const T& render_info, P... p)
{
drawLine(render_info, {p...});
}
void render(bool transparency = true);
void cleanup();
[[nodiscard]] inline size_t draw_count() const
{
return draw_count_;
}
};
}
#endif //BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H