drawqueue.h

main 334 lines · 10.3 KB Raw
Alex Alex Commit Client Upload Part 2 19/10/2026 00:06
1#ifndef DRAWQUEUE_H
2#define DRAWQUEUE_H
3
4#include <framework/graphics/colorarray.h>
5#include <framework/graphics/coordsbuffer.h>
6#include <framework/graphics/declarations.h>
7#include <framework/graphics/deptharray.h>
8#include <framework/graphics/paintershaderprogram.h>
9#include <framework/graphics/texture.h>
10#include <framework/ui/uiwidget.h>
11#include <vector>
12
13class DrawQueue;
14struct DrawQueueItem;
15
16enum DrawType : uint8_t {
17 DRAW_ALL = 0,
18 DRAW_BEFORE_MAP = 1,
19 DRAW_AFTER_MAP = 2
20};
21
22struct DrawQueueItem {
23 DrawQueueItem(const TexturePtr &texture, const Color &color = Color::white)
24 : m_texture(texture), m_color(color) {}
25 virtual ~DrawQueueItem() = default;
26 virtual void draw() {}
27 virtual void draw(const Point &pos) {}
28 virtual bool cache() { return false; }
29
30 TexturePtr m_texture;
31 Color m_color;
32};
33
34struct DrawQueueItemTexturedRect : public DrawQueueItem {
35 DrawQueueItemTexturedRect() : DrawQueueItem(nullptr) {}
36 DrawQueueItemTexturedRect(const Rect &dest, const TexturePtr &texture,
37 const Rect &src, const Color &color)
38 : DrawQueueItem(texture, color), m_dest(dest), m_src(src) {};
39 virtual ~DrawQueueItemTexturedRect() = default;
40
41 virtual void draw();
42 virtual void draw(const Point &pos);
43 virtual bool cache();
44
45 Rect m_dest;
46 Rect m_src;
47};
48
49struct DrawQueueItemTextureCoords : public DrawQueueItem {
50 DrawQueueItemTextureCoords(CoordsBuffer &coordsBuffer,
51 const TexturePtr &texture, const Color &color)
52 : DrawQueueItem(texture, color),
53 m_coordsBuffer(std::move(coordsBuffer)) {};
54
55 void draw();
56 void draw(const Point &pos);
57 bool cache();
58
59 CoordsBuffer m_coordsBuffer;
60};
61
62struct DrawQueueItemColoredTextureCoords : public DrawQueueItem {
63 DrawQueueItemColoredTextureCoords(
64 CoordsBuffer &coordsBuffer, const TexturePtr &texture,
65 const std::vector<std::pair<int, Color>> &colors)
66 : DrawQueueItem(texture), m_coordsBuffer(std::move(coordsBuffer)),
67 m_colors(colors) {};
68
69 void draw();
70
71 CoordsBuffer m_coordsBuffer;
72 std::vector<std::pair<int, Color>> m_colors;
73};
74
75struct DrawQueueItemImageWithShader : public DrawQueueItemTextureCoords {
76 DrawQueueItemImageWithShader(CoordsBuffer &coords, const TexturePtr &texture,
77 const Color &color, const std::string &shader)
78 : DrawQueueItemTextureCoords(coords, texture, color), m_shader(shader) {};
79
80 void draw() override;
81 void draw(const Point &pos) override;
82 bool cache() override { return false; }
83
84 std::string m_shader;
85};
86
87struct DrawQueueItemFilledRect : public DrawQueueItem {
88 DrawQueueItemFilledRect(const Rect &rect, const Color &color)
89 : DrawQueueItem(nullptr, color), m_dest(rect) {};
90 bool cache();
91
92 Rect m_dest;
93};
94
95struct DrawQueueItemClearRect : public DrawQueueItem {
96 DrawQueueItemClearRect(const Rect &rect, const Color &color)
97 : DrawQueueItem(nullptr, color), m_dest(rect) {};
98 void draw();
99
100 Rect m_dest;
101};
102
103struct DrawQueueItemFillCoords : public DrawQueueItem {
104 DrawQueueItemFillCoords(CoordsBuffer &coordsBuffer, const Color &color)
105 : DrawQueueItem(nullptr, color),
106 m_coordsBuffer(std::move(coordsBuffer)) {};
107 bool cache();
108
109 CoordsBuffer m_coordsBuffer;
110};
111
112struct DrawQueueItemText : public DrawQueueItem {
113 DrawQueueItemText(const Point &point, const TexturePtr &texture,
114 uint64_t hash, const Color &color, bool shadow = false)
115 : DrawQueueItem(texture, color), m_point(point), m_hash(hash),
116 m_shadow(shadow) {};
117 void draw();
118
119 Point m_point;
120 uint64_t m_hash;
121 bool m_shadow = false;
122};
123
124struct DrawQueueItemTextColored : public DrawQueueItem {
125 DrawQueueItemTextColored(const Point &point, const TexturePtr &texture,
126 uint64_t hash,
127 const std::vector<std::pair<int, Color>> &colors,
128 bool shadow = false)
129 : DrawQueueItem(texture), m_point(point), m_hash(hash), m_colors(colors),
130 m_shadow(shadow) {};
131 void draw();
132
133 Point m_point;
134 uint64_t m_hash;
135 std::vector<std::pair<int, Color>> m_colors;
136 bool m_shadow = false;
137};
138
139struct DrawQueueItemLine : public DrawQueueItem {
140 DrawQueueItemLine(const std::vector<Point> &points, int width,
141 const Color &color)
142 : DrawQueueItem(nullptr, color), m_points(points), m_width(width) {};
143 void draw();
144
145 std::vector<Point> m_points;
146 int m_width;
147};
148
149struct DrawQueueCondition {
150 DrawQueueCondition(size_t start, size_t end) : m_start(start), m_end(end) {}
151 virtual ~DrawQueueCondition() = default;
152
153 virtual void start(DrawQueue *) = 0;
154 virtual void end(DrawQueue *) = 0;
155
156 size_t m_start;
157 size_t m_end;
158};
159
160struct DrawQueueConditionClip : public DrawQueueCondition {
161 DrawQueueConditionClip(size_t start, size_t end, const Rect &rect)
162 : DrawQueueCondition(start, end), m_rect(rect) {}
163
164 void start(DrawQueue *queue) override;
165 void end(DrawQueue *queue) override;
166
167 Rect m_rect;
168 Rect m_prevClip;
169};
170
171struct DrawQueueConditionRotation : public DrawQueueCondition {
172 DrawQueueConditionRotation(size_t start, size_t end, const Point &center,
173 float angle)
174 : DrawQueueCondition(start, end), m_center(center), m_angle(angle) {}
175
176 void start(DrawQueue *queue) override;
177 void end(DrawQueue *queue) override;
178
179 Point m_center;
180 float m_angle;
181};
182
183struct DrawQueueConditionMark : public DrawQueueCondition {
184 DrawQueueConditionMark(size_t start, size_t end, const Color &color)
185 : DrawQueueCondition(start, end), m_color(color) {}
186
187 void start(DrawQueue *queue) override;
188 void end(DrawQueue *queue) override;
189
190 Color m_color;
191};
192
193class DrawQueue {
194public:
195 DrawQueue() = default;
196 DrawQueue(const DrawQueue &) = delete;
197 DrawQueue &operator=(const DrawQueue &) = delete;
198 ~DrawQueue() {
199 for (auto &item : m_queue)
200 delete item;
201 m_queue.clear();
202 for (auto &condition : m_conditions)
203 delete condition;
204 m_conditions.clear();
205 }
206
207 void draw(DrawType drawType = DRAW_ALL);
208
209 void add(DrawQueueItem *item) {
210 if (!item)
211 return;
212 m_queue.push_back(item);
213 }
214 DrawQueueItemTexturedRect *
215 addTexturedRect(const Rect &dest, const TexturePtr &texture, const Rect &src,
216 const Color &color = Color::white) {
217 DrawQueueItemTexturedRect *item(
218 new DrawQueueItemTexturedRect(dest, texture, src, color));
219 m_queue.push_back(item);
220 return item;
221 }
222 void addTextureCoords(CoordsBuffer &coords, const TexturePtr &texture,
223 const Color &color = Color::white) {
224 m_queue.push_back(new DrawQueueItemTextureCoords(coords, texture, color));
225 }
226 void
227 addColoredTextureCoords(CoordsBuffer &coords, const TexturePtr &texture,
228 const std::vector<std::pair<int, Color>> &colors) {
229 m_queue.push_back(
230 new DrawQueueItemColoredTextureCoords(coords, texture, colors));
231 }
232 void addFilledRect(const Rect &dest, const Color &color = Color::white) {
233 m_queue.push_back(new DrawQueueItemFilledRect(dest, color));
234 }
235 void addFillCoords(CoordsBuffer &coords, const Color &color = Color::white) {
236 m_queue.push_back(new DrawQueueItemFillCoords(coords, color));
237 }
238 void addClearRect(const Rect &dest, const Color &color = Color::white) {
239 m_queue.push_back(new DrawQueueItemClearRect(dest, color));
240 }
241 void addText(BitmapFontPtr font, const std::string &text,
242 const Rect &screenCoords,
243 Fw::AlignmentFlag align = Fw::AlignTopLeft,
244 const Color &color = Color::white, bool shadow = false);
245 void addColoredText(BitmapFontPtr font, const std::string &text,
246 const Rect &screenCoords, Fw::AlignmentFlag align,
247 const std::vector<std::pair<int, Color>> &colors,
248 bool shadow = false);
249
250 void addFilledTriangle(const Point &a, const Point &b, const Point &c,
251 const Color &color = Color::white) {
252 if (a == b || a == c || b == c)
253 return;
254
255 CoordsBuffer coordsBuffer;
256 coordsBuffer.addTriangle(a, b, c);
257 addFillCoords(coordsBuffer, color);
258 }
259 void addBoundingRect(const Rect &dest, int innerLineWidth,
260 const Color &color = Color::white) {
261 if (dest.isEmpty() || innerLineWidth == 0)
262 return;
263
264 CoordsBuffer coordsBuffer;
265 coordsBuffer.addBoudingRect(dest, innerLineWidth);
266 addFillCoords(coordsBuffer, color);
267 }
268
269 void addLine(const std::vector<Point> &points, int width,
270 const Color &color = Color::white) {
271 if (points.empty() || width < 0)
272 return;
273
274 m_queue.push_back(new DrawQueueItemLine(points, width, color));
275 }
276
277 void setFrameBuffer(const Rect &dest, const Size &size, const Rect &src);
278 bool hasFrameBuffer() { return m_useFrameBuffer; }
279 Rect getFrameBufferDest() { return m_frameBufferDest; }
280 Size getFrameBufferSize() { return m_frameBufferSize; }
281 Rect getFrameBufferSrc() { return m_frameBufferSrc; }
282
283 size_t size() { return m_queue.size(); }
284
285 void setOpacity(size_t start, float opacity) {
286 for (size_t i = start; i < m_queue.size(); ++i) {
287 m_queue[i]->m_color = m_queue[i]->m_color.opacity(opacity);
288 }
289 }
290
291 void setClip(size_t start, const Rect &clip) {
292 if (start == m_queue.size())
293 return;
294 m_conditions.push_back(
295 new DrawQueueConditionClip(start, m_queue.size(), clip));
296 }
297
298 void setRotation(size_t start, const Point &center, float angle) {
299 if (start == m_queue.size() || angle == 0)
300 return;
301 m_conditions.push_back(
302 new DrawQueueConditionRotation(start, m_queue.size(), center, angle));
303 }
304
305 void setMark(size_t start, const Color &color) {
306 if (start == m_queue.size())
307 return;
308 m_conditions.push_back(
309 new DrawQueueConditionMark(start, m_queue.size(), color));
310 }
311
312 void markMapPosition() { mapPosition = m_queue.size(); }
313 void correctOutfit(const Rect &dest, int fromPos, bool oldScaling);
314
315 void setShader(const std::string &shader) { m_shader = shader; }
316
317 std::string getShader() { return m_shader; }
318
319private:
320 std::vector<DrawQueueItem *> m_queue;
321 std::vector<DrawQueueCondition *> m_conditions;
322 Size m_frameBufferSize;
323 Rect m_frameBufferDest, m_frameBufferSrc;
324 size_t mapPosition = 0;
325 bool m_useFrameBuffer = false;
326 float m_scaling = 1.f;
327 std::string m_shader;
328
329 friend struct DrawQueueConditionMark;
330};
331
332extern std::shared_ptr<DrawQueue> g_drawQueue;
333
334#endif
Top