[Feat] (MG_Backend/DirectGLES): tracy integration for DirectGLES backend

2026-09-09 04:38:30 +09:00 · 2025-12-11 20:37:20 +08:00
parent ffd4ec3408
commit 91b04f6995
4 changed files with 208 additions and 5 deletions
@@ -65,6 +65,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace BufferImpl {
        void SyncNeccessaryBuffers(Bool includeIBO = false, Bool includeIndirectBuffer = false) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            // All buffers we need are:
            //   1.VBO 2.IBO (if needed) 3.UBO 4.IndirectBuffer (if needed) 5.SSBO (TODO)
            // PBO is not needed since it should be handled in frontend
@@ -141,6 +144,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace VertexArrayImpl {
        void SyncCurrentVAO(Bool needDivisor) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            auto currentVAOObject = MG_State::pGLContext->GetBoundVertexArray();
            if (!currentVAOObject) {
                MGLOG_E("No VAO is currently bound, cannot sync current VAO.");
@@ -162,6 +168,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
    namespace TextureImpl {
        SharedPtr<BackendTextureObject> SyncTextureObjectToBackend(
            SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            const auto& backendTextureIt = g_backendTextureObjects.find(textureObject);
            SharedPtr<BackendTextureObject> backendTextureObject;
            if (backendTextureIt == g_backendTextureObjects.end()) {
@@ -175,6 +184,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void SyncNeccessaryTextures() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            // All textures we need are:
            //   1. textures bound to texture units (TODO: only sync ones that are used in current program)
            //   2. textures used in current FBO
@@ -219,6 +231,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace FramebufferImpl {
        void SyncCurrentFBO() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            const FramebufferTarget fboTargets[] = {FramebufferTarget::Draw, FramebufferTarget::Read};

            MG_State::GLState::FramebufferObject* lastUpdatedFBO = nullptr;
@@ -260,6 +275,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace RenderStateImpl {
        void SyncRenderState() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glViewport(
                MG_State::pGLContext->GetViewport().x(), MG_State::pGLContext->GetViewport().y(),
                MG_State::pGLContext->GetViewport().z(), MG_State::pGLContext->GetViewport().w());
@@ -320,6 +338,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace PrgramImpl {
        void SyncCurrentProgram() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            auto currentProgram = MG_State::pGLContext->GetCurrentProgram();
            if (!currentProgram || !currentProgram->GetLinkStatus()) {
                MG_External::GLES::glUseProgram(0);
@@ -341,6 +362,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
    } // namespace PrgramImpl

    void BindCurrentFBO(FramebufferTarget target) {
+#ifdef TRACY_ENABLE
+        ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
        const auto& currentFBO = MG_State::pGLContext->GetFramebufferBindingSlot(target).GetBoundObject();
        if (currentFBO && currentFBO != MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo->defaultFBO) {
            const auto& backendFBOIt = FramebufferImpl::g_backendFramebufferObjects.find(currentFBO);
@@ -358,6 +382,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
    }

    void PrepareForDraw(DrawSyncBit syncBit) {
+#ifdef TRACY_ENABLE
+        ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
        BufferImpl::SyncNeccessaryBuffers(syncBit & DrawSyncBit::IndexBuffer, syncBit & DrawSyncBit::IndirectBuffer);
        VertexArrayImpl::SyncCurrentVAO(syncBit & DrawSyncBit::Instancing);
        TextureImpl::SyncNeccessaryTextures();
@@ -18,6 +18,9 @@
 namespace MobileGL::MG_Backend::DirectGLES {
    namespace BufferImpl {
        BackendBufferObject::BackendBufferObject() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGenBuffers(1, &m_backendBufferId);
            if (m_backendBufferId == 0) {
                MGLOG_E("Failed to generate buffer object.");
@@ -29,6 +32,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        const GLenum TempBufferTarget = GL_ARRAY_BUFFER;
        void BackendBufferObject::SyncToBackend(SharedPtr<MG_State::GLState::BufferObject>& stateBufferObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (!stateBufferObject) {
                MGLOG_E("State buffer object is null, cannot sync to backend.");
                return;
@@ -74,6 +80,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        void BackendBufferObject::SyncToBackend_glBufferData(
            SharedPtr<MG_State::GLState::BufferObject>& stateBufferObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            BackendBufferBindingProtector backendBufferBindingProtector(TempBufferTarget);

            MGLOG_D("Syncing buffer data (glBufferData) for object with ID : %u", m_backendBufferId);
@@ -90,6 +99,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        void BackendBufferObject::SyncToBackend_glBufferSubData(
            SharedPtr<MG_State::GLState::BufferObject>& stateBufferObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            BackendBufferBindingProtector backendBufferBindingProtector(TempBufferTarget);

            MGLOG_D("Syncing buffer sub-data (glBufferSubData) for object with ID : %u", m_backendBufferId);
@@ -109,6 +121,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        void BackendBufferObject::SyncToBackend_glMapBufferRange(
            SharedPtr<MG_State::GLState::BufferObject>& stateBufferObject, Bool invalidate) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            BackendBufferBindingProtector backendBufferBindingProtector(TempBufferTarget);

            MGLOG_D("Syncing buffer map (glMapBuffer) for object with ID : %u", m_backendBufferId);
@@ -133,10 +148,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendBufferObject::Bind() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindBuffer(TempBufferTarget, m_backendBufferId);
        }

        void BackendBufferObject::Bind(GLenum target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindBuffer(target, m_backendBufferId);
        }

@@ -145,6 +166,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace VertexArrayImpl {
        BackendVertexArrayObject::BackendVertexArrayObject() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGenVertexArrays(1, &m_backendVAOId);
            if (m_backendVAOId == 0) {
                MGLOG_E("Failed to generate vertex array object.");
@@ -155,11 +179,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendVertexArrayObject::Bind() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindVertexArray(m_backendVAOId);
        }

        void BackendVertexArrayObject::SyncToBackend(SharedPtr<MG_State::GLState::VertexArrayObject>& stateVAOObject,
                                                     Bool needDivisor) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (!stateVAOObject) {
                MGLOG_E("State VAO object is null, cannot sync to backend.");
                return;
@@ -233,6 +263,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace TextureImpl {
        BackendTextureObject::BackendTextureObject() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGenTextures(1, &m_backendTextureId);
            if (m_backendTextureId == 0) {
                MGLOG_E("Failed to generate texture object.");
@@ -243,14 +276,23 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendTextureObject::Bind(GLenum target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindTexture(target, m_backendTextureId);
        }

        Uint BackendTextureObject::GetBackendTextureId() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            return m_backendTextureId;
        }

        void BackendTextureObject::SyncToBackend(SharedPtr<MG_State::GLState::ITextureObject>& stateTextureObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            DebugImpl::ErrorLopper errorLopper;
            if (!stateTextureObject) {
                MGLOG_E("State texture object is null, cannot sync to backend.");
@@ -329,8 +371,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                MGLOG_D("%s: target: %s: syncing mip %d: %dx%dx%d, byteSize = %d, pData = %p", __func__,
                                        MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str(), level,
                                        levelTexelSize.x(), levelTexelSize.y(), levelTexelSize.z(), levelByteSize, pData);
-                                BufferImpl::BackendBufferBindingProtector pixelUnpackProtector =
-                                    BufferImpl::BackendBufferBindingProtector(GL_PIXEL_UNPACK_BUFFER);
+
                                errorLopper.Clear();
                                MG_External::GLES::glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
                                MG_External::GLES::glTexImage2D(glUploadTarget, static_cast<GLint>(level), glInternalFormat,
@@ -367,9 +408,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                }

                                auto glUploadTarget = MG_Util::ConvertTextureUploadTargetToGLEnum(uploadTarget);
-
-                                BufferImpl::BackendBufferBindingProtector pixelUnpackProtector =
-                                    BufferImpl::BackendBufferBindingProtector(GL_PIXEL_UNPACK_BUFFER);
                                MG_External::GLES::glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
                                errorLopper.Loop([file = __FILE__, line = __LINE__, func = __func__](GLenum err) {
                                    MGLOG_D("%s(%s:%d) ES error: %s", func, file, line,
@@ -541,6 +579,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace FramebufferImpl {
        BackendFramebufferObject::BackendFramebufferObject() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGenFramebuffers(1, &m_backendFBOId);
            if (m_backendFBOId == 0) {
                MGLOG_E("Failed to generate framebuffer object.");
@@ -551,6 +592,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendFramebufferObject::Bind(FramebufferTarget target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (target == FramebufferTarget::Read)
                MG_External::GLES::glBindFramebuffer(GL_READ_FRAMEBUFFER, m_backendFBOId);
            else
@@ -559,6 +603,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        void BackendFramebufferObject::SyncToBackend(SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject,
                                                     FramebufferTarget asTarget) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (!stateFBOObject) {
                MGLOG_E("State FBO object is null, cannot sync to backend.");
                return;
@@ -664,6 +711,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
            g_backendProgramObjects;

        BackendProgramObjectImpl::BackendProgramObjectImpl() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            m_backendProgramId = MG_External::GLES::glCreateProgram();
            if (m_backendProgramId == 0) {
                MGLOG_E("Failed to create program object in backend.");
@@ -675,6 +725,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        BackendProgramObjectImpl::~BackendProgramObjectImpl() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (m_backendProgramId != 0) {
                MGLOG_D("Deleting backend program object with ID: %u", m_backendProgramId);
                MG_External::GLES::glDeleteProgram(m_backendProgramId);
@@ -682,6 +735,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendProgramObjectImpl::SyncToBackend(SharedPtr<MG_State::GLState::ProgramObject>& stateProgramObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (!stateProgramObject) {
                MGLOG_E("State program object is null, skipping backend sync.");
                return;
@@ -822,6 +878,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendProgramObjectImpl::Use() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MGLOG_D("Using program %u", m_backendProgramId);
            MG_External::GLES::glUseProgram(m_backendProgramId);
        }
@@ -829,6 +888,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace SamplerImpl {
        BackendSamplerObject::BackendSamplerObject() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGenSamplers(1, &m_backendSamplerId);
            if (m_backendSamplerId == 0) {
                MGLOG_E("Failed to generate sampler object.");
@@ -839,6 +901,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendSamplerObject::SyncToBackend(SharedPtr<MG_State::GLState::SamplerObject>& stateSamplerObject) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            if (!stateSamplerObject) {
                MGLOG_E("State sampler object is null, cannot sync to backend.");
                return;
@@ -889,10 +954,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendSamplerObject::Bind(Uint unit) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindSampler(static_cast<GLenum>(unit), m_backendSamplerId);
        }

        Uint BackendSamplerObject::GetBackendSamplerId() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            return m_backendSamplerId;
        }

@@ -11,37 +11,58 @@
 namespace MobileGL::MG_Backend::DirectGLES {
    namespace BufferImpl {
        BackendBufferBindingProtector::BackendBufferBindingProtector(GLenum target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            m_target = target;
            MG_External::GLES::glGetIntegerv(Utils::GetBindingQuery(target, false), &m_previousBinding);
        }

        BackendBufferBindingProtector::~BackendBufferBindingProtector() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindBuffer(m_target, m_previousBinding);
        }
    } // namespace BufferImpl

    namespace VertexArrayImpl {
        BackendVertexArrayBindingProtector::BackendVertexArrayBindingProtector() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &m_previousBinding);
        }

        BackendVertexArrayBindingProtector::~BackendVertexArrayBindingProtector() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindVertexArray(m_previousBinding);
        }
    } // namespace VertexArrayImpl

    namespace TextureImpl {
        BackendTextureBindingProtector::BackendTextureBindingProtector(GLenum target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            m_target = target;
            MG_External::GLES::glGetIntegerv(Utils::GetBindingQuery(target, true), &m_previousBinding);
        }

        BackendTextureBindingProtector::~BackendTextureBindingProtector() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindTexture(m_target, m_previousBinding);
        }

        void NormalizePixelFormat(GLenum internalFormat, GLenum* outInternalFormat, GLenum* outType,
                                  GLenum* outFormat) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            switch (internalFormat) {
            case GL_DEPTH_COMPONENT16:
                if (outInternalFormat) *outInternalFormat = internalFormat;
@@ -365,6 +386,9 @@ namespace MobileGL::MG_Backend::DirectGLES {

        void GenerateTextureFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat, GLenum* outType,
                                       GLenum* outFormat) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            NormalizePixelFormat(MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat), outInternalFormat,
                                 outType, outFormat);
        }
@@ -372,15 +396,24 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace FramebufferImpl {
        BackendFramebufferBindingProtector::BackendFramebufferBindingProtector(GLenum target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            m_target = target;
            MG_External::GLES::glGetIntegerv(Utils::GetBindingQuery(target, false), &m_previousBinding);
        }

        BackendFramebufferBindingProtector::~BackendFramebufferBindingProtector() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            MG_External::GLES::glBindFramebuffer(m_target, m_previousBinding);
        }

        GLuint BackendFramebufferBindingProtector::GetTempFBO(FramebufferTarget target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            GLenum glTarget = MG_Util::ConvertFramebufferTargetToGLEnum(target);
            GLuint& fbo = (glTarget == GL_DRAW_FRAMEBUFFER) ? s_tempDrawFBO : s_tempReadFBO;
            if (fbo == 0) {
@@ -390,6 +423,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        void BackendFramebufferBindingProtector::BindTempFBO(MobileGL::FramebufferTarget target) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            GLuint fbo = GetTempFBO(target);
            GLenum glTarget = MG_Util::ConvertFramebufferTargetToGLEnum(target);
            MG_External::GLES::glBindFramebuffer(glTarget, fbo);
@@ -398,12 +434,18 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace PrgramImpl {
        String ProcessOutColorLocations(const String& glslCode) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            const static std::regex pattern(R"(\n(out highp vec4 outColor)(\d+);)");
            const String replacement = "\nlayout(location=$2) $1$2;";
            return std::regex_replace(glslCode, pattern, replacement);
        }

        String ForceSupporterOutput(const String& glslCode) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            Bool hasPrecisionFloat =
                glslCode.find("precision ") != String::npos && glslCode.find("float;") != String::npos;
            Bool hasPrecisionInt = glslCode.find("precision ") != String::npos && glslCode.find("int;") != String::npos;
@@ -460,6 +502,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
        }

        String RemoveLayoutBinding(const String& glslCode) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            static std::regex bindingRegex(R"(layout\s*\(\s*binding\s*=\s*\d+\s*\)\s*)");
            String result = std::regex_replace(glslCode, bindingRegex, "");
            static std::regex bindingRegex2(R"(layout\s*\(\s*binding\s*=\s*\d+\s*,)");
@@ -470,12 +515,18 @@ namespace MobileGL::MG_Backend::DirectGLES {

    namespace Utils {
        void CheckGLESError() {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            while (GLenum err = MG_External::GLES::glGetError() != GL_NO_ERROR) {
                MGLOG_E("-> GLES Error: %s", MG_Util::ConvertGLEnumToString(err).c_str());
            }
        }

        GLenum GetBindingQuery(GLenum target, bool isTexture) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
            switch (target) {
            case GL_TEXTURE_BUFFER:
                return isTexture ? GL_TEXTURE_BINDING_BUFFER : GL_TEXTURE_BUFFER_BINDING;
@@ -9,12 +9,18 @@
 namespace MobileGL {
    namespace MG_Impl::GLImpl {
        void Clear_Backend(GLbitfield mask) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::Clear(mask);
 #endif
        }

        void DrawElements_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElements(mode, count, type, indices);
 #endif
@@ -22,6 +28,9 @@ namespace MobileGL {

        void MultiDrawElements_Backend(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices,
                                       GLsizei drawcount) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::MultiDrawElements(mode, count, type, indices, drawcount);
 #endif
@@ -30,12 +39,18 @@ namespace MobileGL {
        void MultiDrawElementsBaseVertex_Backend(GLenum mode, const GLsizei* count, GLenum type,
                                                 const void* const* indices, GLsizei drawcount,
                                                 const GLint* basevertex) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 #endif
        }

        void DrawArrays_Backend(GLenum mode, GLint first, GLsizei count) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawArrays(mode, first, count);
 #endif
@@ -43,6 +58,9 @@ namespace MobileGL {

        void DrawElementsBaseVertex_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                            GLint basevertex) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 #endif
@@ -50,12 +68,18 @@ namespace MobileGL {

        void MultiDrawElementsIndirect_Backend(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount,
                                               GLsizei stride) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 #endif
        }

        void MultiDrawArraysIndirect_Backend(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 #endif
@@ -63,6 +87,9 @@ namespace MobileGL {

        void DrawRangeElementsBaseVertex_Backend(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
                                                 const void* indices, GLint basevertex) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 #endif
@@ -70,6 +97,9 @@ namespace MobileGL {

        void DrawRangeElements_Backend(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
                                       const void* indices) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawRangeElements(mode, start, end, count, type, indices);
 #endif
@@ -78,6 +108,9 @@ namespace MobileGL {
        void DrawElementsInstancedBaseVertexBaseInstance_Backend(GLenum mode, GLsizei count, GLenum type,
                                                                 const void* indices, GLsizei instancecount,
                                                                 GLint basevertex, GLuint baseinstance) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsInstancedBaseVertexBaseInstance(
                mode, count, type, indices, instancecount, basevertex, baseinstance);
@@ -86,6 +119,9 @@ namespace MobileGL {

        void DrawElementsInstancedBaseVertex_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                                     GLsizei instancecount, GLint basevertex) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
                                                                    basevertex);
@@ -94,6 +130,9 @@ namespace MobileGL {

        void DrawElementsInstancedBaseInstance_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                                       GLsizei instancecount, GLuint baseinstance) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount,
                                                                      baseinstance);
@@ -102,30 +141,45 @@ namespace MobileGL {

        void DrawElementsInstanced_Backend(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                           GLsizei instancecount) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsInstanced(mode, count, type, indices, instancecount);
 #endif
        }

        void DrawElementsIndirect_Backend(GLenum mode, GLenum type, const void* indirect) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawElementsIndirect(mode, type, indirect);
 #endif
        }
        void DrawArraysInstancedBaseInstance_Backend(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
                                                     GLuint baseinstance) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 #endif
        }

        void DrawArraysInstanced_Backend(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawArraysInstanced(mode, first, count, instancecount);
 #endif
        }

        void DrawArraysIndirect_Backend(GLenum mode, const void* indirect) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
 #if MOBILEGL_BACKEND == MOBILEGL_BACKEND_TYPE_DIRECT_GLES
            MG_Backend::DirectGLES::DrawArraysIndirect(mode, indirect);
 #endif