graphics.h

Go to the documentation of this file.

/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com.                */
#ifndef ENGINE_GRAPHICS_H
#define ENGINE_GRAPHICS_H
 
#include "image.h"
#include "kernel.h"
#include "warning.h"
 
#include <base/color.h>
#include <base/vmath.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <vector>
 
#define GRAPHICS_TYPE_UNSIGNED_BYTE 0x1401
#define GRAPHICS_TYPE_UNSIGNED_SHORT 0x1403
#define GRAPHICS_TYPE_INT 0x1404
#define GRAPHICS_TYPE_UNSIGNED_INT 0x1405
#define GRAPHICS_TYPE_FLOAT 0x1406
 
struct SBufferContainerInfo
{
    int m_Stride;
    int m_VertBufferBindingIndex;
 
    // the attributes of the container
    struct SAttribute
    {
        int m_DataTypeCount;
        unsigned int m_Type;
        bool m_Normalized;
        void *m_pOffset;
 
        //0: float, 1:integer
        unsigned int m_FuncType;
    };
    std::vector<SAttribute> m_vAttributes;
};
 
struct SQuadRenderInfo
{
    ColorRGBA m_Color;
    vec2 m_Offsets;
    float m_Rotation;
    // allows easier upload for uniform buffers because of the alignment requirements
    float m_Padding;
};
 
class CGraphicTile
{
public:
    vec2 m_TopLeft;
    vec2 m_TopRight;
    vec2 m_BottomRight;
    vec2 m_BottomLeft;
};
 
class CGraphicTileTextureCoords
{
public:
    ubvec4 m_TexCoordTopLeft;
    ubvec4 m_TexCoordTopRight;
    ubvec4 m_TexCoordBottomRight;
    ubvec4 m_TexCoordBottomLeft;
};
 
/*
    Structure: CVideoMode
*/
class CVideoMode
{
public:
    int m_CanvasWidth, m_CanvasHeight;
    int m_WindowWidth, m_WindowHeight;
    int m_RefreshRate;
};
 
typedef vec2 GL_SPoint;
typedef vec2 GL_STexCoord;
 
struct GL_STexCoord3D
{
    GL_STexCoord3D &operator=(const GL_STexCoord &TexCoord)
    {
        u = TexCoord.u;
        v = TexCoord.v;
        return *this;
    }
 
    GL_STexCoord3D &operator=(const vec3 &TexCoord)
    {
        u = TexCoord.u;
        v = TexCoord.v;
        w = TexCoord.w;
        return *this;
    }
 
    float u, v, w;
};
 
typedef ColorRGBA GL_SColorf;
//use normalized color values
typedef vector4_base<unsigned char> GL_SColor;
 
struct GL_SVertex
{
    GL_SPoint m_Pos;
    GL_STexCoord m_Tex;
    GL_SColor m_Color;
};
 
struct GL_SVertexTex3D
{
    GL_SPoint m_Pos;
    GL_SColorf m_Color;
    GL_STexCoord3D m_Tex;
};
 
struct GL_SVertexTex3DStream
{
    GL_SPoint m_Pos;
    GL_SColor m_Color;
    GL_STexCoord3D m_Tex;
};
 
static constexpr size_t GRAPHICS_MAX_QUADS_RENDER_COUNT = 256;
static constexpr size_t GRAPHICS_MAX_PARTICLES_RENDER_COUNT = 512;
 
enum EGraphicsDriverAgeType
{
    GRAPHICS_DRIVER_AGE_TYPE_LEGACY = 0,
    GRAPHICS_DRIVER_AGE_TYPE_DEFAULT,
    GRAPHICS_DRIVER_AGE_TYPE_MODERN,
 
    GRAPHICS_DRIVER_AGE_TYPE_COUNT,
};
 
enum EBackendType
{
    BACKEND_TYPE_OPENGL = 0,
    BACKEND_TYPE_OPENGL_ES,
    BACKEND_TYPE_VULKAN,
 
    // special value to tell the backend to identify the current backend
    BACKEND_TYPE_AUTO,
 
