1/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
2/* If you are missing that file, acquire a complete release at teeworlds.com. */
3#ifndef ENGINE_GRAPHICS_H
4#define ENGINE_GRAPHICS_H
5
6#include "image.h"
7#include "kernel.h"
8#include "warning.h"
9
10#include <base/color.h>
11#include <base/vmath.h>
12
13#include <cstddef>
14#include <cstdint>
15#include <functional>
16#include <optional>
17#include <vector>
18
19#define GRAPHICS_TYPE_UNSIGNED_BYTE 0x1401
20#define GRAPHICS_TYPE_UNSIGNED_SHORT 0x1403
21#define GRAPHICS_TYPE_INT 0x1404
22#define GRAPHICS_TYPE_UNSIGNED_INT 0x1405
23#define GRAPHICS_TYPE_FLOAT 0x1406
24
25struct SBufferContainerInfo
26{
27 int m_Stride;
28 int m_VertBufferBindingIndex;
29
30 // the attributes of the container
31 struct SAttribute
32 {
33 int m_DataTypeCount;
34 unsigned int m_Type;
35 bool m_Normalized;
36 void *m_pOffset;
37
38 //0: float, 1:integer
39 unsigned int m_FuncType;
40 };
41 std::vector<SAttribute> m_vAttributes;
42};
43
44struct SQuadRenderInfo
45{
46 ColorRGBA m_Color;
47 vec2 m_Offsets;
48 float m_Rotation;
49 // allows easier upload for uniform buffers because of the alignment requirements
50 float m_Padding;
51};
52
53class CGraphicTile
54{
55public:
56 vec2 m_TopLeft;
57 vec2 m_TopRight;
58 vec2 m_BottomRight;
59 vec2 m_BottomLeft;
60};
61
62class CGraphicTileTextureCoords
63{
64public:
65 ubvec4 m_TexCoordTopLeft;
66 ubvec4 m_TexCoordTopRight;
67 ubvec4 m_TexCoordBottomRight;
68 ubvec4 m_TexCoordBottomLeft;
69};
70
71/*
72 Structure: CVideoMode
73*/
74class CVideoMode
75{
76public:
77 int m_CanvasWidth, m_CanvasHeight;
78 int m_WindowWidth, m_WindowHeight;
79 int m_RefreshRate;
80 int m_Red, m_Green, m_Blue;
81 uint32_t m_Format;
82};
83
84typedef vec2 GL_SPoint;
85typedef vec2 GL_STexCoord;
86
87struct GL_STexCoord3D
88{
89 GL_STexCoord3D &operator=(const GL_STexCoord &TexCoord)
90 {
91 u = TexCoord.u;
92 v = TexCoord.v;
93 return *this;
94 }
95
96 GL_STexCoord3D &operator=(const vec3 &TexCoord)
97 {
98 u = TexCoord.u;
99 v = TexCoord.v;
100 w = TexCoord.w;
101 return *this;
102 }
103
104 float u, v, w;
105};
106
107typedef ColorRGBA GL_SColorf;
108//use normalized color values
109typedef vector4_base<unsigned char> GL_SColor;
110
111struct GL_SVertex
112{
113 GL_SPoint m_Pos;
114 GL_STexCoord m_Tex;
115 GL_SColor m_Color;
116};
117
118struct GL_SVertexTex3D
119{
120 GL_SPoint m_Pos;
121 GL_SColorf m_Color;
122 GL_STexCoord3D m_Tex;
123};
124
125struct GL_SVertexTex3DStream
126{
127 GL_SPoint m_Pos;
128 GL_SColor m_Color;
129 GL_STexCoord3D m_Tex;
130};
131
132static constexpr size_t GRAPHICS_MAX_QUADS_RENDER_COUNT = 256;
133static constexpr size_t GRAPHICS_MAX_PARTICLES_RENDER_COUNT = 512;
134
135enum EGraphicsDriverAgeType
136{
137 GRAPHICS_DRIVER_AGE_TYPE_LEGACY = 0,
138 GRAPHICS_DRIVER_AGE_TYPE_DEFAULT,
139 GRAPHICS_DRIVER_AGE_TYPE_MODERN,
140
141 GRAPHICS_DRIVER_AGE_TYPE_COUNT,
142};
143
144enum EBackendType
145{
146 BACKEND_TYPE_OPENGL = 0,
147 BACKEND_TYPE_OPENGL_ES,
148 BACKEND_TYPE_VULKAN,
149
150 // special value to tell the backend to identify the current backend
151 BACKEND_TYPE_AUTO,
152
153 BACKEND_TYPE_COUNT,
154};
155
156struct STWGraphicGpu
157{
158 enum ETWGraphicsGpuType
159 {
160 GRAPHICS_GPU_TYPE_DISCRETE = 0,
161 GRAPHICS_GPU_TYPE_INTEGRATED,
162 GRAPHICS_GPU_TYPE_VIRTUAL,
163 GRAPHICS_GPU_TYPE_CPU,
164
165 // should stay at last position in this enum
166 GRAPHICS_GPU_TYPE_INVALID,
167 };
168
169 struct STWGraphicGpuItem
170 {
171 char m_aName[256];
172 ETWGraphicsGpuType m_GpuType;
173 };
174 std::vector<STWGraphicGpuItem> m_vGpus;
175 STWGraphicGpuItem m_AutoGpu;
176};
177
178typedef STWGraphicGpu TTwGraphicsGpuList;
179
180typedef std::function<void()> WINDOW_RESIZE_FUNC;
181typedef std::function<void()> WINDOW_PROPS_CHANGED_FUNC;
182
183typedef std::function<bool(uint32_t &Width, uint32_t &Height, CImageInfo::EImageFormat &Format, std::vector<uint8_t> &vDstData)> TGLBackendReadPresentedImageData;
184
185struct CDataSprite;
186
187class IGraphics : public IInterface
188{
189 MACRO_INTERFACE("graphics")
190protected:
191 int m_ScreenWidth;
192 int m_ScreenHeight;
193 int m_ScreenRefreshRate;
194 float m_ScreenHiDPIScale;
195
196public:
197 enum
198 {
199 TEXLOAD_TO_3D_TEXTURE = 1 << 0,
200 TEXLOAD_TO_2D_ARRAY_TEXTURE = 1 << 1,
201 TEXLOAD_NO_2D_TEXTURE = 1 << 2,
202 };
203
204 class CTextureHandle
205 {
206 friend class IGraphics;
207 int m_Id;
208
209 public:
210 CTextureHandle() :
211 m_Id(-1)
212 {
213 }
214
215 bool IsValid() const { return Id() >= 0; }
216 bool IsNullTexture() const { return Id() == 0; }
217 int Id() const { return m_Id; }
218 void Invalidate() { m_Id = -1; }
219 };
220
221 int ScreenWidth() const { return m_ScreenWidth; }
222 int ScreenHeight() const { return m_ScreenHeight; }
223 float ScreenAspect() const { return (float)ScreenWidth() / (float)ScreenHeight(); }
224 float ScreenHiDPIScale() const { return m_ScreenHiDPIScale; }
225 int WindowWidth() const { return m_ScreenWidth / m_ScreenHiDPIScale; }
226 int WindowHeight() const { return m_ScreenHeight / m_ScreenHiDPIScale; }
227
228 virtual void WarnPngliteIncompatibleImages(bool Warn) = 0;
229 virtual void SetWindowParams(int FullscreenMode, bool IsBorderless) = 0;
230 virtual bool SetWindowScreen(int Index, bool MoveToCenter) = 0;
231 virtual bool SwitchWindowScreen(int Index, bool MoveToCenter) = 0;
232 virtual bool SetVSync(bool State) = 0;
233 virtual bool SetMultiSampling(uint32_t ReqMultiSamplingCount, uint32_t &MultiSamplingCountBackend) = 0;
234 virtual int GetWindowScreen() = 0;
235 virtual void Move(int x, int y) = 0;
236 virtual bool Resize(int w, int h, int RefreshRate) = 0;
237 virtual void ResizeToScreen() = 0;
238 virtual void GotResized(int w, int h, int RefreshRate) = 0;
239 virtual void UpdateViewport(int X, int Y, int W, int H, bool ByResize) = 0;
240 virtual bool IsScreenKeyboardShown() = 0;
241
242 /**
243 * Listens to a resize event of the canvas, which is usually caused by a window resize.
244 * Will only be triggered if the actual size changed.
245 */
246 virtual void AddWindowResizeListener(WINDOW_RESIZE_FUNC pFunc) = 0;
247 /**
248 * Listens to various window property changes, such as minimize, maximize, move, fullscreen mode
249 */
250 virtual void AddWindowPropChangeListener(WINDOW_PROPS_CHANGED_FUNC pFunc) = 0;
251
252 virtual void WindowDestroyNtf(uint32_t WindowId) = 0;
253 virtual void WindowCreateNtf(uint32_t WindowId) = 0;
254
255 // ForceClearNow forces the backend to trigger a clear, even at performance cost, else it might be delayed by one frame
256 virtual void Clear(float r, float g, float b, bool ForceClearNow = false) = 0;
257
258 virtual void ClipEnable(int x, int y, int w, int h) = 0;
259 virtual void ClipDisable() = 0;
260
261 virtual void MapScreen(float TopLeftX, float TopLeftY, float BottomRightX, float BottomRightY) = 0;
262
263 // helper functions
264 void CalcScreenParams(float Aspect, float Zoom, float *pWidth, float *pHeight) const;
265 void MapScreenToWorld(float CenterX, float CenterY, float ParallaxX, float ParallaxY,
266 float ParallaxZoom, float OffsetX, float OffsetY, float Aspect, float Zoom, float *pPoints) const;
267 void MapScreenToInterface(float CenterX, float CenterY, float Zoom = 1.0f);
268
269 virtual void GetScreen(float *pTopLeftX, float *pTopLeftY, float *pBottomRightX, float *pBottomRightY) const = 0;
270
271 // TODO: These should perhaps not be virtuals
272 virtual void BlendNone() = 0;
273 virtual void BlendNormal() = 0;
274 virtual void BlendAdditive() = 0;
275 virtual void WrapNormal() = 0;
276 virtual void WrapClamp() = 0;
277
278 virtual uint64_t TextureMemoryUsage() const = 0;
279 virtual uint64_t BufferMemoryUsage() const = 0;
280 virtual uint64_t StreamedMemoryUsage() const = 0;
281 virtual uint64_t StagingMemoryUsage() const = 0;
282
283 virtual const TTwGraphicsGpuList &GetGpus() const = 0;
284
285 virtual bool LoadPng(CImageInfo &Image, const char *pFilename, int StorageType) = 0;
286 virtual bool LoadPng(CImageInfo &Image, const uint8_t *pData, size_t DataSize, const char *pContextName) = 0;
287
288 virtual bool CheckImageDivisibility(const char *pContextName, CImageInfo &Image, int DivX, int DivY, bool AllowResize) = 0;
289 virtual bool IsImageFormatRgba(const char *pContextName, const CImageInfo &Image) = 0;
290
291 virtual void UnloadTexture(CTextureHandle *pIndex) = 0;
292 virtual CTextureHandle LoadTextureRaw(const CImageInfo &Image, int Flags, const char *pTexName = nullptr) = 0;
293 virtual CTextureHandle LoadTextureRawMove(CImageInfo &Image, int Flags, const char *pTexName = nullptr) = 0;
294 virtual CTextureHandle LoadTexture(const char *pFilename, int StorageType, int Flags = 0) = 0;
295 virtual void TextureSet(CTextureHandle Texture) = 0;
296 void TextureClear() { TextureSet(Texture: CTextureHandle()); }
297
298 // pTextData & pTextOutlineData are automatically free'd
299 virtual bool LoadTextTextures(size_t Width, size_t Height, CTextureHandle &TextTexture, CTextureHandle &TextOutlineTexture, uint8_t *pTextData, uint8_t *pTextOutlineData) = 0;
300 virtual bool UnloadTextTextures(CTextureHandle &TextTexture, CTextureHandle &TextOutlineTexture) = 0;
301 virtual bool UpdateTextTexture(CTextureHandle TextureId, int x, int y, size_t Width, size_t Height, uint8_t *pData, bool IsMovedPointer) = 0;
302
303 virtual CTextureHandle LoadSpriteTexture(const CImageInfo &FromImageInfo, const struct CDataSprite *pSprite) = 0;
304
305 virtual bool IsImageSubFullyTransparent(const CImageInfo &FromImageInfo, int x, int y, int w, int h) = 0;
306 virtual bool IsSpriteTextureFullyTransparent(const CImageInfo &FromImageInfo, const struct CDataSprite *pSprite) = 0;
307
308 virtual void FlushVertices(bool KeepVertices = false) = 0;
309 virtual void FlushVerticesTex3D() = 0;
310
311 // specific render functions
312 virtual void RenderTileLayer(int BufferContainerIndex, const ColorRGBA &Color, char **pOffsets, unsigned int *pIndicedVertexDrawNum, size_t NumIndicesOffset) = 0;
313 virtual void RenderBorderTiles(int BufferContainerIndex, const ColorRGBA &Color, char *pIndexBufferOffset, const vec2 &Offset, const vec2 &Scale, uint32_t DrawNum) = 0;
314 virtual void RenderQuadLayer(int BufferContainerIndex, SQuadRenderInfo *pQuadInfo, size_t QuadNum, int QuadOffset, bool Grouped = false) = 0;
315 virtual void RenderText(int BufferContainerIndex, int TextQuadNum, int TextureSize, int TextureTextIndex, int TextureTextOutlineIndex, const ColorRGBA &TextColor, const ColorRGBA &TextOutlineColor) = 0;
316
317 // opengl 3.3 functions
318
319 enum EBufferObjectCreateFlags
320 {
321 // tell the backend that the buffer only needs to be valid for the span of one frame. Buffer size is not allowed to be bigger than GL_SVertex * MAX_VERTICES
322 BUFFER_OBJECT_CREATE_FLAGS_ONE_TIME_USE_BIT = 1 << 0,
323 };
324
325 // if a pointer is passed as moved pointer, it requires to be allocated with malloc()
326 virtual int CreateBufferObject(size_t UploadDataSize, void *pUploadData, int CreateFlags, bool IsMovedPointer = false) = 0;
327 virtual void RecreateBufferObject(int BufferIndex, size_t UploadDataSize, void *pUploadData, int CreateFlags, bool IsMovedPointer = false) = 0;
328 virtual void DeleteBufferObject(int BufferIndex) = 0;
329
330 virtual int CreateBufferContainer(struct SBufferContainerInfo *pContainerInfo) = 0;
331 // destroying all buffer objects means, that all referenced VBOs are destroyed automatically, so the user does not need to save references to them
332 virtual void DeleteBufferContainer(int &ContainerIndex, bool DestroyAllBO = true) = 0;
333 virtual void IndicesNumRequiredNotify(unsigned int RequiredIndicesCount) = 0;
334
335 // returns true if the driver age type is supported, passing BACKEND_TYPE_AUTO for BackendType will query the values for the currently used backend
336 virtual bool GetDriverVersion(EGraphicsDriverAgeType DriverAgeType, int &Major, int &Minor, int &Patch, const char *&pName, EBackendType BackendType) = 0;
337 virtual bool IsConfigModernAPI() = 0;
338 virtual bool IsTileBufferingEnabled() = 0;
339 virtual bool IsQuadBufferingEnabled() = 0;
340 virtual bool IsTextBufferingEnabled() = 0;
341 virtual bool IsQuadContainerBufferingEnabled() = 0;
342 virtual bool Uses2DTextureArrays() = 0;
343 virtual int TextureLoadFlags() = 0;
344 virtual bool HasTextureArraysSupport() = 0;
345
346 virtual const char *GetVendorString() = 0;
347 virtual const char *GetVersionString() = 0;
348 virtual const char *GetRendererString() = 0;
349 virtual const char *GetFatalError() const = 0;
350
351 class CLineItem
352 {
353 public:
354 float m_X0, m_Y0, m_X1, m_Y1;
355 CLineItem() = default;
356 CLineItem(float x0, float y0, float x1, float y1) :
357 m_X0(x0), m_Y0(y0), m_X1(x1), m_Y1(y1) {}
358 CLineItem(vec2 From, vec2 To)
359 {
360 m_X0 = From.x;
361 m_Y0 = From.y;
362 m_X1 = To.x;
363 m_Y1 = To.y;
364 }
365 };
366 virtual void LinesBegin() = 0;
367 virtual void LinesEnd() = 0;
368 virtual void LinesDraw(const CLineItem *pArray, size_t Num) = 0;
369
370 class CLineItemBatch
371 {
372 public:
373 IGraphics::CLineItem m_aItems[256];
374 size_t m_NumItems = 0;
375 };
376 virtual void LinesBatchBegin(CLineItemBatch *pBatch) = 0;
377 virtual void LinesBatchEnd(CLineItemBatch *pBatch) = 0;
378 virtual void LinesBatchDraw(CLineItemBatch *pBatch, const CLineItem *pArray, size_t Num) = 0;
379
380 virtual void QuadsBegin() = 0;
381 virtual void QuadsEnd() = 0;
382 virtual void QuadsTex3DBegin() = 0;
383 virtual void QuadsTex3DEnd() = 0;
384 virtual void TrianglesBegin() = 0;
385 virtual void TrianglesEnd() = 0;
386 virtual void QuadsEndKeepVertices() = 0;
387 virtual void QuadsDrawCurrentVertices(bool KeepVertices = true) = 0;
388 virtual void QuadsSetRotation(float Angle) = 0;
389 virtual void QuadsSetSubset(float TopLeftU, float TopLeftV, float BottomRightU, float BottomRightV) = 0;
390 virtual void QuadsSetSubsetFree(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, int Index = -1) = 0;
391
392 struct CFreeformItem
393 {
394 float m_X0, m_Y0, m_X1, m_Y1, m_X2, m_Y2, m_X3, m_Y3;
395 CFreeformItem() = default;
396 CFreeformItem(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3) :
397 m_X0(x0), m_Y0(y0), m_X1(x1), m_Y1(y1), m_X2(x2), m_Y2(y2), m_X3(x3), m_Y3(y3) {}
398 CFreeformItem(vec2 Point1, vec2 Point2, vec2 Point3, vec2 Point4) :
399 m_X0(Point1.x), m_Y0(Point1.y), m_X1(Point2.x), m_Y1(Point2.y), m_X2(Point3.x), m_Y2(Point3.y), m_X3(Point4.x), m_Y3(Point4.y) {}
400 };
401
402 struct CQuadItem
403 {
404 float m_X, m_Y, m_Width, m_Height;
405 CQuadItem() = default;
406 CQuadItem(float x, float y, float w, float h) :
407 m_X(x), m_Y(y), m_Width(w), m_Height(h) {}
408 CQuadItem(vec2 Position, vec2 Size) :
409 m_X(Position.x), m_Y(Position.y), m_Width(Size.x), m_Height(Size.y) {}
410 };
411 virtual void QuadsDraw(CQuadItem *pArray, int Num) = 0;
412 virtual void QuadsDrawTL(const CQuadItem *pArray, int Num) = 0;
413
414 virtual void QuadsTex3DDrawTL(const CQuadItem *pArray, int Num) = 0;
415
416 virtual int CreateQuadContainer(bool AutomaticUpload = true) = 0;
417 virtual void QuadContainerChangeAutomaticUpload(int ContainerIndex, bool AutomaticUpload) = 0;
418 virtual void QuadContainerUpload(int ContainerIndex) = 0;
419 virtual int QuadContainerAddQuads(int ContainerIndex, CQuadItem *pArray, int Num) = 0;
420 virtual int QuadContainerAddQuads(int ContainerIndex, CFreeformItem *pArray, int Num) = 0;
421 virtual void QuadContainerReset(int ContainerIndex) = 0;
422 virtual void DeleteQuadContainer(int &ContainerIndex) = 0;
423 virtual void RenderQuadContainer(int ContainerIndex, int QuadDrawNum) = 0;
424 virtual void RenderQuadContainer(int ContainerIndex, int QuadOffset, int QuadDrawNum, bool ChangeWrapMode = true) = 0;
425 virtual void RenderQuadContainerEx(int ContainerIndex, int QuadOffset, int QuadDrawNum, float X, float Y, float ScaleX = 1.f, float ScaleY = 1.f) = 0;
426 virtual void RenderQuadContainerAsSprite(int ContainerIndex, int QuadOffset, float X, float Y, float ScaleX = 1.f, float ScaleY = 1.f) = 0;
427
428 struct SRenderSpriteInfo
429 {
430 vec2 m_Pos;
431 float m_Scale;
432 float m_Rotation;
433 };
434
435 virtual void RenderQuadContainerAsSpriteMultiple(int ContainerIndex, int QuadOffset, int DrawCount, SRenderSpriteInfo *pRenderInfo) = 0;
436
437 virtual void QuadsDrawFreeform(const CFreeformItem *pArray, int Num) = 0;
438 virtual void QuadsText(float x, float y, float Size, const char *pText) = 0;
439
440 // sprites
441 enum
442 {
443 SPRITE_FLAG_FLIP_Y = 1,
444 SPRITE_FLAG_FLIP_X = 2,
445 };
446 virtual void SelectSprite(int Id, int Flags = 0) = 0;
447 virtual void SelectSprite7(int Id, int Flags = 0) = 0;
448
449 virtual void GetSpriteScale(const CDataSprite *pSprite, float &ScaleX, float &ScaleY) const = 0;
450 virtual void GetSpriteScale(int Id, float &ScaleX, float &ScaleY) const = 0;
451 virtual void GetSpriteScaleImpl(int Width, int Height, float &ScaleX, float &ScaleY) const = 0;
452
453 virtual void DrawSprite(float x, float y, float Size) = 0;
454 virtual void DrawSprite(float x, float y, float ScaledWidth, float ScaledHeight) = 0;
455
456 virtual int QuadContainerAddSprite(int QuadContainerIndex, float x, float y, float Size) = 0;
457 virtual int QuadContainerAddSprite(int QuadContainerIndex, float Size) = 0;
458 virtual int QuadContainerAddSprite(int QuadContainerIndex, float Width, float Height) = 0;
459 virtual int QuadContainerAddSprite(int QuadContainerIndex, float X, float Y, float Width, float Height) = 0;
460
461 enum
462 {
463 CORNER_NONE = 0,
464 CORNER_TL = 1,
465 CORNER_TR = 2,
466 CORNER_BL = 4,
467 CORNER_BR = 8,
468
469 CORNER_T = CORNER_TL | CORNER_TR,
470 CORNER_B = CORNER_BL | CORNER_BR,
471 CORNER_R = CORNER_TR | CORNER_BR,
472 CORNER_L = CORNER_TL | CORNER_BL,
473
474 CORNER_ALL = CORNER_T | CORNER_B,
475 };
476 virtual void DrawRectExt(float x, float y, float w, float h, float r, int Corners) = 0;
477 virtual void DrawRectExt4(float x, float y, float w, float h, ColorRGBA ColorTopLeft, ColorRGBA ColorTopRight, ColorRGBA ColorBottomLeft, ColorRGBA ColorBottomRight, float r, int Corners) = 0;
478 virtual int CreateRectQuadContainer(float x, float y, float w, float h, float r, int Corners) = 0;
479 virtual void DrawRect(float x, float y, float w, float h, ColorRGBA Color, int Corners, float Rounding) = 0;
480 virtual void DrawRect4(float x, float y, float w, float h, ColorRGBA ColorTopLeft, ColorRGBA ColorTopRight, ColorRGBA ColorBottomLeft, ColorRGBA ColorBottomRight, int Corners, float Rounding) = 0;
481 virtual void DrawCircle(float CenterX, float CenterY, float Radius, int Segments) = 0;
482
483 struct CColorVertex
484 {
485 int m_Index;
486 float m_R, m_G, m_B, m_A;
487 CColorVertex() = default;
488 CColorVertex(int i, float r, float g, float b, float a) :
489 m_Index(i), m_R(r), m_G(g), m_B(b), m_A(a) {}
490 CColorVertex(int i, ColorRGBA Color) :
491 m_Index(i), m_R(Color.r), m_G(Color.g), m_B(Color.b), m_A(Color.a) {}
492 };
493 virtual void SetColorVertex(const CColorVertex *pArray, size_t Num) = 0;
494 virtual void SetColor(float r, float g, float b, float a) = 0;
495 virtual void SetColor(ColorRGBA Color) = 0;
496 virtual void SetColor4(ColorRGBA TopLeft, ColorRGBA TopRight, ColorRGBA BottomLeft, ColorRGBA BottomRight) = 0;
497 virtual void ChangeColorOfCurrentQuadVertices(float r, float g, float b, float a) = 0;
498 virtual void ChangeColorOfQuadVertices(size_t QuadOffset, unsigned char r, unsigned char g, unsigned char b, unsigned char a) = 0;
499
500 /**
501 * Reads the color at the specified position from the backbuffer once,
502 * after the next swap operation.
503 *
504 * @param Position The pixel position to read.
505 * @param pColor Pointer that will receive the read pixel color.
506 * The pointer must be valid until the next swap operation.
507 */
508 virtual void ReadPixel(ivec2 Position, ColorRGBA *pColor) = 0;
509 virtual void TakeScreenshot(const char *pFilename) = 0;
510 virtual void TakeCustomScreenshot(const char *pFilename) = 0;
511 virtual int GetVideoModes(CVideoMode *pModes, int MaxModes, int Screen) = 0;
512 virtual void GetCurrentVideoMode(CVideoMode &CurMode, int Screen) = 0;
513 virtual void Swap() = 0;
514 virtual int GetNumScreens() const = 0;
515 virtual const char *GetScreenName(int Screen) const = 0;
516
517 // synchronization
518 virtual void InsertSignal(class CSemaphore *pSemaphore) = 0;
519 virtual bool IsIdle() const = 0;
520 virtual void WaitForIdle() = 0;
521
522 virtual void SetWindowGrab(bool Grab) = 0;
523 virtual void NotifyWindow() = 0;
524
525 // be aware that this function should only be called from the graphics thread, and even then you should really know what you are doing
526 // this function always returns the pixels in RGB
527 virtual TGLBackendReadPresentedImageData &GetReadPresentedImageDataFuncUnsafe() = 0;
528
529 virtual std::optional<SWarning> CurrentWarning() = 0;
530
531 /**
532 * Type of a message box popup.
533 *
534 * @see CMessageBox
535 */
536 enum class EMessageBoxType
537 {
538 ERROR,
539 WARNING,
540 INFO,
541 };
542 /**
543 * Description of a message box popup button.
544 *
545 * @see CMessageBox
546 */
547 class CMessageBoxButton
548 {
549 public:
550 /**
551 * The label of this button.
552 *
553 * @remark This needs to be short because some systems do not increase the button sizes.
554 */
555 const char *m_pLabel = nullptr;
556 /**
557 * Whether the enter key activates this button.
558 */
559 bool m_Confirm = false;
560 /**
561 * Whether the escape key activates this button.
562 *
563 * @remark Closing the popup with the window manager will also cause this button to be activated.
564 */
565 bool m_Cancel = false;
566 };
567 /**
568 * Description of a message box popup.
569 *
570 * @see ShowMessageBox
571 */
572 class CMessageBox
573 {
574 public:
575 /**
576 * Title of the message box.
577 */
578 const char *m_pTitle = nullptr;
579 /**
580 * Main message of the message box.
581 */
582 const char *m_pMessage = nullptr;
583 /**
584 * Type of the message box.
585 */
586 EMessageBoxType m_Type = EMessageBoxType::ERROR;
587 /**
588 * Buttons shown in the message box. At least one button is required.
589 * The buttons are laid out from left to right.
590 */
591 std::vector<CMessageBoxButton> m_vButtons = {{.m_pLabel = "OK", .m_Confirm = true, .m_Cancel = true}};
592 };
593 /**
594 * Shows a modal message box with configuration title, message and buttons.
595 *
596 * @param MessageBox Description of the message box.
597 *
598 * @return Optional containing the index of the pressed button if the popup was shown successfully.
599 * @return Empty optional if the message box was not shown successfully.
600 *
601 * @remark Note that calling this function will destroy the current window,
602 * so it only makes sense for fatal errors at the moment.
603 */
604 virtual std::optional<int> ShowMessageBox(const CMessageBox &MessageBox) = 0;
605
606 virtual bool IsBackendInitialized() = 0;
607
608protected:
609 CTextureHandle CreateTextureHandle(int Index)
610 {
611 CTextureHandle Tex;
612 Tex.m_Id = Index;
613 return Tex;
614 }
615};
616
617class IEngineGraphics : public IGraphics
618{
619 MACRO_INTERFACE("enginegraphics")
620public:
621 virtual int Init() = 0;
622 void Shutdown() override = 0;
623
624 virtual void Minimize() = 0;
625
626 virtual int WindowActive() = 0;
627 virtual int WindowOpen() = 0;
628};
629
630extern IEngineGraphics *CreateEngineGraphicsThreaded();
631
632/**
633 * This function should only be used when the graphics are not initialized or when @link IGraphics::ShowMessageBox @endlink failed.
634 *
635 * @see IGraphics::ShowMessageBox
636 */
637extern std::optional<int> ShowMessageBoxWithoutGraphics(const IGraphics::CMessageBox &MessageBox);
638
639#endif
640