1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
#pragma once
#include "core/memory.h"
#include "vertex_array.h"
#include "shader.h"
#include "framebuffer.h"
#include <glm/glm.hpp>
namespace Donut
{
class RendererAPI
{
public:
enum class API
{
None = 0,
OpenGL = 1,
Vulkan = 2,
};
public:
virtual ~RendererAPI() = default;
virtual void init() = 0;
virtual void set_viewport(uint32_t x, uint32_t y,
uint32_t width, uint32_t height) = 0;
virtual void set_clear_color(const glm::vec4& color) = 0;
virtual void clear() = 0;
virtual void enable_depth_test() = 0;
virtual void disable_depth_test() = 0;
virtual void set_face_culling(bool enabled) = 0;
virtual void enable_blending() = 0;
virtual void disable_blending() = 0;
virtual void draw_indexed(const Ref<VertexArray>& vertex_array,
uint32_t index_count = 0) = 0;
virtual void draw_arrays(uint32_t vertex_count, uint32_t first = 0) = 0;
virtual void draw_lines(const Ref<VertexArray>& vertex_array,
uint32_t index_count = 0) = 0;
virtual void bind_texture(uint32_t texture_id, uint32_t slot = 0) = 0;
virtual void bind_image_texture(uint32_t texture_id,
uint32_t slot = 0,
bool read_only = false) = 0;
virtual void read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
uint32_t format, uint32_t type, void* pixels) = 0;
inline static API get_api() { return s_api; }
inline static void set_api(API api) { s_api = api; }
static Scope<RendererAPI> create();
private:
static API s_api;
};
class RenderCommand
{
public:
inline static void init()
{
s_renderer_api->init();
}
inline static void set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
{
s_renderer_api->set_viewport(x, y, width, height);
}
inline static void set_clear_color(const glm::vec4& color)
{
s_renderer_api->set_clear_color(color);
}
inline static void clear()
{
s_renderer_api->clear();
}
inline static void enable_depth_test()
{
s_renderer_api->enable_depth_test();
}
inline static void disable_depth_test()
{
s_renderer_api->disable_depth_test();
}
inline static void set_face_culling(bool enabled)
{
s_renderer_api->set_face_culling(enabled);
}
inline static void enable_blending()
{
s_renderer_api->enable_blending();
}
inline static void disable_blending()
{
s_renderer_api->disable_blending();
}
inline static void draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
{
s_renderer_api->draw_indexed(vertex_array, index_count);
}
inline static void draw_arrays(uint32_t vertex_count, uint32_t first = 0)
{
s_renderer_api->draw_arrays(vertex_count, first);
}
inline static void draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
{
s_renderer_api->draw_lines(vertex_array, index_count);
}
inline static void bind_texture(uint32_t texture_id, uint32_t slot = 0)
{
s_renderer_api->bind_texture(texture_id, slot);
}
inline static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false)
{
s_renderer_api->bind_image_texture(texture_id, slot, read_only);
}
inline static void read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
uint32_t format, uint32_t type, void* pixels)
{
s_renderer_api->read_pixels(x, y, width, height, format, type, pixels);
}
private:
static Scope<RendererAPI> s_renderer_api;
};
class Renderer
{
public:
static void init();
static void shutdown();
static void on_window_resize(uint32_t width, uint32_t height);
static void submit(const Ref<Shader>& shader,
const Ref<VertexArray>& vertex_array,
const glm::mat4& transform,
const glm::mat4& view_projection);
static void set_clear_color(const glm::vec4& color);
static void clear();
inline static RendererAPI::API get_api() { return RendererAPI::get_api(); }
};
};
|