    BACKEND_TYPE_COUNT,
};
 
struct STWGraphicGpu
{
    enum ETWGraphicsGpuType
    {
        GRAPHICS_GPU_TYPE_DISCRETE = 0,
        GRAPHICS_GPU_TYPE_INTEGRATED,
        GRAPHICS_GPU_TYPE_VIRTUAL,
        GRAPHICS_GPU_TYPE_CPU,
 
        // should stay at last position in this enum
        GRAPHICS_GPU_TYPE_INVALID,
    };
 
    struct STWGraphicGpuItem
    {
        char m_aName[256];
        ETWGraphicsGpuType m_GpuType;
    };
    std::vector<STWGraphicGpuItem> m_vGpus;
    STWGraphicGpuItem m_AutoGpu;
};
 
typedef STWGraphicGpu TTwGraphicsGpuList;
 
typedef std::function<void()> WINDOW_RESIZE_FUNC;
typedef std::function<void()> WINDOW_PROPS_CHANGED_FUNC;
 
typedef std::function<bool(uint32_t &Width, uint32_t &Height, CImageInfo::EImageFormat &Format, std::vector<uint8_t> &vDstData)> TGLBackendReadPresentedImageData;
 
struct CDataSprite;
 
class CScreenRect
{
public:
    CScreenRect(float Left, float Top, float Width, float Height) :
        m_TopLeft(Left, Top), m_BottomRight(Left + Width, Top + Height) {}
 
    CScreenRect(const vec2 &TopLeft, const vec2 &BottomRight) :
        m_TopLeft(TopLeft), m_BottomRight(BottomRight) {}
 
    CScreenRect Move(const vec2 &Position) const
    {
        CScreenRect Rect(*this);
        Rect.m_TopLeft += Position;
        Rect.m_BottomRight += Position;
        return Rect;
    }
 
    constexpr vec2 Size() const
    {
        return m_BottomRight - m_TopLeft;
    }
 
    constexpr float Width() const
    {
        return m_BottomRight.x - m_TopLeft.x;
    }
 
    constexpr float Height() const
    {
        return m_BottomRight.y - m_TopLeft.y;
    }
 
    constexpr bool Inside(const vec2 &Position) const
    {
        return !(!in_range(Position.x, m_TopLeft.x, m_BottomRight.x) || !in_range(Position.y, m_TopLeft.y, m_BottomRight.y));
    }
 
    void Expand(float Width, float Height)
    {
        m_TopLeft.x -= Width;
        m_BottomRight.x += Width;
        m_TopLeft.y -= Height;
        m_BottomRight.y += Height;
    }
 
    void Expand(float Size)
    {
        Expand(Size, Size);
    }
 
    vec2 m_TopLeft;
    vec2 m_BottomRight;
};
 
class IGraphics : public IInterface
{
    MACRO_INTERFACE("graphics")
protected:
    int m_ScreenWidth;
    int m_ScreenHeight;
    int m_ViewportX = 0;
    int m_DrawableWidth;
    int m_DrawableHeight;
    int m_ScreenRefreshRate;
    float m_ScreenHiDPIScale;
    ivec2 m_DesktopSize;
 
public:
    enum
    {
        TEXLOAD_TO_3D_TEXTURE = 1 << 0,
        TEXLOAD_TO_2D_ARRAY_TEXTURE = 1 << 1,
        TEXLOAD_NO_2D_TEXTURE = 1 << 2,
    };
 
    class CTextureHandle
    {
        friend class IGraphics;
        int m_Id;
 
    public:
        CTextureHandle() :
            m_Id(-1)
        {
        }
 
        bool IsValid() const { return Id() >= 0; }
        bool IsNullTexture() const { return Id() == 0; }
        int Id() const { return m_Id; }
        void Invalidate() { m_Id = -1; }
    };
 
    int ScreenWidth() const { return m_ScreenWidth; }
    int ScreenHeight() const { return m_ScreenHeight; }
    vec2 ScreenSize() const { return vec2(m_ScreenWidth, m_ScreenHeight); }
    float ScreenAspect() const { return (float)ScreenWidth() / (float)ScreenHeight(); }
    float ScreenHiDPIScale() const { return m_ScreenHiDPIScale; }
    int WindowWidth() const { return m_ScreenWidth / m_ScreenHiDPIScale; }
    int WindowHeight() const { return m_ScreenHeight / m_ScreenHiDPIScale; }
 
    // Size of the whole drawable area, in the same units as ScreenWidth()/ScreenHeight().
    // The rendered image is clamped to an aspect ratio of at most 5:4 and excludes the
    // area covered by the cutout of the display, so it can be smaller than that area.
    // The rest of the drawable area is not rendered to.
    vec2 DrawableSize() const { return vec2(m_DrawableWidth, m_DrawableHeight); }
 
    // Distance of the rendered image from the left edge of the drawable area, in the
    // same units as ScreenWidth(). The image is always aligned to the top edge.
    int ViewportX() const { return m_ViewportX; }
 
    virtual void WarnPngliteIncompatibleImages(bool Warn) = 0;
    virtual void SetWindowParams(int FullscreenMode, bool IsBorderless) = 0;
    virtual bool SetWindowScreen(int Index, bool MoveToCenter) = 0;
    virtual bool SwitchWindowScreen(int Index, bool MoveToCenter) = 0;
    virtual bool SetVSync(bool State) = 0;
    virtual bool SetMultiSampling(uint32_t ReqMultiSamplingCount, uint32_t &MultiSamplingCountBackend) = 0;
    virtual int GetWindowScreen() = 0;
    virtual void Move(int x, int y) = 0;
    virtual bool Resize(int w, int h, int RefreshRate) = 0;
    virtual void ResizeToScreen() = 0;
    virtual void GotResized(int w, int h, int RefreshRate) = 0;
    virtual void UpdateViewport(int X, int Y, int W, int H, bool ByResize) = 0;
    virtual bool IsScreenKeyboardShown() = 0;

    virtual void AddWindowResizeListener(WINDOW_RESIZE_FUNC pFunc) = 0;
    virtual void AddWindowPropChangeListener(WINDOW_PROPS_CHANGED_FUNC pFunc) = 0;
 
    virtual void WindowDestroyNtf(uint32_t WindowId) = 0;
    virtual void WindowCreateNtf(uint32_t WindowId) = 0;
 
    // ForceClearNow forces the backend to trigger a clear, even at performance cost, else it might be delayed by one frame
    virtual void Clear(float r, float g, float b, bool ForceClearNow = false) = 0;
 
    virtual void ClipEnable(int x, int y, int w, int h) = 0;
    virtual void ClipDisable() = 0;
 
    virtual void MapScreen(const CScreenRect &ScreenRect) = 0;
 
    // helper functions
    void CalcScreenParams(float Aspect, float Zoom, float *pWidth, float *pHeight) const;
    CScreenRect MapScreenToWorld(float CenterX, float CenterY, float ParallaxX, float ParallaxY,
        float ParallaxZoom, float OffsetX, float OffsetY, float Aspect, float Zoom) const;
    void MapScreenToInterface(float CenterX, float CenterY, float Zoom = 1.0f);
    void MapScreenToSize(float Width, float Height);
 
    virtual CScreenRect GetScreen() const = 0;
 
    // TODO: These should perhaps not be virtuals
    virtual void BlendNone() = 0;
    virtual void BlendNormal() = 0;
    virtual void BlendAdditive() = 0;
    virtual void WrapNormal() = 0;
    virtual void WrapClamp() = 0;
 
    virtual uint64_t TextureMemoryUsage() const = 0;
    virtual uint64_t BufferMemoryUsage() const = 0;
    virtual uint64_t StreamedMemoryUsage() const = 0;
    virtual uint64_t StagingMemoryUsage() const = 0;
 
    virtual const TTwGraphicsGpuList &GetGpus() const = 0;
 
    virtual bool LoadPng(CImageInfo &Image, const char *pFilename, int StorageType) = 0;
    virtual bool LoadPng(CImageInfo &Image, const uint8_t *pData, size_t DataSize, const char *pContextName) = 0;
 
    virtual bool CheckImageDivisibility(const char *pContextName, CImageInfo &Image, int DivX, int DivY, bool AllowResize) = 0;
    virtual bool IsImageFormatRgba(const char *pContextName, const CImageInfo &Image) = 0;
 
    virtual void UnloadTexture(CTextureHandle *pIndex) = 0;
    virtual CTextureHandle LoadTextureRaw(const CImageInfo &Image, int Flags, const char *pTexName = nullptr) = 0;
    virtual CTextureHandle LoadTextureRawMove(CImageInfo &Image, int Flags, const char *pTexName = nullptr) = 0;
    virtual CTextureHandle LoadTexture(const char *pFilename, int StorageType, int Flags = 0) = 0;
    virtual void TextureSet(CTextureHandle Texture) = 0;
    void TextureClear() { TextureSet(CTextureHandle()); }
 
    // pTextData & pTextOutlineData are automatically free'd
    virtual bool LoadTextTextures(size_t Width, size_t Height, CTextureHandle &TextTexture, CTextureHandle &TextOutlineTexture, uint8_t *pTextData, uint8_t *pTextOutlineData) = 0;
    virtual bool UnloadTextTextures(CTextureHandle &TextTexture, CTextureHandle &TextOutlineTexture) = 0;
    virtual bool UpdateTextTexture(CTextureHandle TextureId, int x, int y, size_t Width, size_t Height, uint8_t *pData, bool IsMovedPointer) = 0;
 
    virtual CTextureHandle LoadSpriteTexture(const CImageInfo &FromImageInfo, const std::optional<CImageInfo> &FallbackImageInfo, const struct CDataSprite *pSprite) = 0;
 
    virtual bool IsImageSubFullyTransparent(const CImageInfo &FromImageInfo, int x, int y, int w, int h) = 0;
    virtual bool IsSpriteTextureFullyTransparent(const CImageInfo &FromImageInfo, const struct CDataSprite *pSprite) = 0;
 
    virtual void FlushVertices(bool KeepVertices = false) = 0;
    virtual void FlushVerticesTex3D() = 0;
 
    // specific render functions
    virtual void RenderTileLayer(int BufferContainerIndex, const ColorRGBA &Color, char **pOffsets, unsigned int *pIndicedVertexDrawNum, size_t NumIndicesOffset) = 0;
    virtual void RenderBorderTiles(int BufferContainerIndex, const ColorRGBA &Color, char *pIndexBufferOffset, const vec2 &Offset, const vec2 &Scale, uint32_t DrawNum) = 0;
    virtual void RenderQuadLayer(int BufferContainerIndex, SQuadRenderInfo *pQuadInfo, size_t QuadNum, int QuadOffset, bool Grouped = false) = 0;
    virtual void RenderText(int BufferContainerIndex, int TextQuadNum, int TextureSize, int TextureTextIndex, int TextureTextOutlineIndex, const ColorRGBA &TextColor, const ColorRGBA &TextOutlineColor) = 0;
 
    // opengl 3.3 functions
 
    enum EBufferObjectCreateFlags
    {
        // 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
        BUFFER_OBJECT_CREATE_FLAGS_ONE_TIME_USE_BIT = 1 << 0,
    };
 
    // if a pointer is passed as moved pointer, it requires to be allocated with malloc()
    virtual int CreateBufferObject(size_t UploadDataSize, void *pUploadData, int CreateFlags, bool IsMovedPointer = false) = 0;
    virtual void RecreateBufferObject(int BufferIndex, size_t UploadDataSize, void *pUploadData, int CreateFlags, bool IsMovedPointer = false) = 0;
    virtual void DeleteBufferObject(int BufferIndex) = 0;
 
    virtual int CreateBufferContainer(struct SBufferContainerInfo *pContainerInfo) = 0;
    // destroying all buffer objects means, that all referenced VBOs are destroyed automatically, so the user does not need to save references to them
    virtual void DeleteBufferContainer(int &ContainerIndex, bool DestroyAllBO = true) = 0;
    virtual void IndicesNumRequiredNotify(unsigned int RequiredIndicesCount) = 0;
 
    // returns true if the driver age type is supported, passing BACKEND_TYPE_AUTO for BackendType will query the values for the currently used backend
    virtual bool GetDriverVersion(EGraphicsDriverAgeType DriverAgeType, int &Major, int &Minor, int &Patch, const char *&pName, EBackendType BackendType) = 0;
    virtual bool IsConfigModernAPI() = 0;
    virtual bool IsTileBufferingEnabled() = 0;
    virtual bool IsQuadBufferingEnabled() = 0;
    virtual bool IsTextBufferingEnabled() = 0;
    virtual bool IsQuadContainerBufferingEnabled() = 0;
    virtual bool Uses2DTextureArrays() = 0;
    virtual int TextureLoadFlags() = 0;
    virtual bool HasTextureArraysSupport() = 0;
 
    virtual const char *GetVendorString() = 0;
    virtual const char *GetVersionString() = 0;
    virtual const char *GetRendererString() = 0;
    virtual const char *GetFatalError() const = 0;
 
    class CLineItem
    {
    public:
        float m_X0, m_Y0, m_X1, m_Y1;
        CLineItem() = default;
        CLineItem(float x0, float y0, float x1, float y1) :
            m_X0(x0), m_Y0(y0), m_X1(x1), m_Y1(y1) {}
        CLineItem(vec2 From, vec2 To)
        {
            m_X0 = From.x;
            m_Y0 = From.y;
            m_X1 = To.x;
            m_Y1 = To.y;
        }
    };
    virtual void LinesBegin() = 0;
    virtual void LinesEnd() = 0;
    virtual void LinesDraw(const CLineItem *pArray, size_t Num) = 0;
 
    class CLineItemBatch
    {
    public:
        IGraphics::CLineItem m_aItems[256];
        size_t m_NumItems = 0;
    };
    virtual void LinesBatchBegin(CLineItemBatch *pBatch) = 0;
    virtual void LinesBatchEnd(CLineItemBatch *pBatch) = 0;
    virtual void LinesBatchDraw(CLineItemBatch *pBatch, const CLineItem *pArray, size_t Num) = 0;
 
    virtual void QuadsBegin() = 0;
    virtual void QuadsEnd() = 0;
    virtual void QuadsTex3DBegin() = 0;
    virtual void QuadsTex3DEnd() = 0;
    virtual void TrianglesBegin() = 0;
    virtual void TrianglesEnd() = 0;
    virtual void QuadsEndKeepVertices() = 0;
    virtual void QuadsDrawCurrentVertices(bool KeepVertices = true) = 0;
    virtual void QuadsSetRotation(float Angle) = 0;
    virtual void QuadsSetSubset(float TopLeftU, float TopLeftV, float BottomRightU, float BottomRightV) = 0;
    virtual void QuadsSetSubsetFree(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, int Index = -1) = 0;
 
    struct CFreeformItem
    {
        float m_X0, m_Y0, m_X1, m_Y1, m_X2, m_Y2, m_X3, m_Y3;
        CFreeformItem() = default;
        CFreeformItem(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3) :
            m_X0(x0), m_Y0(y0), m_X1(x1), m_Y1(y1), m_X2(x2), m_Y2(y2), m_X3(x3), m_Y3(y3) {}
        CFreeformItem(vec2 Point1, vec2 Point2, vec2 Point3, vec2 Point4) :
            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) {}
    };
 
    struct CQuadItem
    {
        float m_X, m_Y, m_Width, m_Height;
        CQuadItem() = default;
        CQuadItem(float x, float y, float w, float h) :
            m_X(x), m_Y(y), m_Width(w), m_Height(h) {}
        CQuadItem(vec2 Position, vec2 Size) :
            m_X(Position.x), m_Y(Position.y), m_Width(Size.x), m_Height(Size.y) {}
    };
    virtual void QuadsDraw(CQuadItem *pArray, int Num) = 0;
    virtual void QuadsDrawTL(const CQuadItem *pArray, int Num) = 0;
 
    virtual void QuadsTex3DDrawTL(const CQuadItem *pArray, int Num) = 0;
 
    virtual int CreateQuadContainer(bool AutomaticUpload = true) = 0;
    virtual void QuadContainerChangeAutomaticUpload(int ContainerIndex, bool AutomaticUpload) = 0;
    virtual void QuadContainerUpload(int ContainerIndex) = 0;
    virtual int QuadContainerAddQuads(int ContainerIndex, CQuadItem *pArray, int Num) = 0;
    virtual int QuadContainerAddQuads(int ContainerIndex, CFreeformItem *pArray, int Num) = 0;
    virtual void QuadContainerReset(int ContainerIndex) = 0;
    virtual void DeleteQuadContainer(int &ContainerIndex) = 0;
    virtual void RenderQuadContainer(int ContainerIndex, int QuadDrawNum) = 0;
    virtual void RenderQuadContainer(int ContainerIndex, int QuadOffset, int QuadDrawNum, bool ChangeWrapMode = true) = 0;
    virtual void RenderQuadContainerEx(int ContainerIndex, int QuadOffset, int QuadDrawNum, float X, float Y, float ScaleX = 1.f, float ScaleY = 1.f) = 0;
    virtual void RenderQuadContainerAsSprite(int ContainerIndex, int QuadOffset, float X, float Y, float ScaleX = 1.f, float ScaleY = 1.f) = 0;
 
    struct SRenderSpriteInfo
    {
        vec2 m_Pos;
        float m_Scale;
        float m_Rotation;
    };
 
    virtual void RenderQuadContainerAsSpriteMultiple(int ContainerIndex, int QuadOffset, int DrawCount, SRenderSpriteInfo *pRenderInfo) = 0;
 
    virtual void QuadsDrawFreeform(const CFreeformItem *pArray, int Num) = 0;
    virtual void QuadsText(float x, float y, float Size, const char *pText) = 0;
 
    // sprites
    enum
    {
        SPRITE_FLAG_FLIP_Y = 1,
        SPRITE_FLAG_FLIP_X = 2,
    };
    virtual void SelectSprite(int Id, int Flags = 0) = 0;
    virtual void SelectSprite7(int Id, int Flags = 0) = 0;
 
    virtual void GetSpriteScale(const CDataSprite *pSprite, float &ScaleX, float &ScaleY) const = 0;
    virtual void GetSpriteScale(int Id, float &ScaleX, float &ScaleY) const = 0;
    virtual void GetSpriteScaleImpl(int Width, int Height, float &ScaleX, float &ScaleY) const = 0;
 
    virtual void DrawSprite(float x, float y, float Size) = 0;
    virtual void DrawSprite(float x, float y, float ScaledWidth, float ScaledHeight) = 0;
 
    virtual int QuadContainerAddSprite(int QuadContainerIndex, float x, float y, float Size) = 0;
    virtual int QuadContainerAddSprite(int QuadContainerIndex, float Size) = 0;
    virtual int QuadContainerAddSprite(int QuadContainerIndex, float Width, float Height) = 0;
    virtual int QuadContainerAddSprite(int QuadContainerIndex, float X, float Y, float Width, float Height) = 0;
 
    enum
    {
        CORNER_NONE = 0,
        CORNER_TL = 1,
        CORNER_TR = 2,
        CORNER_BL = 4,
        CORNER_BR = 8,
 
        CORNER_T = CORNER_TL | CORNER_TR,
        CORNER_B = CORNER_BL | CORNER_BR,
        CORNER_R = CORNER_TR | CORNER_BR,
        CORNER_L = CORNER_TL | CORNER_BL,
 
        CORNER_ALL = CORNER_T | CORNER_B,
    };
    virtual void DrawRectExt(float x, float y, float w, float h, float r, int Corners) = 0;
    virtual void DrawRectExt4(float x, float y, float w, float h, ColorRGBA ColorTopLeft, ColorRGBA ColorTopRight, ColorRGBA ColorBottomLeft, ColorRGBA ColorBottomRight, float r, int Corners) = 0;
    virtual int CreateRectQuadContainer(float x, float y, float w, float h, float r, int Corners) = 0;
    virtual void DrawRect(float x, float y, float w, float h, ColorRGBA Color, int Corners, float Rounding) = 0;
    virtual void DrawRect4(float x, float y, float w, float h, ColorRGBA ColorTopLeft, ColorRGBA ColorTopRight, ColorRGBA ColorBottomLeft, ColorRGBA ColorBottomRight, int Corners, float Rounding) = 0;
    virtual void DrawCircle(float CenterX, float CenterY, float Radius, int Segments) = 0;

    virtual void SetColor(float r, float g, float b, float a) = 0;
    virtual void SetColor(ColorRGBA Color) = 0;
    virtual void SetColor2(ColorRGBA First, ColorRGBA Second) = 0;
    virtual void SetColor4(ColorRGBA TopLeft, ColorRGBA TopRight, ColorRGBA BottomLeft, ColorRGBA BottomRight) = 0;
    virtual void ChangeColorOfQuadVertices(size_t QuadOffset, unsigned char r, unsigned char g, unsigned char b, unsigned char a) = 0;

    virtual void ReadPixel(ivec2 Position, ColorRGBA *pColor) = 0;
    virtual void TakeScreenshot(const char *pFilename) = 0;
    virtual void TakeCustomScreenshot(const char *pFilename) = 0;
    virtual int GetVideoModes(CVideoMode *pModes, int MaxModes, int Screen) = 0;
    virtual void GetCurrentVideoMode(CVideoMode &CurMode, int Screen) = 0;
    virtual void Swap() = 0;
    virtual int GetNumScreens() const = 0;
    virtual const char *GetScreenName(int Screen) const = 0;
 
    // synchronization
    virtual void InsertSignal(class CSemaphore *pSemaphore) = 0;
    virtual bool IsIdle() const = 0;
    virtual void WaitForIdle() = 0;
 
    virtual void SetWindowGrab(bool Grab) = 0;
    virtual void NotifyWindow() = 0;
 
    // be aware that this function should only be called from the graphics thread, and even then you should really know what you are doing
    // this function always returns the pixels in RGB
    virtual TGLBackendReadPresentedImageData &GetReadPresentedImageDataFuncUnsafe() = 0;
 
    virtual std::optional<SWarning> CurrentWarning() = 0;

    enum class EMessageBoxType
    {
        ERROR,
        WARNING,
        INFO,
    };

    class CMessageBoxButton
    {
    public:
        const char *m_pLabel = nullptr;
        bool m_Confirm = false;
        bool m_Cancel = false;
    };

    class CMessageBox
    {
    public:
        const char *m_pTitle = nullptr;
        const char *m_pMessage = nullptr;
        EMessageBoxType m_Type = EMessageBoxType::ERROR;
        std::vector<CMessageBoxButton> m_vButtons = {{.m_pLabel = "OK", .m_Confirm = true, .m_Cancel = true}};
    };

    virtual std::optional<int> ShowMessageBox(const CMessageBox &MessageBox) = 0;
 
    virtual bool IsBackendInitialized() = 0;
 
protected:
    CTextureHandle CreateTextureHandle(int Index)
    {
        CTextureHandle Tex;
        Tex.m_Id = Index;
        return Tex;
    }
};
 
class IEngineGraphics : public IGraphics
{
    MACRO_INTERFACE("enginegraphics")
public:
    virtual int Init() = 0;
    void Shutdown() override = 0;
 
    virtual void Minimize() = 0;
 
    virtual int WindowActive() = 0;
    virtual int WindowOpen() = 0;
};
 
extern IEngineGraphics *CreateEngineGraphicsThreaded();

extern std::optional<int> ShowMessageBoxWithoutGraphics(const IGraphics::CMessageBox &MessageBox);
 
#endif