Fix indentation

Change-Id: I1046718d54f818f72be63dc2a795703d3f655d22
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>
Reviewed-by: Jari Karppinen <jari.karppinen@qt.io>
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
 

1 files changed, 1848 insertions, 1843 deletions

diff --git a/src/Runtime/ogl-runtime/src/render/backends/gl/Qt3DSRenderBackendGLBase.cpp b/src/Runtime/ogl-runtime/src/render/backends/gl/Qt3DSRenderBackendGLBase.cpp
index 3598aced..0fe6e0f4 100644
--- a/src/Runtime/ogl-runtime/src/render/backends/gl/Qt3DSRenderBackendGLBase.cpp
+++ b/src/Runtime/ogl-runtime/src/render/backends/gl/Qt3DSRenderBackendGLBase.cpp
@@ -58,2167 +58,2172 @@ namespace render {
 #define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB
 #endif
 
-    /// constructor
-    NVRenderBackendGLBase::NVRenderBackendGLBase(NVFoundationBase &fnd,
-                                                 qt3ds::foundation::IStringTable &stringTable,
-                                                 const QSurfaceFormat &format)
-        : mRefCount(0)
-        , m_Foundation(fnd)
-        , m_StringTable(stringTable)
-        , m_Conversion()
-        , m_MaxAttribCount(0)
-        , m_DrawBuffersArray(m_Foundation.getAllocator(),
-                             "NVRenderBackendGLBase::m_DrawBuffersArray")
-        , m_format(format)
-    {
-        m_glFunctions = new QOpenGLFunctions;
-        m_glFunctions->initializeOpenGLFunctions();
-        m_glExtraFunctions = new QOpenGLExtraFunctions;
-        m_glExtraFunctions->initializeOpenGLFunctions();
-
-        // internal state tracker
-        m_pCurrentRasterizerState =
-            QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendRasterizerStateGL)();
-        m_pCurrentDepthStencilState =
-            QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendDepthStencilStateGL)();
-
-        m_glFunctions->glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_maxAnisotropy);
-    }
-    /// destructor
-    NVRenderBackendGLBase::~NVRenderBackendGLBase()
-    {
-        if (m_pCurrentRasterizerState)
-            NVDelete(m_Foundation.getAllocator(), m_pCurrentRasterizerState);
-        if (m_pCurrentDepthStencilState)
-            NVDelete(m_Foundation.getAllocator(), m_pCurrentDepthStencilState);
-        if (m_glFunctions)
-            delete m_glFunctions;
-        if (m_glExtraFunctions)
-            delete m_glExtraFunctions;
-    }
+/// constructor
+NVRenderBackendGLBase::NVRenderBackendGLBase(NVFoundationBase &fnd,
+                                             qt3ds::foundation::IStringTable &stringTable,
+                                             const QSurfaceFormat &format)
+    : mRefCount(0)
+    , m_Foundation(fnd)
+    , m_StringTable(stringTable)
+    , m_Conversion()
+    , m_MaxAttribCount(0)
+    , m_DrawBuffersArray(m_Foundation.getAllocator(),
+                         "NVRenderBackendGLBase::m_DrawBuffersArray")
+    , m_format(format)
+{
+    m_glFunctions = new QOpenGLFunctions;
+    m_glFunctions->initializeOpenGLFunctions();
+    m_glExtraFunctions = new QOpenGLExtraFunctions;
+    m_glExtraFunctions->initializeOpenGLFunctions();
+
+    // internal state tracker
+    m_pCurrentRasterizerState =
+        QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendRasterizerStateGL)();
+    m_pCurrentDepthStencilState =
+        QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendDepthStencilStateGL)();
+
+    m_glFunctions->glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_maxAnisotropy);
+}
+/// destructor
+NVRenderBackendGLBase::~NVRenderBackendGLBase()
+{
+    if (m_pCurrentRasterizerState)
+        NVDelete(m_Foundation.getAllocator(), m_pCurrentRasterizerState);
+    if (m_pCurrentDepthStencilState)
+        NVDelete(m_Foundation.getAllocator(), m_pCurrentDepthStencilState);
+    if (m_glFunctions)
+        delete m_glFunctions;
+    if (m_glExtraFunctions)
+        delete m_glExtraFunctions;
+}
 
-    NVRenderContextType NVRenderBackendGLBase::GetRenderContextType() const
-    {
-        if (m_format.renderableType() == QSurfaceFormat::OpenGLES) {
-            if (m_format.majorVersion() == 2)
-                return NVRenderContextValues::GLES2;
-
-            if (m_format.majorVersion() == 3) {
-                if (m_format.minorVersion() >= 1)
-                    return NVRenderContextValues::GLES3PLUS;
-                else
-                    return NVRenderContextValues::GLES3;
-            }
-        } else if (m_format.majorVersion() == 2) {
-            return NVRenderContextValues::GL2;
-        } else if (m_format.majorVersion() == 3) {
-            return NVRenderContextValues::GL3;
-        } else if (m_format.majorVersion() == 4) {
-            return NVRenderContextValues::GL4;
+NVRenderContextType NVRenderBackendGLBase::GetRenderContextType() const
+{
+    if (m_format.renderableType() == QSurfaceFormat::OpenGLES) {
+        if (m_format.majorVersion() == 2)
+            return NVRenderContextValues::GLES2;
+
+        if (m_format.majorVersion() == 3) {
+            if (m_format.minorVersion() >= 1)
+                return NVRenderContextValues::GLES3PLUS;
+            else
+                return NVRenderContextValues::GLES3;
         }
-
-        return NVRenderContextValues::NullContext;
+    } else if (m_format.majorVersion() == 2) {
+        return NVRenderContextValues::GL2;
+    } else if (m_format.majorVersion() == 3) {
+        return NVRenderContextValues::GL3;
+    } else if (m_format.majorVersion() == 4) {
+        return NVRenderContextValues::GL4;
     }
 
-    bool NVRenderBackendGLBase::isESCompatible() const
-    {
-        return m_format.renderableType() == QSurfaceFormat::OpenGLES;
-    }
+    return NVRenderContextValues::NullContext;
+}
 
-    const char *NVRenderBackendGLBase::GetShadingLanguageVersion()
-    {
-        const char *retval = (const char *)GL_CALL_FUNCTION(
-            glGetString(GL_SHADING_LANGUAGE_VERSION));
-        if (retval == NULL)
-            return "";
+bool NVRenderBackendGLBase::isESCompatible() const
+{
+    return m_format.renderableType() == QSurfaceFormat::OpenGLES;
+}
 
-        return retval;
-    }
+const char *NVRenderBackendGLBase::GetShadingLanguageVersion()
+{
+    const char *retval = (const char *)GL_CALL_FUNCTION(
+        glGetString(GL_SHADING_LANGUAGE_VERSION));
+    if (retval == nullptr)
+        return "";
 
-    QT3DSU32
-    NVRenderBackendGLBase::GetMaxCombinedTextureUnits()
-    {
-        QT3DSI32 maxUnits;
-        GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxUnits));
-        return maxUnits;
-    }
+    return retval;
+}
 
-    bool NVRenderBackendGLBase::GetRenderBackendCap(
-        NVRenderBackend::NVRenderBackendCaps::Enum inCap) const
-    {
-        bool bSupported = false;
-
-        switch (inCap) {
-        case NVRenderBackendCaps::FpRenderTarget:
-            bSupported = m_backendSupport.caps.bits.bFPRenderTargetsSupported;
-            break;
-        case NVRenderBackendCaps::DepthStencilTexture:
-            bSupported = m_backendSupport.caps.bits.bDepthStencilSupported;
-            break;
-        case NVRenderBackendCaps::ConstantBuffer:
-            bSupported = m_backendSupport.caps.bits.bConstantBufferSupported;
-            break;
-        case NVRenderBackendCaps::DxtImages:
-            bSupported = m_backendSupport.caps.bits.bDXTImagesSupported;
-            break;
-        case NVRenderBackendCaps::MsTexture:
-            bSupported = m_backendSupport.caps.bits.bMsTextureSupported;
-            break;
-        case NVRenderBackendCaps::TexSwizzle:
-            bSupported = m_backendSupport.caps.bits.bTextureSwizzleSupported;
-            break;
-        case NVRenderBackendCaps::FastBlits:
-            bSupported = m_backendSupport.caps.bits.bFastBlitsSupported;
-            break;
-        case NVRenderBackendCaps::Tessellation:
-            bSupported = m_backendSupport.caps.bits.bTessellationSupported;
-            break;
-        case NVRenderBackendCaps::Compute:
-            bSupported = m_backendSupport.caps.bits.bComputeSupported;
-            break;
-        case NVRenderBackendCaps::Geometry:
-            bSupported = m_backendSupport.caps.bits.bGeometrySupported;
-            break;
-        case NVRenderBackendCaps::SampleQuery: {
-            // On the following context sample query is not supported
-            NVRenderContextType noSamplesQuerySupportedContextFlags(NVRenderContextValues::GL2
-                                                                    | NVRenderContextValues::GLES2);
-            NVRenderContextType ctxType = GetRenderContextType();
-            bSupported = !(ctxType & noSamplesQuerySupportedContextFlags);
-        } break;
-        case NVRenderBackendCaps::TimerQuery:
-            bSupported = m_backendSupport.caps.bits.bTimerQuerySupported;
-            break;
-        case NVRenderBackendCaps::CommandSync: {
-            // On the following context sync objects are not supported
-            NVRenderContextType noSyncObjectSupportedContextFlags(NVRenderContextValues::GL2
-                                                                  | NVRenderContextValues::GLES2);
-            NVRenderContextType ctxType = GetRenderContextType();
-            bSupported = !(ctxType & noSyncObjectSupportedContextFlags);
-        } break;
-        case NVRenderBackendCaps::TextureArray: {
-            // On the following context texture arrays are not supported
-            NVRenderContextType noTextureArraySupportedContextFlags(NVRenderContextValues::GL2
-                                                                    | NVRenderContextValues::GLES2);
-            NVRenderContextType ctxType = GetRenderContextType();
-            bSupported = !(ctxType & noTextureArraySupportedContextFlags);
-        } break;
-        case NVRenderBackendCaps::StorageBuffer:
-            bSupported = m_backendSupport.caps.bits.bStorageBufferSupported;
-            break;
-        case NVRenderBackendCaps::AtomicCounterBuffer:
-            bSupported = m_backendSupport.caps.bits.bAtomicCounterBufferSupported;
-            break;
-        case NVRenderBackendCaps::ShaderImageLoadStore:
-            bSupported = m_backendSupport.caps.bits.bShaderImageLoadStoreSupported;
-            break;
-        case NVRenderBackendCaps::ProgramPipeline:
-            bSupported = m_backendSupport.caps.bits.bProgramPipelineSupported;
-            break;
-        case NVRenderBackendCaps::PathRendering:
-            bSupported = m_backendSupport.caps.bits.bNVPathRenderingSupported;
-            break;
-        case NVRenderBackendCaps::AdvancedBlend:
-            bSupported = m_backendSupport.caps.bits.bNVAdvancedBlendSupported |
-                         m_backendSupport.caps.bits.bKHRAdvancedBlendSupported;
-            break;
-        case NVRenderBackendCaps::AdvancedBlendKHR:
-            bSupported = m_backendSupport.caps.bits.bKHRAdvancedBlendSupported;
-            break;
-        case NVRenderBackendCaps::BlendCoherency:
-            bSupported = m_backendSupport.caps.bits.bNVBlendCoherenceSupported |
-                         m_backendSupport.caps.bits.bKHRBlendCoherenceSupported;
-            break;
-        case NVRenderBackendCaps::gpuShader5:
-            bSupported = m_backendSupport.caps.bits.bGPUShader5ExtensionSupported;
-            break;
-        case NVRenderBackendCaps::VertexArrayObject:
-            bSupported = m_backendSupport.caps.bits.bVertexArrayObjectSupported;
-            break;
-        case NVRenderBackendCaps::StandardDerivatives:
-            bSupported = m_backendSupport.caps.bits.bStandardDerivativesSupported;
-            break;
-        case NVRenderBackendCaps::TextureLod:
-            bSupported = m_backendSupport.caps.bits.bTextureLodSupported;
-            break;
-        default:
-            QT3DS_ASSERT(false);
-            bSupported = false;
-            break;
-        }
+QT3DSU32
+NVRenderBackendGLBase::GetMaxCombinedTextureUnits()
+{
+    QT3DSI32 maxUnits;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxUnits));
+    return maxUnits;
+}
 
-        return bSupported;
-    }
+bool NVRenderBackendGLBase::GetRenderBackendCap(
+    NVRenderBackend::NVRenderBackendCaps::Enum inCap) const
+{
+    bool bSupported = false;
+
+    switch (inCap) {
+    case NVRenderBackendCaps::FpRenderTarget:
+        bSupported = m_backendSupport.caps.bits.bFPRenderTargetsSupported;
+        break;
+    case NVRenderBackendCaps::DepthStencilTexture:
+        bSupported = m_backendSupport.caps.bits.bDepthStencilSupported;
+        break;
+    case NVRenderBackendCaps::ConstantBuffer:
+        bSupported = m_backendSupport.caps.bits.bConstantBufferSupported;
+        break;
+    case NVRenderBackendCaps::DxtImages:
+        bSupported = m_backendSupport.caps.bits.bDXTImagesSupported;
+        break;
+    case NVRenderBackendCaps::MsTexture:
+        bSupported = m_backendSupport.caps.bits.bMsTextureSupported;
+        break;
+    case NVRenderBackendCaps::TexSwizzle:
+        bSupported = m_backendSupport.caps.bits.bTextureSwizzleSupported;
+        break;
+    case NVRenderBackendCaps::FastBlits:
+        bSupported = m_backendSupport.caps.bits.bFastBlitsSupported;
+        break;
+    case NVRenderBackendCaps::Tessellation:
+        bSupported = m_backendSupport.caps.bits.bTessellationSupported;
+        break;
+    case NVRenderBackendCaps::Compute:
+        bSupported = m_backendSupport.caps.bits.bComputeSupported;
+        break;
+    case NVRenderBackendCaps::Geometry:
+        bSupported = m_backendSupport.caps.bits.bGeometrySupported;
+        break;
+    case NVRenderBackendCaps::SampleQuery: {
+        // On the following context sample query is not supported
+        NVRenderContextType noSamplesQuerySupportedContextFlags(NVRenderContextValues::GL2
+                                                                | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        bSupported = !(ctxType & noSamplesQuerySupportedContextFlags);
+    } break;
+    case NVRenderBackendCaps::TimerQuery:
+        bSupported = m_backendSupport.caps.bits.bTimerQuerySupported;
+        break;
+    case NVRenderBackendCaps::CommandSync: {
+        // On the following context sync objects are not supported
+        NVRenderContextType noSyncObjectSupportedContextFlags(NVRenderContextValues::GL2
+                                                              | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        bSupported = !(ctxType & noSyncObjectSupportedContextFlags);
+    } break;
+    case NVRenderBackendCaps::TextureArray: {
+        // On the following context texture arrays are not supported
+        NVRenderContextType noTextureArraySupportedContextFlags(NVRenderContextValues::GL2
+                                                                | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        bSupported = !(ctxType & noTextureArraySupportedContextFlags);
+    } break;
+    case NVRenderBackendCaps::StorageBuffer:
+        bSupported = m_backendSupport.caps.bits.bStorageBufferSupported;
+        break;
+    case NVRenderBackendCaps::AtomicCounterBuffer:
+        bSupported = m_backendSupport.caps.bits.bAtomicCounterBufferSupported;
+        break;
+    case NVRenderBackendCaps::ShaderImageLoadStore:
+        bSupported = m_backendSupport.caps.bits.bShaderImageLoadStoreSupported;
+        break;
+    case NVRenderBackendCaps::ProgramPipeline:
+        bSupported = m_backendSupport.caps.bits.bProgramPipelineSupported;
+        break;
+    case NVRenderBackendCaps::PathRendering:
+        bSupported = m_backendSupport.caps.bits.bNVPathRenderingSupported;
+        break;
+    case NVRenderBackendCaps::AdvancedBlend:
+        bSupported = m_backendSupport.caps.bits.bNVAdvancedBlendSupported |
+                     m_backendSupport.caps.bits.bKHRAdvancedBlendSupported;
+        break;
+    case NVRenderBackendCaps::AdvancedBlendKHR:
+        bSupported = m_backendSupport.caps.bits.bKHRAdvancedBlendSupported;
+        break;
+    case NVRenderBackendCaps::BlendCoherency:
+        bSupported = m_backendSupport.caps.bits.bNVBlendCoherenceSupported |
+                     m_backendSupport.caps.bits.bKHRBlendCoherenceSupported;
+        break;
+    case NVRenderBackendCaps::gpuShader5:
+        bSupported = m_backendSupport.caps.bits.bGPUShader5ExtensionSupported;
+        break;
+    case NVRenderBackendCaps::VertexArrayObject:
+        bSupported = m_backendSupport.caps.bits.bVertexArrayObjectSupported;
+        break;
+    case NVRenderBackendCaps::StandardDerivatives:
+        bSupported = m_backendSupport.caps.bits.bStandardDerivativesSupported;
+        break;
+    case NVRenderBackendCaps::TextureLod:
+        bSupported = m_backendSupport.caps.bits.bTextureLodSupported;
+        break;
+    default:
+        QT3DS_ASSERT(false);
+        bSupported = false;
+        break;
+    }
+
+    return bSupported;
+}
 
-    void NVRenderBackendGLBase::GetRenderBackendValue(NVRenderBackendQuery::Enum inQuery,
-                                                      QT3DSI32 *params) const
-    {
-        if (params) {
-            switch (inQuery) {
-            case NVRenderBackendQuery::MaxTextureSize:
-                GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_TEXTURE_SIZE, params));
-                break;
-            case NVRenderBackendQuery::MaxTextureArrayLayers: {
-                NVRenderContextType noTextureArraySupportedContextFlags(
-                    NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
-                NVRenderContextType ctxType = GetRenderContextType();
-                if (!(ctxType & noTextureArraySupportedContextFlags)) {
-                    GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, params));
-                } else {
-                    *params = 0;
-                }
-            } break;
-            case NVRenderBackendQuery::MaxConstantBufferSlots: {
-                NVRenderContextType noConstantBufferSupportedContextFlags(
-                    NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
-                NVRenderContextType ctxType = GetRenderContextType();
-                if (!(ctxType & noConstantBufferSupportedContextFlags)) {
-                    GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, params));
-                } else {
-                    *params = 0;
-                }
-            } break;
-            case NVRenderBackendQuery::MaxConstantBufferBlockSize: {
-                NVRenderContextType noConstantBufferSupportedContextFlags(
-                    NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
-                NVRenderContextType ctxType = GetRenderContextType();
-                if (!(ctxType & noConstantBufferSupportedContextFlags)) {
-                    GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, params));
-                } else {
-                    *params = 0;
-                }
-            } break;
-            default:
-                QT3DS_ASSERT(false);
-                *params = 0;
-                break;
-            }
+void NVRenderBackendGLBase::GetRenderBackendValue(NVRenderBackendQuery::Enum inQuery,
+                                                  QT3DSI32 *params) const
+{
+    if (!params)
+        return;
+    switch (inQuery) {
+    case NVRenderBackendQuery::MaxTextureSize:
+        GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_TEXTURE_SIZE, params));
+        break;
+    case NVRenderBackendQuery::MaxTextureArrayLayers: {
+        NVRenderContextType noTextureArraySupportedContextFlags(
+            NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        if (!(ctxType & noTextureArraySupportedContextFlags)) {
+            GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, params));
+        } else {
+            *params = 0;
+        }
+    } break;
+    case NVRenderBackendQuery::MaxConstantBufferSlots: {
+        NVRenderContextType noConstantBufferSupportedContextFlags(
+            NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        if (!(ctxType & noConstantBufferSupportedContextFlags)) {
+            GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, params));
+        } else {
+            *params = 0;
         }
+    } break;
+    case NVRenderBackendQuery::MaxConstantBufferBlockSize: {
+        NVRenderContextType noConstantBufferSupportedContextFlags(
+            NVRenderContextValues::GL2 | NVRenderContextValues::GLES2);
+        NVRenderContextType ctxType = GetRenderContextType();
+        if (!(ctxType & noConstantBufferSupportedContextFlags)) {
+            GL_CALL_FUNCTION(glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, params));
+        } else {
+            *params = 0;
+        }
+    } break;
+    default:
+        QT3DS_ASSERT(false);
+        *params = 0;
+        break;
     }
+}
 
-    QT3DSU32
-    NVRenderBackendGLBase::GetDepthBits() const
-    {
-        QT3DSI32 depthBits;
-        GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_BITS, &depthBits));
-        return depthBits;
-    }
+QT3DSU32
+NVRenderBackendGLBase::GetDepthBits() const
+{
+    QT3DSI32 depthBits;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_BITS, &depthBits));
+    return depthBits;
+}
 
-    QT3DSU32
-    NVRenderBackendGLBase::GetStencilBits() const
-    {
-        QT3DSI32 stencilBits;
-        GL_CALL_FUNCTION(glGetIntegerv(GL_STENCIL_BITS, &stencilBits));
-        return stencilBits;
-    }
+QT3DSU32
+NVRenderBackendGLBase::GetStencilBits() const
+{
+    QT3DSI32 stencilBits;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_STENCIL_BITS, &stencilBits));
+    return stencilBits;
+}
 
-    void NVRenderBackendGLBase::SetMultisample(bool bEnable)
-    {
-        QT3DS_ASSERT(m_backendSupport.caps.bits.bMsTextureSupported || !bEnable);
-        // For GL ES explicit multisample enabling is not needed
-        // and does not exist
-        NVRenderContextType noMsaaEnableContextFlags(NVRenderContextValues::GLES2
-                                                     | NVRenderContextValues::GLES3
-                                                     | NVRenderContextValues::GLES3PLUS);
-        NVRenderContextType ctxType = GetRenderContextType();
-        if (!(ctxType & noMsaaEnableContextFlags)) {
-            SetRenderState(bEnable, NVRenderState::Multisample);
-        }
+void NVRenderBackendGLBase::SetMultisample(bool bEnable)
+{
+    QT3DS_ASSERT(m_backendSupport.caps.bits.bMsTextureSupported || !bEnable);
+    // For GL ES explicit multisample enabling is not needed
+    // and does not exist
+    NVRenderContextType noMsaaEnableContextFlags(NVRenderContextValues::GLES2
+                                                 | NVRenderContextValues::GLES3
+                                                 | NVRenderContextValues::GLES3PLUS);
+    NVRenderContextType ctxType = GetRenderContextType();
+    if (!(ctxType & noMsaaEnableContextFlags)) {
+        SetRenderState(bEnable, NVRenderState::Multisample);
     }
+}
 
-    void NVRenderBackendGLBase::SetRenderState(bool bEnable, const NVRenderState::Enum value)
-    {
-        if (value == NVRenderState::DepthWrite) {
-            GL_CALL_FUNCTION(glDepthMask(bEnable));
+void NVRenderBackendGLBase::SetRenderState(bool bEnable, const NVRenderState::Enum value)
+{
+    if (value == NVRenderState::DepthWrite) {
+        GL_CALL_FUNCTION(glDepthMask(bEnable));
+    } else {
+        if (bEnable) {
+            GL_CALL_FUNCTION(glEnable(m_Conversion.fromRenderStateToGL(value)));
         } else {
-            if (bEnable) {
-                GL_CALL_FUNCTION(glEnable(m_Conversion.fromRenderStateToGL(value)));
-            } else {
-                GL_CALL_FUNCTION(glDisable(m_Conversion.fromRenderStateToGL(value)));
-            }
+            GL_CALL_FUNCTION(glDisable(m_Conversion.fromRenderStateToGL(value)));
         }
     }
+}
 
-    NVRenderBackend::NVRenderBackendDepthStencilStateObject
-    NVRenderBackendGLBase::CreateDepthStencilState(
-        bool enableDepth, bool depthMask, NVRenderBoolOp::Enum depthFunc, bool enableStencil,
-        NVRenderStencilFunctionArgument &stencilFuncFront,
-        NVRenderStencilFunctionArgument &stencilFuncBack,
-        NVRenderStencilOperationArgument &depthStencilOpFront,
-        NVRenderStencilOperationArgument &depthStencilOpBack)
-    {
-        NVRenderBackendDepthStencilStateGL *retval =
-            QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendDepthStencilStateGL)(
-                enableDepth, depthMask, depthFunc, enableStencil, stencilFuncFront, stencilFuncBack,
-                depthStencilOpFront, depthStencilOpBack);
-
-        return (NVRenderBackend::NVRenderBackendDepthStencilStateObject)retval;
-    }
+NVRenderBackend::NVRenderBackendDepthStencilStateObject
+NVRenderBackendGLBase::CreateDepthStencilState(
+    bool enableDepth, bool depthMask, NVRenderBoolOp::Enum depthFunc, bool enableStencil,
+    NVRenderStencilFunctionArgument &stencilFuncFront,
+    NVRenderStencilFunctionArgument &stencilFuncBack,
+    NVRenderStencilOperationArgument &depthStencilOpFront,
+    NVRenderStencilOperationArgument &depthStencilOpBack)
+{
+    NVRenderBackendDepthStencilStateGL *retval =
+        QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendDepthStencilStateGL)(
+            enableDepth, depthMask, depthFunc, enableStencil, stencilFuncFront, stencilFuncBack,
+            depthStencilOpFront, depthStencilOpBack);
+
+    return (NVRenderBackend::NVRenderBackendDepthStencilStateObject)retval;
+}
 
-    void NVRenderBackendGLBase::ReleaseDepthStencilState(
-        NVRenderBackendDepthStencilStateObject inDepthStencilState)
-    {
-        NVRenderBackendDepthStencilStateGL *inputState =
-            (NVRenderBackendDepthStencilStateGL *)inDepthStencilState;
-        if (inputState)
-            NVDelete(m_Foundation.getAllocator(), inputState);
-    }
+void NVRenderBackendGLBase::ReleaseDepthStencilState(
+    NVRenderBackendDepthStencilStateObject inDepthStencilState)
+{
+    NVRenderBackendDepthStencilStateGL *inputState =
+        (NVRenderBackendDepthStencilStateGL *)inDepthStencilState;
+    if (inputState)
+        NVDelete(m_Foundation.getAllocator(), inputState);
+}
 
-    NVRenderBackend::NVRenderBackendRasterizerStateObject
-    NVRenderBackendGLBase::CreateRasterizerState(QT3DSF32 depthBias, QT3DSF32 depthScale,
-                                                 NVRenderFaces::Enum cullFace)
-    {
-        NVRenderBackendRasterizerStateGL *retval =
-            QT3DS_NEW(m_Foundation.getAllocator(),
-                   NVRenderBackendRasterizerStateGL)(depthBias, depthScale, cullFace);
+NVRenderBackend::NVRenderBackendRasterizerStateObject
+NVRenderBackendGLBase::CreateRasterizerState(QT3DSF32 depthBias, QT3DSF32 depthScale,
+                                             NVRenderFaces::Enum cullFace)
+{
+    NVRenderBackendRasterizerStateGL *retval =
+        QT3DS_NEW(m_Foundation.getAllocator(),
+               NVRenderBackendRasterizerStateGL)(depthBias, depthScale, cullFace);
 
-        return (NVRenderBackend::NVRenderBackendRasterizerStateObject)retval;
-    }
+    return (NVRenderBackend::NVRenderBackendRasterizerStateObject)retval;
+}
 
-    void NVRenderBackendGLBase::ReleaseRasterizerState(
-        NVRenderBackendRasterizerStateObject rasterizerState)
-    {
-        NVRenderBackendRasterizerStateGL *inputState =
-            (NVRenderBackendRasterizerStateGL *)rasterizerState;
-        if (inputState)
-            NVDelete(m_Foundation.getAllocator(), inputState);
-    }
+void NVRenderBackendGLBase::ReleaseRasterizerState(
+    NVRenderBackendRasterizerStateObject rasterizerState)
+{
+    NVRenderBackendRasterizerStateGL *inputState =
+        (NVRenderBackendRasterizerStateGL *)rasterizerState;
+    if (inputState)
+        NVDelete(m_Foundation.getAllocator(), inputState);
+}
 
-    void NVRenderBackendGLBase::SetDepthStencilState(
-        NVRenderBackendDepthStencilStateObject inDepthStencilState)
-    {
-        NVRenderBackendDepthStencilStateGL *inputState =
-            (NVRenderBackendDepthStencilStateGL *)inDepthStencilState;
-        if (inputState && !(*m_pCurrentDepthStencilState == *inputState)) {
-            // we check on a per single state base
-            if (inputState->m_DepthEnable != m_pCurrentDepthStencilState->m_DepthEnable) {
-                SetRenderState(inputState->m_DepthEnable, NVRenderState::DepthTest);
-                m_pCurrentDepthStencilState->m_DepthEnable = inputState->m_DepthEnable;
-            }
-            if (inputState->m_StencilEnable != m_pCurrentDepthStencilState->m_StencilEnable) {
-                SetRenderState(inputState->m_StencilEnable, NVRenderState::StencilTest);
-                m_pCurrentDepthStencilState->m_StencilEnable = inputState->m_StencilEnable;
-            }
+void NVRenderBackendGLBase::SetDepthStencilState(
+    NVRenderBackendDepthStencilStateObject inDepthStencilState)
+{
+    NVRenderBackendDepthStencilStateGL *inputState =
+        (NVRenderBackendDepthStencilStateGL *)inDepthStencilState;
+    if (inputState && !(*m_pCurrentDepthStencilState == *inputState)) {
+        // we check on a per single state base
+        if (inputState->m_DepthEnable != m_pCurrentDepthStencilState->m_DepthEnable) {
+            SetRenderState(inputState->m_DepthEnable, NVRenderState::DepthTest);
+            m_pCurrentDepthStencilState->m_DepthEnable = inputState->m_DepthEnable;
+        }
+        if (inputState->m_StencilEnable != m_pCurrentDepthStencilState->m_StencilEnable) {
+            SetRenderState(inputState->m_StencilEnable, NVRenderState::StencilTest);
+            m_pCurrentDepthStencilState->m_StencilEnable = inputState->m_StencilEnable;
+        }
 
-            if (inputState->m_DepthMask != m_pCurrentDepthStencilState->m_DepthMask) {
-                GL_CALL_FUNCTION(glDepthMask(inputState->m_DepthMask));
-                m_pCurrentDepthStencilState->m_DepthMask = inputState->m_DepthMask;
-            }
+        if (inputState->m_DepthMask != m_pCurrentDepthStencilState->m_DepthMask) {
+            GL_CALL_FUNCTION(glDepthMask(inputState->m_DepthMask));
+            m_pCurrentDepthStencilState->m_DepthMask = inputState->m_DepthMask;
+        }
 
-            if (inputState->m_DepthFunc != m_pCurrentDepthStencilState->m_DepthFunc) {
-                GL_CALL_FUNCTION(glDepthFunc(m_Conversion.fromBoolOpToGL(inputState->m_DepthFunc)));
-                m_pCurrentDepthStencilState->m_DepthFunc = inputState->m_DepthFunc;
-            }
+        if (inputState->m_DepthFunc != m_pCurrentDepthStencilState->m_DepthFunc) {
+            GL_CALL_FUNCTION(glDepthFunc(m_Conversion.fromBoolOpToGL(inputState->m_DepthFunc)));
+            m_pCurrentDepthStencilState->m_DepthFunc = inputState->m_DepthFunc;
+        }
 
-            if (!(inputState->m_DepthStencilOpFront
-                  == m_pCurrentDepthStencilState->m_DepthStencilOpFront)) {
-                GL_CALL_FUNCTION(glStencilOpSeparate(
-                    GL_FRONT,
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_StencilFail),
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_DepthFail),
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_DepthPass)));
-                m_pCurrentDepthStencilState->m_DepthStencilOpFront =
-                    inputState->m_DepthStencilOpFront;
-            }
+        if (!(inputState->m_DepthStencilOpFront
+              == m_pCurrentDepthStencilState->m_DepthStencilOpFront)) {
+            GL_CALL_FUNCTION(glStencilOpSeparate(
+                GL_FRONT,
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_StencilFail),
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_DepthFail),
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpFront.m_DepthPass)));
+            m_pCurrentDepthStencilState->m_DepthStencilOpFront =
+                inputState->m_DepthStencilOpFront;
+        }
 
-            if (!(inputState->m_DepthStencilOpBack
-                  == m_pCurrentDepthStencilState->m_DepthStencilOpBack)) {
-                GL_CALL_FUNCTION(glStencilOpSeparate(
-                    GL_BACK,
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_StencilFail),
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_DepthFail),
-                    m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_DepthPass)));
-                m_pCurrentDepthStencilState->m_DepthStencilOpBack =
-                    inputState->m_DepthStencilOpBack;
-            }
+        if (!(inputState->m_DepthStencilOpBack
+              == m_pCurrentDepthStencilState->m_DepthStencilOpBack)) {
+            GL_CALL_FUNCTION(glStencilOpSeparate(
+                GL_BACK,
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_StencilFail),
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_DepthFail),
+                m_Conversion.fromStencilOpToGL(inputState->m_DepthStencilOpBack.m_DepthPass)));
+            m_pCurrentDepthStencilState->m_DepthStencilOpBack =
+                inputState->m_DepthStencilOpBack;
+        }
 
-            if (!(inputState->m_StencilFuncFront
-                  == m_pCurrentDepthStencilState->m_StencilFuncFront)) {
-                GL_CALL_FUNCTION(glStencilFuncSeparate(
-                    GL_FRONT,
-                    m_Conversion.fromBoolOpToGL(inputState->m_StencilFuncFront.m_Function),
-                    inputState->m_StencilFuncFront.m_ReferenceValue,
-                    inputState->m_StencilFuncFront.m_Mask));
-                m_pCurrentDepthStencilState->m_StencilFuncFront = inputState->m_StencilFuncFront;
-            }
+        if (!(inputState->m_StencilFuncFront
+              == m_pCurrentDepthStencilState->m_StencilFuncFront)) {
+            GL_CALL_FUNCTION(glStencilFuncSeparate(
+                GL_FRONT,
+                m_Conversion.fromBoolOpToGL(inputState->m_StencilFuncFront.m_Function),
+                inputState->m_StencilFuncFront.m_ReferenceValue,
+                inputState->m_StencilFuncFront.m_Mask));
+            m_pCurrentDepthStencilState->m_StencilFuncFront = inputState->m_StencilFuncFront;
+        }
 
-            if (!(inputState->m_StencilFuncBack
-                  == m_pCurrentDepthStencilState->m_StencilFuncBack)) {
-                GL_CALL_FUNCTION(glStencilFuncSeparate(
-                    GL_BACK, m_Conversion.fromBoolOpToGL(inputState->m_StencilFuncBack.m_Function),
-                    inputState->m_StencilFuncBack.m_ReferenceValue,
-                    inputState->m_StencilFuncBack.m_Mask));
-                m_pCurrentDepthStencilState->m_StencilFuncBack = inputState->m_StencilFuncBack;
-            }
+        if (!(inputState->m_StencilFuncBack
+              == m_pCurrentDepthStencilState->m_StencilFuncBack)) {
+            GL_CALL_FUNCTION(glStencilFuncSeparate(
+                GL_BACK, m_Conversion.fromBoolOpToGL(inputState->m_StencilFuncBack.m_Function),
+                inputState->m_StencilFuncBack.m_ReferenceValue,
+                inputState->m_StencilFuncBack.m_Mask));
+            m_pCurrentDepthStencilState->m_StencilFuncBack = inputState->m_StencilFuncBack;
         }
     }
+}
 
-    void
-    NVRenderBackendGLBase::SetRasterizerState(NVRenderBackendRasterizerStateObject rasterizerState)
-    {
-        NVRenderBackendRasterizerStateGL *inputState =
-            (NVRenderBackendRasterizerStateGL *)rasterizerState;
-        if (inputState && !(*m_pCurrentRasterizerState == *inputState)) {
-            // store current state
-            *m_pCurrentRasterizerState = *inputState;
-
-            if (m_pCurrentRasterizerState->m_DepthBias != 0.0
-                || m_pCurrentRasterizerState->m_DepthScale != 0.0) {
-                GL_CALL_FUNCTION(glEnable(GL_POLYGON_OFFSET_FILL));
-            } else {
-                GL_CALL_FUNCTION(glDisable(GL_POLYGON_OFFSET_FILL));
-            }
+void
+NVRenderBackendGLBase::SetRasterizerState(NVRenderBackendRasterizerStateObject rasterizerState)
+{
+    NVRenderBackendRasterizerStateGL *inputState =
+        (NVRenderBackendRasterizerStateGL *)rasterizerState;
+    if (inputState && !(*m_pCurrentRasterizerState == *inputState)) {
+        // store current state
+        *m_pCurrentRasterizerState = *inputState;
+
+        if (m_pCurrentRasterizerState->m_DepthBias != 0.0
+            || m_pCurrentRasterizerState->m_DepthScale != 0.0) {
+            GL_CALL_FUNCTION(glEnable(GL_POLYGON_OFFSET_FILL));
+        } else {
+            GL_CALL_FUNCTION(glDisable(GL_POLYGON_OFFSET_FILL));
+        }
 
-            GL_CALL_FUNCTION(glPolygonOffset(m_pCurrentRasterizerState->m_DepthBias,
-                                       m_pCurrentRasterizerState->m_DepthScale));
+        GL_CALL_FUNCTION(glPolygonOffset(m_pCurrentRasterizerState->m_DepthBias,
+                                   m_pCurrentRasterizerState->m_DepthScale));
 
-            GL_CALL_FUNCTION(
-                glCullFace(m_Conversion.fromFacesToGL(m_pCurrentRasterizerState->m_CullFace)));
-        }
+        GL_CALL_FUNCTION(
+            glCullFace(m_Conversion.fromFacesToGL(m_pCurrentRasterizerState->m_CullFace)));
     }
+}
 
-    bool NVRenderBackendGLBase::GetRenderState(const NVRenderState::Enum value)
-    {
-        bool enabled = GL_CALL_FUNCTION(glIsEnabled(m_Conversion.fromRenderStateToGL(value)));
-        return enabled;
-    }
+bool NVRenderBackendGLBase::GetRenderState(const NVRenderState::Enum value)
+{
+    bool enabled = GL_CALL_FUNCTION(glIsEnabled(m_Conversion.fromRenderStateToGL(value)));
+    return enabled;
+}
 
-    NVRenderBoolOp::Enum NVRenderBackendGLBase::GetDepthFunc()
-    {
-        QT3DSI32 value;
-        GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_FUNC, &value));
-        return m_Conversion.fromGLToBoolOp(value);
-    }
+NVRenderBoolOp::Enum NVRenderBackendGLBase::GetDepthFunc()
+{
+    QT3DSI32 value;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_FUNC, &value));
+    return m_Conversion.fromGLToBoolOp(value);
+}
 
-    void NVRenderBackendGLBase::SetDepthFunc(const NVRenderBoolOp::Enum func)
-    {
-        GL_CALL_FUNCTION(glDepthFunc(m_Conversion.fromBoolOpToGL(func)));
-    }
+void NVRenderBackendGLBase::SetDepthFunc(const NVRenderBoolOp::Enum func)
+{
+    GL_CALL_FUNCTION(glDepthFunc(m_Conversion.fromBoolOpToGL(func)));
+}
 
-    bool NVRenderBackendGLBase::GetDepthWrite()
-    {
-        QT3DSI32 value;
-        GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_WRITEMASK, (GLint *)&value));
-        return value ? true : false;
-    }
+bool NVRenderBackendGLBase::GetDepthWrite()
+{
+    QT3DSI32 value;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_DEPTH_WRITEMASK, (GLint *)&value));
+    return value ? true : false;
+}
 
-    void NVRenderBackendGLBase::SetDepthWrite(bool bEnable) { GL_CALL_FUNCTION(glDepthMask(bEnable)); }
+void NVRenderBackendGLBase::SetDepthWrite(bool bEnable)
+{
+    GL_CALL_FUNCTION(glDepthMask(bEnable));
+}
 
-    void NVRenderBackendGLBase::SetColorWrites(bool bRed, bool bGreen, bool bBlue, bool bAlpha)
-    {
-        GL_CALL_FUNCTION(glColorMask(bRed, bGreen, bBlue, bAlpha));
-    }
+void NVRenderBackendGLBase::SetColorWrites(bool bRed, bool bGreen, bool bBlue, bool bAlpha)
+{
+    GL_CALL_FUNCTION(glColorMask(bRed, bGreen, bBlue, bAlpha));
+}
 
-    void NVRenderBackendGLBase::GetBlendFunc(NVRenderBlendFunctionArgument *pBlendFuncArg)
-    {
-        QT3DS_ASSERT(pBlendFuncArg);
-        QT3DSI32_4 values;
-
-        GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_SRC_RGB, (GLint *)&values.x));
-        GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint *)&values.y));
-        GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_DST_RGB, (GLint *)&values.z));
-        GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint *)&values.w));
-
-        pBlendFuncArg->m_SrcRGB = m_Conversion.fromGLToSrcBlendFunc(values.x);
-        pBlendFuncArg->m_SrcAlpha = m_Conversion.fromGLToSrcBlendFunc(values.y);
-        pBlendFuncArg->m_DstRGB = m_Conversion.fromGLToDstBlendFunc(values.z);
-        pBlendFuncArg->m_DstAlpha = m_Conversion.fromGLToDstBlendFunc(values.w);
-    }
+void NVRenderBackendGLBase::GetBlendFunc(NVRenderBlendFunctionArgument *pBlendFuncArg)
+{
+    QT3DS_ASSERT(pBlendFuncArg);
+    QT3DSI32_4 values;
 
-    void NVRenderBackendGLBase::SetBlendFunc(const NVRenderBlendFunctionArgument &blendFuncArg)
-    {
-        QT3DSI32_4 values;
+    GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_SRC_RGB, (GLint *)&values.x));
+    GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint *)&values.y));
+    GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_DST_RGB, (GLint *)&values.z));
+    GL_CALL_FUNCTION(glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint *)&values.w));
 
-        values.x = m_Conversion.fromSrcBlendFuncToGL(blendFuncArg.m_SrcRGB);
-        values.y = m_Conversion.fromDstBlendFuncToGL(blendFuncArg.m_DstRGB);
-        values.z = m_Conversion.fromSrcBlendFuncToGL(blendFuncArg.m_SrcAlpha);
-        values.w = m_Conversion.fromDstBlendFuncToGL(blendFuncArg.m_DstAlpha);
+    pBlendFuncArg->m_SrcRGB = m_Conversion.fromGLToSrcBlendFunc(values.x);
+    pBlendFuncArg->m_SrcAlpha = m_Conversion.fromGLToSrcBlendFunc(values.y);
+    pBlendFuncArg->m_DstRGB = m_Conversion.fromGLToDstBlendFunc(values.z);
+    pBlendFuncArg->m_DstAlpha = m_Conversion.fromGLToDstBlendFunc(values.w);
+}
 
-        GL_CALL_FUNCTION(glBlendFuncSeparate(values.x, values.y, values.z, values.w));
-    }
+void NVRenderBackendGLBase::SetBlendFunc(const NVRenderBlendFunctionArgument &blendFuncArg)
+{
+    QT3DSI32_4 values;
 
-    void NVRenderBackendGLBase::SetBlendEquation(const NVRenderBlendEquationArgument &)
-    {
-        // needs GL4 / GLES 3.1
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    values.x = m_Conversion.fromSrcBlendFuncToGL(blendFuncArg.m_SrcRGB);
+    values.y = m_Conversion.fromDstBlendFuncToGL(blendFuncArg.m_DstRGB);
+    values.z = m_Conversion.fromSrcBlendFuncToGL(blendFuncArg.m_SrcAlpha);
+    values.w = m_Conversion.fromDstBlendFuncToGL(blendFuncArg.m_DstAlpha);
 
-    void NVRenderBackendGLBase::SetBlendBarrier()
-    {
-        // needs GL4 / GLES 3.1
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    GL_CALL_FUNCTION(glBlendFuncSeparate(values.x, values.y, values.z, values.w));
+}
 
-    void NVRenderBackendGLBase::GetScissorRect(NVRenderRect *pRect)
-    {
-        QT3DS_ASSERT(pRect);
-        GL_CALL_FUNCTION(glGetIntegerv(GL_SCISSOR_BOX, (GLint *)pRect));
-    }
+void NVRenderBackendGLBase::SetBlendEquation(const NVRenderBlendEquationArgument &)
+{
+    // needs GL4 / GLES 3.1
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::SetScissorRect(const NVRenderRect &rect)
-    {
-        GL_CALL_FUNCTION(glScissor(rect.m_X, rect.m_Y, rect.m_Width, rect.m_Height));
-    }
+void NVRenderBackendGLBase::SetBlendBarrier()
+{
+    // needs GL4 / GLES 3.1
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::GetViewportRect(NVRenderRect *pRect)
-    {
-        QT3DS_ASSERT(pRect);
-        GL_CALL_FUNCTION(glGetIntegerv(GL_VIEWPORT, (GLint *)pRect));
-    }
+void NVRenderBackendGLBase::GetScissorRect(NVRenderRect *pRect)
+{
+    QT3DS_ASSERT(pRect);
+    GL_CALL_FUNCTION(glGetIntegerv(GL_SCISSOR_BOX, (GLint *)pRect));
+}
 
-    void NVRenderBackendGLBase::SetViewportRect(const NVRenderRect &rect)
-    {
-        GL_CALL_FUNCTION(glViewport(rect.m_X, rect.m_Y, rect.m_Width, rect.m_Height););
-    }
+void NVRenderBackendGLBase::SetScissorRect(const NVRenderRect &rect)
+{
+    GL_CALL_FUNCTION(glScissor(rect.m_X, rect.m_Y, rect.m_Width, rect.m_Height));
+}
 
-    void NVRenderBackendGLBase::SetClearColor(const QT3DSVec4 *pClearColor)
-    {
-        QT3DS_ASSERT(pClearColor);
+void NVRenderBackendGLBase::GetViewportRect(NVRenderRect *pRect)
+{
+    QT3DS_ASSERT(pRect);
+    GL_CALL_FUNCTION(glGetIntegerv(GL_VIEWPORT, (GLint *)pRect));
+}
 
-        GL_CALL_FUNCTION(glClearColor(pClearColor->x, pClearColor->y,
-            pClearColor->z, pClearColor->w));
-    }
+void NVRenderBackendGLBase::SetViewportRect(const NVRenderRect &rect)
+{
+    GL_CALL_FUNCTION(glViewport(rect.m_X, rect.m_Y, rect.m_Width, rect.m_Height););
+}
 
-    void NVRenderBackendGLBase::Clear(NVRenderClearFlags flags)
-    {
-        GL_CALL_FUNCTION(glClear(m_Conversion.fromClearFlagsToGL(flags)));
-    }
+void NVRenderBackendGLBase::SetClearColor(const QT3DSVec4 *pClearColor)
+{
+    QT3DS_ASSERT(pClearColor);
 
-    NVRenderBackend::NVRenderBackendBufferObject
-    NVRenderBackendGLBase::CreateBuffer(size_t size, NVRenderBufferBindFlags bindFlags,
-                                        NVRenderBufferUsageType::Enum usage, const void *hostPtr)
-    {
-        GLuint bufID = 0;
-
-        GL_CALL_FUNCTION(glGenBuffers(1, &bufID));
-
-        if (bufID && size) {
-            GLenum target = m_Conversion.fromBindBufferFlagsToGL(bindFlags);
-            if (target != GL_INVALID_ENUM) {
-                GL_CALL_FUNCTION(glBindBuffer(target, bufID));
-                GL_CALL_FUNCTION(glBufferData(target, size, hostPtr,
-                                        m_Conversion.fromBufferUsageTypeToGL(usage)));
-            } else {
-                GL_CALL_FUNCTION(glDeleteBuffers(1, &bufID));
-                bufID = 0;
-                qCCritical(GL_ERROR, GLConversion::processGLError(target));
-            }
-        }
+    GL_CALL_FUNCTION(glClearColor(pClearColor->x, pClearColor->y,
+        pClearColor->z, pClearColor->w));
+}
 
-        return (NVRenderBackend::NVRenderBackendBufferObject)bufID;
-    }
+void NVRenderBackendGLBase::Clear(NVRenderClearFlags flags)
+{
+    GL_CALL_FUNCTION(glClear(m_Conversion.fromClearFlagsToGL(flags)));
+}
 
-    void NVRenderBackendGLBase::BindBuffer(NVRenderBackendBufferObject bo,
-                                           NVRenderBufferBindFlags bindFlags)
-    {
-        GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
-        GL_CALL_FUNCTION(glBindBuffer(m_Conversion.fromBindBufferFlagsToGL(bindFlags), bufID));
-    }
+NVRenderBackend::NVRenderBackendBufferObject
+NVRenderBackendGLBase::CreateBuffer(size_t size, NVRenderBufferBindFlags bindFlags,
+                                    NVRenderBufferUsageType::Enum usage, const void *hostPtr)
+{
+    GLuint bufID = 0;
 
-    void NVRenderBackendGLBase::ReleaseBuffer(NVRenderBackendBufferObject bo)
-    {
-        GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
-        GL_CALL_FUNCTION(glDeleteBuffers(1, &bufID));
-    }
+    GL_CALL_FUNCTION(glGenBuffers(1, &bufID));
 
-    void NVRenderBackendGLBase::UpdateBuffer(NVRenderBackendBufferObject bo,
-                                             NVRenderBufferBindFlags bindFlags, size_t size,
-                                             NVRenderBufferUsageType::Enum usage, const void *data)
-    {
-        GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
+    if (bufID && size) {
         GLenum target = m_Conversion.fromBindBufferFlagsToGL(bindFlags);
-        GL_CALL_FUNCTION(glBindBuffer(target, bufID));
-        GL_CALL_FUNCTION(glBufferData(target, size, data, m_Conversion.fromBufferUsageTypeToGL(usage)));
+        if (target != GL_INVALID_ENUM) {
+            GL_CALL_FUNCTION(glBindBuffer(target, bufID));
+            GL_CALL_FUNCTION(glBufferData(target, size, hostPtr,
+                                    m_Conversion.fromBufferUsageTypeToGL(usage)));
+        } else {
+            GL_CALL_FUNCTION(glDeleteBuffers(1, &bufID));
+            bufID = 0;
+            qCCritical(GL_ERROR, GLConversion::processGLError(target));
+        }
     }
 
-    void NVRenderBackendGLBase::UpdateBufferRange(NVRenderBackendBufferObject bo,
-                                                  NVRenderBufferBindFlags bindFlags, size_t offset,
-                                                  size_t size, const void *data)
-    {
-        GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
-        GLenum target = m_Conversion.fromBindBufferFlagsToGL(bindFlags);
-        GL_CALL_FUNCTION(glBindBuffer(target, bufID));
-        GL_CALL_FUNCTION(glBufferSubData(target, offset, size, data));
-    }
+    return (NVRenderBackend::NVRenderBackendBufferObject)bufID;
+}
 
-    void *NVRenderBackendGLBase::MapBuffer(NVRenderBackendBufferObject, NVRenderBufferBindFlags,
-                                           size_t, size_t, NVRenderBufferAccessFlags)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+void NVRenderBackendGLBase::BindBuffer(NVRenderBackendBufferObject bo,
+                                       NVRenderBufferBindFlags bindFlags)
+{
+    GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
+    GL_CALL_FUNCTION(glBindBuffer(m_Conversion.fromBindBufferFlagsToGL(bindFlags), bufID));
+}
 
-        return NULL;
-    }
+void NVRenderBackendGLBase::ReleaseBuffer(NVRenderBackendBufferObject bo)
+{
+    GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
+    GL_CALL_FUNCTION(glDeleteBuffers(1, &bufID));
+}
 
-    bool NVRenderBackendGLBase::UnmapBuffer(NVRenderBackendBufferObject, NVRenderBufferBindFlags)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+void NVRenderBackendGLBase::UpdateBuffer(NVRenderBackendBufferObject bo,
+                                         NVRenderBufferBindFlags bindFlags, size_t size,
+                                         NVRenderBufferUsageType::Enum usage, const void *data)
+{
+    GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
+    GLenum target = m_Conversion.fromBindBufferFlagsToGL(bindFlags);
+    GL_CALL_FUNCTION(glBindBuffer(target, bufID));
+    GL_CALL_FUNCTION(glBufferData(target, size, data, m_Conversion.fromBufferUsageTypeToGL(usage)));
+}
 
-        return true;
-    }
+void NVRenderBackendGLBase::UpdateBufferRange(NVRenderBackendBufferObject bo,
+                                              NVRenderBufferBindFlags bindFlags, size_t offset,
+                                              size_t size, const void *data)
+{
+    GLuint bufID = HandleToID_cast(GLuint, size_t, bo);
+    GLenum target = m_Conversion.fromBindBufferFlagsToGL(bindFlags);
+    GL_CALL_FUNCTION(glBindBuffer(target, bufID));
+    GL_CALL_FUNCTION(glBufferSubData(target, offset, size, data));
+}
 
-    void NVRenderBackendGLBase::SetMemoryBarrier(NVRenderBufferBarrierFlags)
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void *NVRenderBackendGLBase::MapBuffer(NVRenderBackendBufferObject, NVRenderBufferBindFlags,
+                                       size_t, size_t, NVRenderBufferAccessFlags)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    NVRenderBackend::NVRenderBackendQueryObject NVRenderBackendGLBase::CreateQuery()
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+    return nullptr;
+}
 
-        return NVRenderBackendQueryObject(0);
-    }
+bool NVRenderBackendGLBase::UnmapBuffer(NVRenderBackendBufferObject, NVRenderBufferBindFlags)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    void NVRenderBackendGLBase::ReleaseQuery(NVRenderBackendQueryObject)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    return true;
+}
 
-    void NVRenderBackendGLBase::BeginQuery(NVRenderBackendQueryObject, NVRenderQueryType::Enum)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::SetMemoryBarrier(NVRenderBufferBarrierFlags)
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::EndQuery(NVRenderBackendQueryObject, NVRenderQueryType::Enum)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+NVRenderBackend::NVRenderBackendQueryObject NVRenderBackendGLBase::CreateQuery()
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    void NVRenderBackendGLBase::GetQueryResult(NVRenderBackendQueryObject,
-                                               NVRenderQueryResultType::Enum, QT3DSU32 *)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    return NVRenderBackendQueryObject(0);
+}
 
-    void NVRenderBackendGLBase::GetQueryResult(NVRenderBackendQueryObject,
-                                               NVRenderQueryResultType::Enum, QT3DSU64 *)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::ReleaseQuery(NVRenderBackendQueryObject)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::SetQueryTimer(NVRenderBackendQueryObject)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::BeginQuery(NVRenderBackendQueryObject, NVRenderQueryType::Enum)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    NVRenderBackend::NVRenderBackendSyncObject
-        NVRenderBackendGLBase::CreateSync(NVRenderSyncType::Enum, NVRenderSyncFlags)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+void NVRenderBackendGLBase::EndQuery(NVRenderBackendQueryObject, NVRenderQueryType::Enum)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        return NVRenderBackendSyncObject(0);
-    }
+void NVRenderBackendGLBase::GetQueryResult(NVRenderBackendQueryObject,
+                                           NVRenderQueryResultType::Enum, QT3DSU32 *)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::ReleaseSync(NVRenderBackendSyncObject)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::GetQueryResult(NVRenderBackendQueryObject,
+                                           NVRenderQueryResultType::Enum, QT3DSU64 *)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::WaitSync(NVRenderBackendSyncObject, NVRenderCommandFlushFlags,
-                                         QT3DSU64)
-    {
-        // needs GL 3 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::SetQueryTimer(NVRenderBackendQueryObject)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    NVRenderBackend::NVRenderBackendRenderTargetObject NVRenderBackendGLBase::CreateRenderTarget()
-    {
-        GLuint fboID = 0;
+NVRenderBackend::NVRenderBackendSyncObject
+    NVRenderBackendGLBase::CreateSync(NVRenderSyncType::Enum, NVRenderSyncFlags)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-        GL_CALL_FUNCTION(glGenFramebuffers(1, &fboID));
+    return NVRenderBackendSyncObject(0);
+}
 
-        return (NVRenderBackend::NVRenderBackendRenderTargetObject)fboID;
-    }
+void NVRenderBackendGLBase::ReleaseSync(NVRenderBackendSyncObject)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::ReleaseRenderTarget(NVRenderBackendRenderTargetObject rto)
-    {
-        GLuint fboID = HandleToID_cast(GLuint, size_t, rto);
+void NVRenderBackendGLBase::WaitSync(NVRenderBackendSyncObject, NVRenderCommandFlushFlags,
+                                     QT3DSU64)
+{
+    // needs GL 3 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        if (fboID) {
-            GL_CALL_FUNCTION(glDeleteFramebuffers(1, &fboID));
-        }
-    }
+NVRenderBackend::NVRenderBackendRenderTargetObject NVRenderBackendGLBase::CreateRenderTarget()
+{
+    GLuint fboID = 0;
 
-    void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject /* rto */,
-                                                   NVRenderFrameBufferAttachments::Enum attachment,
-                                                   NVRenderBackendRenderbufferObject rbo)
-    {
-        // rto must be the current render target
-        GLuint rbID = HandleToID_cast(GLuint, size_t, rbo);
+    GL_CALL_FUNCTION(glGenFramebuffers(1, &fboID));
 
-        GLenum glAttach = GLConversion::fromFramebufferAttachmentsToGL(attachment);
+    return (NVRenderBackend::NVRenderBackendRenderTargetObject)fboID;
+}
 
-        GL_CALL_FUNCTION(glFramebufferRenderbuffer(GL_FRAMEBUFFER, glAttach, GL_RENDERBUFFER, rbID));
+void NVRenderBackendGLBase::ReleaseRenderTarget(NVRenderBackendRenderTargetObject rto)
+{
+    GLuint fboID = HandleToID_cast(GLuint, size_t, rto);
+
+    if (fboID) {
+        GL_CALL_FUNCTION(glDeleteFramebuffers(1, &fboID));
     }
+}
 
-    void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject /* rto */,
-                                                   NVRenderFrameBufferAttachments::Enum attachment,
-                                                   NVRenderBackendTextureObject to,
-                                                   NVRenderTextureTargetType::Enum target)
-    {
-        // rto must be the current render target
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
+void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject /* rto */,
+                                               NVRenderFrameBufferAttachments::Enum attachment,
+                                               NVRenderBackendRenderbufferObject rbo)
+{
+    // rto must be the current render target
+    GLuint rbID = HandleToID_cast(GLuint, size_t, rbo);
+
+    GLenum glAttach = GLConversion::fromFramebufferAttachmentsToGL(attachment);
 
-        QT3DS_ASSERT(target == NVRenderTextureTargetType::Texture2D
-                  || m_backendSupport.caps.bits.bMsTextureSupported);
+    GL_CALL_FUNCTION(glFramebufferRenderbuffer(GL_FRAMEBUFFER, glAttach, GL_RENDERBUFFER, rbID));
+}
 
-        GLenum glAttach = GLConversion::fromFramebufferAttachmentsToGL(attachment);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject /* rto */,
+                                               NVRenderFrameBufferAttachments::Enum attachment,
+                                               NVRenderBackendTextureObject to,
+                                               NVRenderTextureTargetType::Enum target)
+{
+    // rto must be the current render target
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
 
-        GL_CALL_FUNCTION(glFramebufferTexture2D(GL_FRAMEBUFFER, glAttach, glTarget, texID, 0))
-    }
+    QT3DS_ASSERT(target == NVRenderTextureTargetType::Texture2D
+              || m_backendSupport.caps.bits.bMsTextureSupported);
 
-    void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject,
-                                                   NVRenderFrameBufferAttachments::Enum,
-                                                   NVRenderBackendTextureObject, QT3DSI32, QT3DSI32)
-    {
-        // Needs GL3 or GLES 3
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    GLenum glAttach = GLConversion::fromFramebufferAttachmentsToGL(attachment);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
 
-    void NVRenderBackendGLBase::SetRenderTarget(NVRenderBackendRenderTargetObject rto)
-    {
-        GLuint fboID = HandleToID_cast(GLuint, size_t, rto);
-        if (!fboID)
-            fboID = QT_PREPEND_NAMESPACE(QOpenGLContext)::currentContext()->defaultFramebufferObject();
+    GL_CALL_FUNCTION(glFramebufferTexture2D(GL_FRAMEBUFFER, glAttach, glTarget, texID, 0))
+}
 
-        GL_CALL_FUNCTION(glBindFramebuffer(GL_FRAMEBUFFER, fboID));
-    }
+void NVRenderBackendGLBase::RenderTargetAttach(NVRenderBackendRenderTargetObject,
+                                               NVRenderFrameBufferAttachments::Enum,
+                                               NVRenderBackendTextureObject, QT3DSI32, QT3DSI32)
+{
+    // Needs GL3 or GLES 3
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    bool NVRenderBackendGLBase::RenderTargetIsValid(NVRenderBackendRenderTargetObject /* rto */)
-    {
-        // rto must be the current render target
-        GLenum completeStatus = GL_CALL_FUNCTION(glCheckFramebufferStatus(GL_FRAMEBUFFER));
-        switch (completeStatus) {
-#define HANDLE_INCOMPLETE_STATUS(x)                                                                \
-    case x:                                                                                        \
-        qCCritical(INTERNAL_ERROR, "Framebuffer is not complete: %s", #x);           \
-        return false;
-            HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)
-            HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS)
-            HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)
-            HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_UNSUPPORTED)
+void NVRenderBackendGLBase::SetRenderTarget(NVRenderBackendRenderTargetObject rto)
+{
+    GLuint fboID = HandleToID_cast(GLuint, size_t, rto);
+    if (!fboID)
+        fboID = QT_PREPEND_NAMESPACE(QOpenGLContext)::currentContext()->defaultFramebufferObject();
+
+    GL_CALL_FUNCTION(glBindFramebuffer(GL_FRAMEBUFFER, fboID));
+}
+
+bool NVRenderBackendGLBase::RenderTargetIsValid(NVRenderBackendRenderTargetObject /* rto */)
+{
+    // rto must be the current render target
+    GLenum completeStatus = GL_CALL_FUNCTION(glCheckFramebufferStatus(GL_FRAMEBUFFER));
+    switch (completeStatus) {
+#define HANDLE_INCOMPLETE_STATUS(x)                                                             \
+case x:                                                                                         \
+    qCCritical(INTERNAL_ERROR, "Framebuffer is not complete: %s", #x);                          \
+    return false;
+        HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)
+        HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS)
+        HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)
+        HANDLE_INCOMPLETE_STATUS(GL_FRAMEBUFFER_UNSUPPORTED)
 #undef HANDLE_INCOMPLETE_STATUS
-        }
-        return true;
     }
+    return true;
+}
 
-    NVRenderBackend::NVRenderBackendRenderbufferObject
-    NVRenderBackendGLBase::CreateRenderbuffer(NVRenderRenderBufferFormats::Enum storageFormat,
-                                              size_t width, size_t height)
-    {
-        GLuint bufID = 0;
-
-        GL_CALL_FUNCTION(glGenRenderbuffers(1, &bufID));
-        GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, bufID));
-        GL_CALL_FUNCTION(glRenderbufferStorage(GL_RENDERBUFFER,
-                              GLConversion::fromRenderBufferFormatsToRenderBufferGL(storageFormat),
-                              (GLsizei)width, (GLsizei)height));
-
-        // check for error
-        GLenum error = m_glFunctions->glGetError();
-        if (error != GL_NO_ERROR) {
-            qCCritical(GL_ERROR, GLConversion::processGLError(error));
-            QT3DS_ASSERT(false);
-            GL_CALL_FUNCTION(glDeleteRenderbuffers(1, &bufID));
-            bufID = 0;
-        }
+NVRenderBackend::NVRenderBackendRenderbufferObject
+NVRenderBackendGLBase::CreateRenderbuffer(NVRenderRenderBufferFormats::Enum storageFormat,
+                                          size_t width, size_t height)
+{
+    GLuint bufID = 0;
 
-        GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, 0));
+    GL_CALL_FUNCTION(glGenRenderbuffers(1, &bufID));
+    GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, bufID));
+    GL_CALL_FUNCTION(glRenderbufferStorage(GL_RENDERBUFFER,
+                          GLConversion::fromRenderBufferFormatsToRenderBufferGL(storageFormat),
+                          (GLsizei)width, (GLsizei)height));
 
-        return (NVRenderBackend::NVRenderBackendRenderbufferObject)bufID;
+    // check for error
+    GLenum error = m_glFunctions->glGetError();
+    if (error != GL_NO_ERROR) {
+        qCCritical(GL_ERROR, GLConversion::processGLError(error));
+        QT3DS_ASSERT(false);
+        GL_CALL_FUNCTION(glDeleteRenderbuffers(1, &bufID));
+        bufID = 0;
     }
 
-    void NVRenderBackendGLBase::ReleaseRenderbuffer(NVRenderBackendRenderbufferObject rbo)
-    {
-        GLuint bufID = HandleToID_cast(GLuint, size_t, rbo);
+    GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, 0));
 
-        if (bufID) {
-            GL_CALL_FUNCTION(glDeleteRenderbuffers(1, &bufID));
-        }
-    }
+    return (NVRenderBackend::NVRenderBackendRenderbufferObject)bufID;
+}
 
-    bool NVRenderBackendGLBase::ResizeRenderbuffer(NVRenderBackendRenderbufferObject rbo,
-                                                   NVRenderRenderBufferFormats::Enum storageFormat,
-                                                   size_t width, size_t height)
-    {
-        bool success = true;
-        GLuint bufID = HandleToID_cast(GLuint, size_t, rbo);
-
-        QT3DS_ASSERT(bufID);
-
-        GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, bufID));
-        GL_CALL_FUNCTION(glRenderbufferStorage(GL_RENDERBUFFER,
-                              GLConversion::fromRenderBufferFormatsToRenderBufferGL(storageFormat),
-                              (GLsizei)width, (GLsizei)height));
-
-        // check for error
-        GLenum error = m_glFunctions->glGetError();
-        if (error != GL_NO_ERROR) {
-            qCCritical(GL_ERROR, GLConversion::processGLError(error));
-            QT3DS_ASSERT(false);
-            success = false;
-        }
+void NVRenderBackendGLBase::ReleaseRenderbuffer(NVRenderBackendRenderbufferObject rbo)
+{
+    GLuint bufID = HandleToID_cast(GLuint, size_t, rbo);
 
-        return success;
+    if (bufID) {
+        GL_CALL_FUNCTION(glDeleteRenderbuffers(1, &bufID));
     }
+}
 
-    NVRenderBackend::NVRenderBackendTextureObject NVRenderBackendGLBase::CreateTexture()
-    {
-        GLuint texID = 0;
+bool NVRenderBackendGLBase::ResizeRenderbuffer(NVRenderBackendRenderbufferObject rbo,
+                                               NVRenderRenderBufferFormats::Enum storageFormat,
+                                               size_t width, size_t height)
+{
+    bool success = true;
+    GLuint bufID = HandleToID_cast(GLuint, size_t, rbo);
 
-        GL_CALL_FUNCTION(glGenTextures(1, &texID));
-        return (NVRenderBackend::NVRenderBackendTextureObject)texID;
-    }
+    QT3DS_ASSERT(bufID);
 
-    void NVRenderBackendGLBase::BindTexture(NVRenderBackendTextureObject to,
-                                            NVRenderTextureTargetType::Enum target, QT3DSU32 unit)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0 + unit));
-        GL_CALL_FUNCTION(glBindTexture(m_Conversion.fromTextureTargetToGL(target), texID));
-    }
+    GL_CALL_FUNCTION(glBindRenderbuffer(GL_RENDERBUFFER, bufID));
+    GL_CALL_FUNCTION(glRenderbufferStorage(GL_RENDERBUFFER,
+                          GLConversion::fromRenderBufferFormatsToRenderBufferGL(storageFormat),
+                          (GLsizei)width, (GLsizei)height));
 
-    void NVRenderBackendGLBase::BindImageTexture(NVRenderBackendTextureObject, QT3DSU32, QT3DSI32, bool,
-                                                 QT3DSI32, NVRenderImageAccessType::Enum,
-                                                 NVRenderTextureFormats::Enum)
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+    // check for error
+    GLenum error = m_glFunctions->glGetError();
+    if (error != GL_NO_ERROR) {
+        qCCritical(GL_ERROR, GLConversion::processGLError(error));
+        QT3DS_ASSERT(false);
+        success = false;
     }
 
-    void NVRenderBackendGLBase::ReleaseTexture(NVRenderBackendTextureObject to)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GL_CALL_FUNCTION(glDeleteTextures(1, &texID));
-    }
+    return success;
+}
 
-    void NVRenderBackendGLBase::SetTextureData2D(
-        NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
-        NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
-        NVRenderTextureFormats::Enum format, const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
-        bool conversionRequired = format != internalFormat;
-
-        NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
-        internalFormat = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(),
-                                                                     internalFormat, swizzleMode);
-
-        GLenum glformat = 0, glInternalFormat = 0, gltype = GL_UNSIGNED_BYTE;
-
-        if (NVRenderTextureFormats::isUncompressedTextureFormat(internalFormat))
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), internalFormat,
-                                                           glformat, gltype, glInternalFormat);
-
-        if (conversionRequired) {
-            GLenum dummy;
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                           gltype, dummy);
-        } else if (NVRenderTextureFormats::isCompressedTextureFormat(internalFormat)) {
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                           gltype, glInternalFormat);
-            glInternalFormat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
-        } else if (NVRenderTextureFormats::isDepthTextureFormat(format))
-            m_Conversion.fromDepthTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                    gltype, glInternalFormat);
-
-        GL_CALL_FUNCTION(glTexImage2D(glTarget, level, glInternalFormat, (GLsizei)width, (GLsizei)height,
-                                border, glformat, gltype, hostPtr));
-
-        GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
-    }
+NVRenderBackend::NVRenderBackendTextureObject NVRenderBackendGLBase::CreateTexture()
+{
+    GLuint texID = 0;
 
-    // This will look very SetTextureData2D, but the target for glBindTexture will be different from
-    // the target for
-    // glTexImage2D.
-    void NVRenderBackendGLBase::SetTextureDataCubeFace(
-        NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
-        NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
-        NVRenderTextureFormats::Enum format, const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GLenum glTexTarget =
-            m_Conversion.fromTextureTargetToGL(NVRenderTextureTargetType::TextureCube);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTexTarget, texID));
-        bool conversionRequired = format != internalFormat;
-
-        NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
-        internalFormat = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(),
-                                                                     internalFormat, swizzleMode);
-
-        GLenum glformat = 0, glInternalFormat = 0, gltype = GL_UNSIGNED_BYTE;
-
-        if (NVRenderTextureFormats::isUncompressedTextureFormat(internalFormat))
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), internalFormat,
-                                                           glformat, gltype, glInternalFormat);
-
-
-        if (conversionRequired) {
-            GLenum dummy;
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                           gltype, dummy);
-        } else if (NVRenderTextureFormats::isCompressedTextureFormat(internalFormat)) {
-            m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                           gltype, glInternalFormat);
-            glInternalFormat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
-        } else if (NVRenderTextureFormats::isDepthTextureFormat(format))
-            m_Conversion.fromDepthTextureFormatToGL(GetRenderContextType(), format, glformat,
-                                                    gltype, glInternalFormat);
-
-        // for es2 internal format must be same as format
-        if (GetRenderContextType() == NVRenderContextValues::GLES2)
-            glInternalFormat = glformat;
-
-        GL_CALL_FUNCTION(glTexImage2D(glTarget, level, glInternalFormat, (GLsizei)width, (GLsizei)height,
-                                border, glformat, gltype, hostPtr));
-
-        GL_CALL_FUNCTION(glBindTexture(glTexTarget, 0));
-    }
+    GL_CALL_FUNCTION(glGenTextures(1, &texID));
+    return (NVRenderBackend::NVRenderBackendTextureObject)texID;
+}
 
-    void NVRenderBackendGLBase::CreateTextureStorage2D(NVRenderBackendTextureObject,
-                                                       NVRenderTextureTargetType::Enum, QT3DSU32,
-                                                       NVRenderTextureFormats::Enum, size_t, size_t)
-    {
-        // you need GL 4.2 or GLES 3.1
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::BindTexture(NVRenderBackendTextureObject to,
+                                        NVRenderTextureTargetType::Enum target, QT3DSU32 unit)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0 + unit));
+    GL_CALL_FUNCTION(glBindTexture(m_Conversion.fromTextureTargetToGL(target), texID));
+}
 
-    void NVRenderBackendGLBase::SetTextureSubData2D(NVRenderBackendTextureObject to,
-                                                    NVRenderTextureTargetType::Enum target,
-                                                    QT3DSU32 level, QT3DSI32 xOffset, QT3DSI32 yOffset,
-                                                    size_t width, size_t height,
-                                                    NVRenderTextureFormats::Enum format,
-                                                    const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+void NVRenderBackendGLBase::BindImageTexture(NVRenderBackendTextureObject, QT3DSU32, QT3DSI32, bool,
+                                             QT3DSI32, NVRenderImageAccessType::Enum,
+                                             NVRenderTextureFormats::Enum)
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
-        format = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(), format,
-                                                             swizzleMode);
+void NVRenderBackendGLBase::ReleaseTexture(NVRenderBackendTextureObject to)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GL_CALL_FUNCTION(glDeleteTextures(1, &texID));
+}
 
-        GLenum glformat = 0, glInternalFormat = 0, gltype = 0;
+void NVRenderBackendGLBase::SetTextureData2D(
+    NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
+    NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
+    NVRenderTextureFormats::Enum format, const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+    bool conversionRequired = format != internalFormat;
+
+    NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
+    internalFormat = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(),
+                                                                 internalFormat, swizzleMode);
+
+    GLenum glformat = 0, glInternalFormat = 0, gltype = GL_UNSIGNED_BYTE;
+
+    if (NVRenderTextureFormats::isUncompressedTextureFormat(internalFormat))
+        m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), internalFormat,
+                                                       glformat, gltype, glInternalFormat);
+
+    if (conversionRequired) {
+        GLenum dummy;
+        m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                       gltype, dummy);
+    } else if (NVRenderTextureFormats::isCompressedTextureFormat(internalFormat)) {
         m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
                                                        gltype, glInternalFormat);
-        GL_CALL_FUNCTION(glTexSubImage2D(glTarget, level, xOffset, yOffset, (GLsizei)width,
-                                   (GLsizei)height, glformat, gltype, hostPtr));
-
-        GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
-    }
+        glInternalFormat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
+    } else if (NVRenderTextureFormats::isDepthTextureFormat(format))
+        m_Conversion.fromDepthTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                gltype, glInternalFormat);
 
-    void NVRenderBackendGLBase::SetCompressedTextureData2D(
-        NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
-        NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
-        size_t imageSize, const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+    GL_CALL_FUNCTION(glTexImage2D(glTarget, level, glInternalFormat, (GLsizei)width, (GLsizei)height,
+                            border, glformat, gltype, hostPtr));
 
-        GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
-        GL_CALL_FUNCTION(glCompressedTexImage2D(glTarget, level, glformat, (GLsizei)width,
-                                          (GLsizei)height, border, (GLsizei)imageSize, hostPtr));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
+}
 
-        GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
-    }
+// This will look very SetTextureData2D, but the target for glBindTexture will be different from
+// the target for
+// glTexImage2D.
+void NVRenderBackendGLBase::SetTextureDataCubeFace(
+    NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
+    NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
+    NVRenderTextureFormats::Enum format, const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GLenum glTexTarget =
+        m_Conversion.fromTextureTargetToGL(NVRenderTextureTargetType::TextureCube);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTexTarget, texID));
+    bool conversionRequired = format != internalFormat;
+
+    NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
+    internalFormat = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(),
+                                                                 internalFormat, swizzleMode);
+
+    GLenum glformat = 0, glInternalFormat = 0, gltype = GL_UNSIGNED_BYTE;
+
+    if (NVRenderTextureFormats::isUncompressedTextureFormat(internalFormat))
+        m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), internalFormat,
+                                                       glformat, gltype, glInternalFormat);
+
+
+    if (conversionRequired) {
+        GLenum dummy;
+        m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                       gltype, dummy);
+    } else if (NVRenderTextureFormats::isCompressedTextureFormat(internalFormat)) {
+        m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                       gltype, glInternalFormat);
+        glInternalFormat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
+    } else if (NVRenderTextureFormats::isDepthTextureFormat(format))
+        m_Conversion.fromDepthTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                gltype, glInternalFormat);
 
-    void NVRenderBackendGLBase::SetCompressedTextureDataCubeFace(
-        NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
-        NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
-        size_t imageSize, const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GLenum glTexTarget =
-            m_Conversion.fromTextureTargetToGL(NVRenderTextureTargetType::TextureCube);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTexTarget, texID));
-
-        GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
-        GL_CALL_FUNCTION(glCompressedTexImage2D(glTarget, level, glformat, (GLsizei)width,
-                                          (GLsizei)height, border, (GLsizei)imageSize, hostPtr));
-
-        GL_CALL_FUNCTION(glBindTexture(glTexTarget, 0));
-    }
+    // for es2 internal format must be same as format
+    if (GetRenderContextType() == NVRenderContextValues::GLES2)
+        glInternalFormat = glformat;
 
-    void NVRenderBackendGLBase::SetCompressedTextureSubData2D(
-        NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
-        QT3DSI32 xOffset, QT3DSI32 yOffset, size_t width, size_t height,
-        NVRenderTextureFormats::Enum format, size_t imageSize, const void *hostPtr)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+    GL_CALL_FUNCTION(glTexImage2D(glTarget, level, glInternalFormat, (GLsizei)width, (GLsizei)height,
+                            border, glformat, gltype, hostPtr));
 
-        GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(format);
-        GL_CALL_FUNCTION(glCompressedTexSubImage2D(glTarget, level, xOffset, yOffset, (GLsizei)width,
-                                             (GLsizei)height, glformat, (GLsizei)imageSize,
-                                             hostPtr));
-
-        GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
-    }
+    GL_CALL_FUNCTION(glBindTexture(glTexTarget, 0));
+}
 
-    void NVRenderBackendGLBase::SetTextureData3D(NVRenderBackendTextureObject,
-                                                 NVRenderTextureTargetType::Enum, QT3DSU32,
-                                                 NVRenderTextureFormats::Enum, size_t, size_t,
-                                                 size_t, QT3DSI32, NVRenderTextureFormats::Enum,
-                                                 const void *)
-    {
-        // needs GL3 or GLES3
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::CreateTextureStorage2D(NVRenderBackendTextureObject,
+                                                   NVRenderTextureTargetType::Enum, QT3DSU32,
+                                                   NVRenderTextureFormats::Enum, size_t, size_t)
+{
+    // you need GL 4.2 or GLES 3.1
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::GenerateMipMaps(NVRenderBackendTextureObject to,
+void NVRenderBackendGLBase::SetTextureSubData2D(NVRenderBackendTextureObject to,
                                                 NVRenderTextureTargetType::Enum target,
-                                                NVRenderHint::Enum genType)
-    {
-        GLuint texID = HandleToID_cast(GLuint, size_t, to);
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-        GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
-        GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+                                                QT3DSU32 level, QT3DSI32 xOffset, QT3DSI32 yOffset,
+                                                size_t width, size_t height,
+                                                NVRenderTextureFormats::Enum format,
+                                                const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+
+    NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
+    format = m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(), format,
+                                                         swizzleMode);
+
+    GLenum glformat = 0, glInternalFormat = 0, gltype = 0;
+    m_Conversion.fromUncompressedTextureFormatToGL(GetRenderContextType(), format, glformat,
+                                                   gltype, glInternalFormat);
+    GL_CALL_FUNCTION(glTexSubImage2D(glTarget, level, xOffset, yOffset, (GLsizei)width,
+                               (GLsizei)height, glformat, gltype, hostPtr));
+
+    GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
+}
 
-        GLenum glValue = GLConversion::fromHintToGL(genType);
-        GL_CALL_FUNCTION(glHint(GL_GENERATE_MIPMAP_HINT, glValue));
-        GL_CALL_FUNCTION(glGenerateMipmap(glTarget));
+void NVRenderBackendGLBase::SetCompressedTextureData2D(
+    NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
+    NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
+    size_t imageSize, const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+
+    GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
+    GL_CALL_FUNCTION(glCompressedTexImage2D(glTarget, level, glformat, (GLsizei)width,
+                                      (GLsizei)height, border, (GLsizei)imageSize, hostPtr));
+
+    GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
+}
 
-        GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
-    }
+void NVRenderBackendGLBase::SetCompressedTextureDataCubeFace(
+    NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
+    NVRenderTextureFormats::Enum internalFormat, size_t width, size_t height, QT3DSI32 border,
+    size_t imageSize, const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GLenum glTexTarget =
+        m_Conversion.fromTextureTargetToGL(NVRenderTextureTargetType::TextureCube);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTexTarget, texID));
+
+    GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(internalFormat);
+    GL_CALL_FUNCTION(glCompressedTexImage2D(glTarget, level, glformat, (GLsizei)width,
+                                      (GLsizei)height, border, (GLsizei)imageSize, hostPtr));
+
+    GL_CALL_FUNCTION(glBindTexture(glTexTarget, 0));
+}
 
-    NVRenderTextureSwizzleMode::Enum
-    NVRenderBackendGLBase::GetTextureSwizzleMode(const NVRenderTextureFormats::Enum inFormat) const
-    {
-        NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
-        m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(), inFormat, swizzleMode);
+void NVRenderBackendGLBase::SetCompressedTextureSubData2D(
+    NVRenderBackendTextureObject to, NVRenderTextureTargetType::Enum target, QT3DSU32 level,
+    QT3DSI32 xOffset, QT3DSI32 yOffset, size_t width, size_t height,
+    NVRenderTextureFormats::Enum format, size_t imageSize, const void *hostPtr)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
+
+    GLenum glformat = m_Conversion.fromCompressedTextureFormatToGL(format);
+    GL_CALL_FUNCTION(glCompressedTexSubImage2D(glTarget, level, xOffset, yOffset, (GLsizei)width,
+                                         (GLsizei)height, glformat, (GLsizei)imageSize,
+                                         hostPtr));
+
+    GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
+}
 
-        return swizzleMode;
-    }
+void NVRenderBackendGLBase::SetTextureData3D(NVRenderBackendTextureObject,
+                                             NVRenderTextureTargetType::Enum, QT3DSU32,
+                                             NVRenderTextureFormats::Enum, size_t, size_t,
+                                             size_t, QT3DSI32, NVRenderTextureFormats::Enum,
+                                             const void *)
+{
+    // needs GL3 or GLES3
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    NVRenderBackend::NVRenderBackendSamplerObject NVRenderBackendGLBase::CreateSampler(
-        NVRenderTextureMinifyingOp::Enum minFilter, NVRenderTextureMagnifyingOp::Enum magFilter,
-        NVRenderTextureCoordOp::Enum wrapS, NVRenderTextureCoordOp::Enum wrapT,
-        NVRenderTextureCoordOp::Enum wrapR, QT3DSI32 minLod, QT3DSI32 maxLod, QT3DSF32 lodBias,
-        NVRenderTextureCompareMode::Enum compareMode, NVRenderTextureCompareOp::Enum compareFunc,
-        QT3DSF32 anisotropy, QT3DSF32 *borderColor)
-    {
-        // Satisfy the compiler
-        // We don"t setup the state here for GL
-        // but we need to pass on the variables here
-        // to satisfy the interface
-        NVRENDER_BACKEND_UNUSED(minFilter);
-        NVRENDER_BACKEND_UNUSED(magFilter);
-        NVRENDER_BACKEND_UNUSED(wrapS);
-        NVRENDER_BACKEND_UNUSED(wrapT);
-        NVRENDER_BACKEND_UNUSED(wrapR);
-        NVRENDER_BACKEND_UNUSED(minLod);
-        NVRENDER_BACKEND_UNUSED(maxLod);
-        NVRENDER_BACKEND_UNUSED(lodBias);
-        NVRENDER_BACKEND_UNUSED(compareMode);
-        NVRENDER_BACKEND_UNUSED(compareFunc);
-        NVRENDER_BACKEND_UNUSED(anisotropy);
-        NVRENDER_BACKEND_UNUSED(borderColor);
-
-        // return a dummy handle
-        return (NVRenderBackend::NVRenderBackendSamplerObject)0x0001;
-    }
+void NVRenderBackendGLBase::GenerateMipMaps(NVRenderBackendTextureObject to,
+                                            NVRenderTextureTargetType::Enum target,
+                                            NVRenderHint::Enum genType)
+{
+    GLuint texID = HandleToID_cast(GLuint, size_t, to);
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+    GL_CALL_FUNCTION(glActiveTexture(GL_TEXTURE0));
+    GL_CALL_FUNCTION(glBindTexture(glTarget, texID));
 
-    void NVRenderBackendGLBase::UpdateSampler(
-        NVRenderBackendSamplerObject /* so */, NVRenderTextureTargetType::Enum target,
-        NVRenderTextureMinifyingOp::Enum minFilter, NVRenderTextureMagnifyingOp::Enum magFilter,
-        NVRenderTextureCoordOp::Enum wrapS, NVRenderTextureCoordOp::Enum wrapT,
-        NVRenderTextureCoordOp::Enum wrapR, QT3DSF32 minLod, QT3DSF32 maxLod, QT3DSF32 lodBias,
-        NVRenderTextureCompareMode::Enum compareMode, NVRenderTextureCompareOp::Enum compareFunc,
-        QT3DSF32 anisotropy, QT3DSF32 *borderColor)
-    {
-        // Satisfy the compiler
-        // These are not available in GLES 2 and we don't use them right now
-        NVRENDER_BACKEND_UNUSED(wrapR);
-        NVRENDER_BACKEND_UNUSED(lodBias);
-        NVRENDER_BACKEND_UNUSED(minLod);
-        NVRENDER_BACKEND_UNUSED(maxLod);
-        NVRENDER_BACKEND_UNUSED(compareMode);
-        NVRENDER_BACKEND_UNUSED(compareFunc);
-        NVRENDER_BACKEND_UNUSED(borderColor);
-
-        GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
-
-        GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_MIN_FILTER,
-                                   m_Conversion.fromTextureMinifyingOpToGL(minFilter)));
-        GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_MAG_FILTER,
-                                   m_Conversion.fromTextureMagnifyingOpToGL(magFilter)));
-        GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_WRAP_S,
-                                   m_Conversion.fromTextureCoordOpToGL(wrapS)));
-        GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_WRAP_T,
-                                   m_Conversion.fromTextureCoordOpToGL(wrapT)));
-        if (m_backendSupport.caps.bits.bAnistropySupported) {
-            GL_CALL_FUNCTION(glTexParameterf(glTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT,
-                                             qMin(m_maxAnisotropy, anisotropy)));
-        }
-    }
+    GLenum glValue = GLConversion::fromHintToGL(genType);
+    GL_CALL_FUNCTION(glHint(GL_GENERATE_MIPMAP_HINT, glValue));
+    GL_CALL_FUNCTION(glGenerateMipmap(glTarget));
 
-    void NVRenderBackendGLBase::UpdateTextureObject(NVRenderBackendTextureObject to,
-                                                    NVRenderTextureTargetType::Enum target,
-                                                    QT3DSI32 baseLevel, QT3DSI32 maxLevel)
-    {
-        NVRENDER_BACKEND_UNUSED(to);
-        NVRENDER_BACKEND_UNUSED(target);
-        NVRENDER_BACKEND_UNUSED(baseLevel);
-        NVRENDER_BACKEND_UNUSED(maxLevel);
-    }
+    GL_CALL_FUNCTION(glBindTexture(glTarget, 0));
+}
 
-    void NVRenderBackendGLBase::UpdateTextureSwizzle(NVRenderBackendTextureObject to,
-                                                     NVRenderTextureTargetType::Enum target,
-                                                     NVRenderTextureSwizzleMode::Enum swizzleMode)
-    {
-        NVRENDER_BACKEND_UNUSED(to);
-        NVRENDER_BACKEND_UNUSED(target);
+NVRenderTextureSwizzleMode::Enum
+NVRenderBackendGLBase::GetTextureSwizzleMode(const NVRenderTextureFormats::Enum inFormat) const
+{
+    NVRenderTextureSwizzleMode::Enum swizzleMode = NVRenderTextureSwizzleMode::NoSwizzle;
+    m_Conversion.replaceDeprecatedTextureFormat(GetRenderContextType(), inFormat, swizzleMode);
 
-        // Nothing to do here still might be called
-        QT3DS_ASSERT(swizzleMode == NVRenderTextureSwizzleMode::NoSwizzle);
+    return swizzleMode;
+}
 
-        NVRENDER_BACKEND_UNUSED(swizzleMode);
-    }
+NVRenderBackend::NVRenderBackendSamplerObject NVRenderBackendGLBase::CreateSampler(
+    NVRenderTextureMinifyingOp::Enum minFilter, NVRenderTextureMagnifyingOp::Enum magFilter,
+    NVRenderTextureCoordOp::Enum wrapS, NVRenderTextureCoordOp::Enum wrapT,
+    NVRenderTextureCoordOp::Enum wrapR, QT3DSI32 minLod, QT3DSI32 maxLod, QT3DSF32 lodBias,
+    NVRenderTextureCompareMode::Enum compareMode, NVRenderTextureCompareOp::Enum compareFunc,
+    QT3DSF32 anisotropy, QT3DSF32 *borderColor)
+{
+    // Satisfy the compiler
+    // We don"t setup the state here for GL
+    // but we need to pass on the variables here
+    // to satisfy the interface
+    NVRENDER_BACKEND_UNUSED(minFilter);
+    NVRENDER_BACKEND_UNUSED(magFilter);
+    NVRENDER_BACKEND_UNUSED(wrapS);
+    NVRENDER_BACKEND_UNUSED(wrapT);
+    NVRENDER_BACKEND_UNUSED(wrapR);
+    NVRENDER_BACKEND_UNUSED(minLod);
+    NVRENDER_BACKEND_UNUSED(maxLod);
+    NVRENDER_BACKEND_UNUSED(lodBias);
+    NVRENDER_BACKEND_UNUSED(compareMode);
+    NVRENDER_BACKEND_UNUSED(compareFunc);
+    NVRENDER_BACKEND_UNUSED(anisotropy);
+    NVRENDER_BACKEND_UNUSED(borderColor);
+
+    // return a dummy handle
+    return (NVRenderBackend::NVRenderBackendSamplerObject)0x0001;
+}
 
-    void NVRenderBackendGLBase::ReleaseSampler(NVRenderBackendSamplerObject so)
-    {
-        GLuint samplerID = HandleToID_cast(GLuint, size_t, so);
-        if (!samplerID)
-            return;
-        // otherwise nothing to do
+void NVRenderBackendGLBase::UpdateSampler(
+    NVRenderBackendSamplerObject /* so */, NVRenderTextureTargetType::Enum target,
+    NVRenderTextureMinifyingOp::Enum minFilter, NVRenderTextureMagnifyingOp::Enum magFilter,
+    NVRenderTextureCoordOp::Enum wrapS, NVRenderTextureCoordOp::Enum wrapT,
+    NVRenderTextureCoordOp::Enum wrapR, QT3DSF32 minLod, QT3DSF32 maxLod, QT3DSF32 lodBias,
+    NVRenderTextureCompareMode::Enum compareMode, NVRenderTextureCompareOp::Enum compareFunc,
+    QT3DSF32 anisotropy, QT3DSF32 *borderColor)
+{
+    // Satisfy the compiler
+    // These are not available in GLES 2 and we don't use them right now
+    NVRENDER_BACKEND_UNUSED(wrapR);
+    NVRENDER_BACKEND_UNUSED(lodBias);
+    NVRENDER_BACKEND_UNUSED(minLod);
+    NVRENDER_BACKEND_UNUSED(maxLod);
+    NVRENDER_BACKEND_UNUSED(compareMode);
+    NVRENDER_BACKEND_UNUSED(compareFunc);
+    NVRENDER_BACKEND_UNUSED(borderColor);
+
+    GLenum glTarget = m_Conversion.fromTextureTargetToGL(target);
+
+    GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_MIN_FILTER,
+                               m_Conversion.fromTextureMinifyingOpToGL(minFilter)));
+    GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_MAG_FILTER,
+                               m_Conversion.fromTextureMagnifyingOpToGL(magFilter)));
+    GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_WRAP_S,
+                               m_Conversion.fromTextureCoordOpToGL(wrapS)));
+    GL_CALL_FUNCTION(glTexParameteri(glTarget, GL_TEXTURE_WRAP_T,
+                               m_Conversion.fromTextureCoordOpToGL(wrapT)));
+    if (m_backendSupport.caps.bits.bAnistropySupported) {
+        GL_CALL_FUNCTION(glTexParameterf(glTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                                         qMin(m_maxAnisotropy, anisotropy)));
     }
+}
 
-    NVRenderBackend::NVRenderBackendAttribLayoutObject
-    NVRenderBackendGLBase::CreateAttribLayout(NVConstDataRef<NVRenderVertexBufferEntry> attribs)
-    {
-        QT3DSU32 attribLayoutSize = sizeof(NVRenderBackendAttributeLayoutGL);
-        QT3DSU32 entrySize = sizeof(NVRenderBackendLayoutEntryGL) * attribs.size();
-        QT3DSU8 *newMem = (QT3DSU8 *)QT3DS_ALLOC(m_Foundation.getAllocator(), attribLayoutSize + entrySize,
-                                        "BackendAttributeLayoutGL");
-        NVDataRef<NVRenderBackendLayoutEntryGL> entryRef =
-            PtrAtOffset<NVRenderBackendLayoutEntryGL>(newMem, attribLayoutSize, entrySize);
-        QT3DSU32 maxInputSlot = 0;
-
-        // copy data
-        QT3DS_FOREACH(idx, attribs.size())
-        {
-            entryRef[idx].m_AttribName = m_StringTable->RegisterStr(attribs.mData[idx].m_Name);
-            entryRef[idx].m_Normalize = 0;
-            entryRef[idx].m_AttribIndex = 0; // will be set later
-            entryRef[idx].m_Type = m_Conversion.fromComponentTypeAndNumCompsToAttribGL(
-                attribs.mData[idx].m_ComponentType, attribs.mData[idx].m_NumComponents);
-            entryRef[idx].m_NumComponents = attribs.mData[idx].m_NumComponents;
-            entryRef[idx].m_InputSlot = attribs.mData[idx].m_InputSlot;
-            entryRef[idx].m_Offset = attribs.mData[idx].m_FirstItemOffset;
-
-            if (maxInputSlot < entryRef[idx].m_InputSlot)
-                maxInputSlot = entryRef[idx].m_InputSlot;
-        }
+void NVRenderBackendGLBase::UpdateTextureObject(NVRenderBackendTextureObject to,
+                                                NVRenderTextureTargetType::Enum target,
+                                                QT3DSI32 baseLevel, QT3DSI32 maxLevel)
+{
+    NVRENDER_BACKEND_UNUSED(to);
+    NVRENDER_BACKEND_UNUSED(target);
+    NVRENDER_BACKEND_UNUSED(baseLevel);
+    NVRENDER_BACKEND_UNUSED(maxLevel);
+}
 
-        NVRenderBackendAttributeLayoutGL *retval =
-            new (newMem) NVRenderBackendAttributeLayoutGL(entryRef, maxInputSlot);
+void NVRenderBackendGLBase::UpdateTextureSwizzle(NVRenderBackendTextureObject to,
+                                                 NVRenderTextureTargetType::Enum target,
+                                                 NVRenderTextureSwizzleMode::Enum swizzleMode)
+{
+    NVRENDER_BACKEND_UNUSED(to);
+    NVRENDER_BACKEND_UNUSED(target);
 
-        return (NVRenderBackend::NVRenderBackendAttribLayoutObject)retval;
-    }
+    // Nothing to do here still might be called
+    QT3DS_ASSERT(swizzleMode == NVRenderTextureSwizzleMode::NoSwizzle);
 
-    void NVRenderBackendGLBase::ReleaseAttribLayout(NVRenderBackendAttribLayoutObject ao)
-    {
-        NVRenderBackendAttributeLayoutGL *attribLayout = (NVRenderBackendAttributeLayoutGL *)ao;
-
-        NVDelete(m_Foundation.getAllocator(), attribLayout);
-    };
-
-    NVRenderBackend::NVRenderBackendInputAssemblerObject
-    NVRenderBackendGLBase::CreateInputAssembler(NVRenderBackendAttribLayoutObject attribLayout,
-                                                NVConstDataRef<NVRenderBackendBufferObject> buffers,
-                                                const NVRenderBackendBufferObject indexBuffer,
-                                                NVConstDataRef<QT3DSU32> strides,
-                                                NVConstDataRef<QT3DSU32> offsets,
-                                                QT3DSU32 patchVertexCount)
-    {
-        NVRenderBackendAttributeLayoutGL *attribLayoutGL =
-            (NVRenderBackendAttributeLayoutGL *)attribLayout;
+    NVRENDER_BACKEND_UNUSED(swizzleMode);
+}
 
-        NVRenderBackendInputAssemblerGL *retval = QT3DS_NEW(m_Foundation.getAllocator(),
-                                                         NVRenderBackendInputAssemblerGL)(
-            m_Foundation, attribLayoutGL, buffers, indexBuffer, strides, offsets, patchVertexCount);
+void NVRenderBackendGLBase::ReleaseSampler(NVRenderBackendSamplerObject so)
+{
+    GLuint samplerID = HandleToID_cast(GLuint, size_t, so);
+    if (!samplerID)
+        return;
+    // otherwise nothing to do
+}
 
-        return (NVRenderBackend::NVRenderBackendInputAssemblerObject)retval;
-    }
+NVRenderBackend::NVRenderBackendAttribLayoutObject
+NVRenderBackendGLBase::CreateAttribLayout(NVConstDataRef<NVRenderVertexBufferEntry> attribs)
+{
+    QT3DSU32 attribLayoutSize = sizeof(NVRenderBackendAttributeLayoutGL);
+    QT3DSU32 entrySize = sizeof(NVRenderBackendLayoutEntryGL) * attribs.size();
+    QT3DSU8 *newMem = (QT3DSU8 *)QT3DS_ALLOC(m_Foundation.getAllocator(),
+                                             attribLayoutSize + entrySize,
+                                             "BackendAttributeLayoutGL");
+    NVDataRef<NVRenderBackendLayoutEntryGL> entryRef =
+        PtrAtOffset<NVRenderBackendLayoutEntryGL>(newMem, attribLayoutSize, entrySize);
+    QT3DSU32 maxInputSlot = 0;
+
+    // copy data
+    QT3DS_FOREACH(idx, attribs.size())
+    {
+        entryRef[idx].m_AttribName = m_StringTable->RegisterStr(attribs.mData[idx].m_Name);
+        entryRef[idx].m_Normalize = 0;
+        entryRef[idx].m_AttribIndex = 0; // will be set later
+        entryRef[idx].m_Type = m_Conversion.fromComponentTypeAndNumCompsToAttribGL(
+            attribs.mData[idx].m_ComponentType, attribs.mData[idx].m_NumComponents);
+        entryRef[idx].m_NumComponents = attribs.mData[idx].m_NumComponents;
+        entryRef[idx].m_InputSlot = attribs.mData[idx].m_InputSlot;
+        entryRef[idx].m_Offset = attribs.mData[idx].m_FirstItemOffset;
+
+        if (maxInputSlot < entryRef[idx].m_InputSlot)
+            maxInputSlot = entryRef[idx].m_InputSlot;
+    }
+
+    NVRenderBackendAttributeLayoutGL *retval =
+        new (newMem) NVRenderBackendAttributeLayoutGL(entryRef, maxInputSlot);
+
+    return (NVRenderBackend::NVRenderBackendAttribLayoutObject)retval;
+}
 
-    void NVRenderBackendGLBase::ReleaseInputAssembler(NVRenderBackendInputAssemblerObject iao)
-    {
-        NVRenderBackendInputAssemblerGL *inputAssembler = (NVRenderBackendInputAssemblerGL *)iao;
-        NVDelete(m_Foundation.getAllocator(), inputAssembler);
-    }
+void NVRenderBackendGLBase::ReleaseAttribLayout(NVRenderBackendAttribLayoutObject ao)
+{
+    NVRenderBackendAttributeLayoutGL *attribLayout = (NVRenderBackendAttributeLayoutGL *)ao;
+
+    NVDelete(m_Foundation.getAllocator(), attribLayout);
+};
+
+NVRenderBackend::NVRenderBackendInputAssemblerObject
+NVRenderBackendGLBase::CreateInputAssembler(NVRenderBackendAttribLayoutObject attribLayout,
+                                            NVConstDataRef<NVRenderBackendBufferObject> buffers,
+                                            const NVRenderBackendBufferObject indexBuffer,
+                                            NVConstDataRef<QT3DSU32> strides,
+                                            NVConstDataRef<QT3DSU32> offsets,
+                                            QT3DSU32 patchVertexCount)
+{
+    NVRenderBackendAttributeLayoutGL *attribLayoutGL =
+        (NVRenderBackendAttributeLayoutGL *)attribLayout;
+
+    NVRenderBackendInputAssemblerGL *retval = QT3DS_NEW(m_Foundation.getAllocator(),
+                                                     NVRenderBackendInputAssemblerGL)(
+        m_Foundation, attribLayoutGL, buffers, indexBuffer, strides, offsets, patchVertexCount);
+
+    return (NVRenderBackend::NVRenderBackendInputAssemblerObject)retval;
+}
 
-    bool NVRenderBackendGLBase::compileSource(GLuint shaderID, NVConstDataRef<QT3DSI8> source,
-                                              eastl::string &errorMessage, bool binary)
-    {
-        GLint shaderSourceSize = static_cast<GLint>(source.size());
-        const char *shaderSourceData = (const char *)source.begin();
-        GLint shaderStatus = GL_TRUE;
+void NVRenderBackendGLBase::ReleaseInputAssembler(NVRenderBackendInputAssemblerObject iao)
+{
+    NVRenderBackendInputAssemblerGL *inputAssembler = (NVRenderBackendInputAssemblerGL *)iao;
+    NVDelete(m_Foundation.getAllocator(), inputAssembler);
+}
 
-        if (!binary) {
+bool NVRenderBackendGLBase::compileSource(GLuint shaderID, NVConstDataRef<QT3DSI8> source,
+                                          eastl::string &errorMessage, bool binary)
+{
+    GLint shaderSourceSize = static_cast<GLint>(source.size());
+    const char *shaderSourceData = (const char *)source.begin();
+    GLint shaderStatus = GL_TRUE;
 
-            GL_CALL_FUNCTION(glShaderSource(shaderID, 1, &shaderSourceData, &shaderSourceSize));
-            GL_CALL_FUNCTION(glCompileShader(shaderID));
+    if (!binary) {
 
-            GLint logLen;
-            GL_CALL_FUNCTION(glGetShaderiv(shaderID, GL_COMPILE_STATUS, &shaderStatus));
-            GL_CALL_FUNCTION(glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLen));
+        GL_CALL_FUNCTION(glShaderSource(shaderID, 1, &shaderSourceData, &shaderSourceSize));
+        GL_CALL_FUNCTION(glCompileShader(shaderID));
 
-            // Check if some log exists. We also write warnings here
-            // Should at least contain more than the null termination
-            if (logLen > 2) {
-                errorMessage.resize(logLen + 1);
+        GLint logLen;
+        GL_CALL_FUNCTION(glGetShaderiv(shaderID, GL_COMPILE_STATUS, &shaderStatus));
+        GL_CALL_FUNCTION(glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLen));
 
-                GLint lenWithoutNull;
-                GL_CALL_FUNCTION(glGetShaderInfoLog(shaderID, logLen, &lenWithoutNull,
-                                              (char *)errorMessage.c_str()));
-            }
-        } else {
-            GL_CALL_FUNCTION(glShaderBinary(1, &shaderID, GL_NVIDIA_PLATFORM_BINARY_NV, shaderSourceData,
-                           shaderSourceSize));
-            GLenum binaryError = m_glFunctions->glGetError();
-            if (binaryError != GL_NO_ERROR) {
-                shaderStatus = GL_FALSE;
-                qCCritical(GL_ERROR, GLConversion::processGLError(binaryError));
-            }
-        }
+        // Check if some log exists. We also write warnings here
+        // Should at least contain more than the null termination
+        if (logLen > 2) {
+            errorMessage.resize(logLen + 1);
 
-        return (shaderStatus == GL_TRUE);
+            GLint lenWithoutNull;
+            GL_CALL_FUNCTION(glGetShaderInfoLog(shaderID, logLen, &lenWithoutNull,
+                                          (char *)errorMessage.c_str()));
+        }
+    } else {
+        GL_CALL_FUNCTION(glShaderBinary(1, &shaderID, GL_NVIDIA_PLATFORM_BINARY_NV, shaderSourceData,
+                       shaderSourceSize));
+        GLenum binaryError = m_glFunctions->glGetError();
+        if (binaryError != GL_NO_ERROR) {
+            shaderStatus = GL_FALSE;
+            qCCritical(GL_ERROR, GLConversion::processGLError(binaryError));
+        }
     }
 
-    NVRenderBackend::NVRenderBackendVertexShaderObject
-    NVRenderBackendGLBase::CreateVertexShader(NVConstDataRef<QT3DSI8> source,
-                                              eastl::string &errorMessage, bool binary)
-    {
-        GLuint shaderID = GL_CALL_FUNCTION(glCreateShader(GL_VERTEX_SHADER));
+    return (shaderStatus == GL_TRUE);
+}
 
-        if (shaderID && !compileSource(shaderID, source, errorMessage, binary)) {
-            GL_CALL_FUNCTION(glDeleteShader(shaderID));
-            shaderID = 0;
-        }
+NVRenderBackend::NVRenderBackendVertexShaderObject
+NVRenderBackendGLBase::CreateVertexShader(NVConstDataRef<QT3DSI8> source,
+                                          eastl::string &errorMessage, bool binary)
+{
+    GLuint shaderID = GL_CALL_FUNCTION(glCreateShader(GL_VERTEX_SHADER));
 
-        return (NVRenderBackend::NVRenderBackendVertexShaderObject)shaderID;
+    if (shaderID && !compileSource(shaderID, source, errorMessage, binary)) {
+        GL_CALL_FUNCTION(glDeleteShader(shaderID));
+        shaderID = 0;
     }
 
-    NVRenderBackend::NVRenderBackendFragmentShaderObject
-    NVRenderBackendGLBase::CreateFragmentShader(NVConstDataRef<QT3DSI8> source,
-                                                eastl::string &errorMessage, bool binary)
-    {
-        GLuint shaderID = GL_CALL_FUNCTION(glCreateShader(GL_FRAGMENT_SHADER));
+    return (NVRenderBackend::NVRenderBackendVertexShaderObject)shaderID;
+}
 
-        if (shaderID && !compileSource(shaderID, source, errorMessage, binary)) {
-            GL_CALL_FUNCTION(glDeleteShader(shaderID));
-            shaderID = 0;
-        }
+NVRenderBackend::NVRenderBackendFragmentShaderObject
+NVRenderBackendGLBase::CreateFragmentShader(NVConstDataRef<QT3DSI8> source,
+                                            eastl::string &errorMessage, bool binary)
+{
+    GLuint shaderID = GL_CALL_FUNCTION(glCreateShader(GL_FRAGMENT_SHADER));
 
-        return (NVRenderBackend::NVRenderBackendFragmentShaderObject)shaderID;
+    if (shaderID && !compileSource(shaderID, source, errorMessage, binary)) {
+        GL_CALL_FUNCTION(glDeleteShader(shaderID));
+        shaderID = 0;
     }
 
-    NVRenderBackend::NVRenderBackendTessControlShaderObject
-    NVRenderBackendGLBase::CreateTessControlShader(NVConstDataRef<QT3DSI8> source,
-                                                   eastl::string &errorMessage, bool binary)
-    {
-        // needs GL 4 or GLES EXT_tessellation_shader support
-        NVRENDER_BACKEND_UNUSED(source);
-        NVRENDER_BACKEND_UNUSED(errorMessage);
-        NVRENDER_BACKEND_UNUSED(binary);
+    return (NVRenderBackend::NVRenderBackendFragmentShaderObject)shaderID;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderBackend::NVRenderBackendTessControlShaderObject
+NVRenderBackendGLBase::CreateTessControlShader(NVConstDataRef<QT3DSI8> source,
+                                               eastl::string &errorMessage, bool binary)
+{
+    // needs GL 4 or GLES EXT_tessellation_shader support
+    NVRENDER_BACKEND_UNUSED(source);
+    NVRENDER_BACKEND_UNUSED(errorMessage);
+    NVRENDER_BACKEND_UNUSED(binary);
 
-        return (NVRenderBackend::NVRenderBackendTessControlShaderObject)0;
-    }
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    NVRenderBackend::NVRenderBackendTessEvaluationShaderObject
-    NVRenderBackendGLBase::CreateTessEvaluationShader(NVConstDataRef<QT3DSI8> source,
-                                                      eastl::string &errorMessage, bool binary)
-    {
-        // needs GL 4 or GLES EXT_tessellation_shader support
-        NVRENDER_BACKEND_UNUSED(source);
-        NVRENDER_BACKEND_UNUSED(errorMessage);
-        NVRENDER_BACKEND_UNUSED(binary);
+    return (NVRenderBackend::NVRenderBackendTessControlShaderObject)0;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderBackend::NVRenderBackendTessEvaluationShaderObject
+NVRenderBackendGLBase::CreateTessEvaluationShader(NVConstDataRef<QT3DSI8> source,
+                                                  eastl::string &errorMessage, bool binary)
+{
+    // needs GL 4 or GLES EXT_tessellation_shader support
+    NVRENDER_BACKEND_UNUSED(source);
+    NVRENDER_BACKEND_UNUSED(errorMessage);
+    NVRENDER_BACKEND_UNUSED(binary);
 
-        return (NVRenderBackend::NVRenderBackendTessEvaluationShaderObject)0;
-    }
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    NVRenderBackend::NVRenderBackendGeometryShaderObject
-    NVRenderBackendGLBase::CreateGeometryShader(NVConstDataRef<QT3DSI8> source,
-                                                eastl::string &errorMessage, bool binary)
-    {
-        // needs GL 4 or GLES EXT_geometry_shader support
-        NVRENDER_BACKEND_UNUSED(source);
-        NVRENDER_BACKEND_UNUSED(errorMessage);
-        NVRENDER_BACKEND_UNUSED(binary);
+    return (NVRenderBackend::NVRenderBackendTessEvaluationShaderObject)0;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderBackend::NVRenderBackendGeometryShaderObject
+NVRenderBackendGLBase::CreateGeometryShader(NVConstDataRef<QT3DSI8> source,
+                                            eastl::string &errorMessage, bool binary)
+{
+    // needs GL 4 or GLES EXT_geometry_shader support
+    NVRENDER_BACKEND_UNUSED(source);
+    NVRENDER_BACKEND_UNUSED(errorMessage);
+    NVRENDER_BACKEND_UNUSED(binary);
 
-        return (NVRenderBackend::NVRenderBackendGeometryShaderObject)0;
-    }
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    NVRenderBackend::NVRenderBackendComputeShaderObject
-    NVRenderBackendGLBase::CreateComputeShader(NVConstDataRef<QT3DSI8> source,
-                                               eastl::string &errorMessage, bool binary)
-    {
-        // needs GL 4.3 or GLES3.1 support
-        NVRENDER_BACKEND_UNUSED(source);
-        NVRENDER_BACKEND_UNUSED(errorMessage);
-        NVRENDER_BACKEND_UNUSED(binary);
+    return (NVRenderBackend::NVRenderBackendGeometryShaderObject)0;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderBackend::NVRenderBackendComputeShaderObject
+NVRenderBackendGLBase::CreateComputeShader(NVConstDataRef<QT3DSI8> source,
+                                           eastl::string &errorMessage, bool binary)
+{
+    // needs GL 4.3 or GLES3.1 support
+    NVRENDER_BACKEND_UNUSED(source);
+    NVRENDER_BACKEND_UNUSED(errorMessage);
+    NVRENDER_BACKEND_UNUSED(binary);
 
-        return (NVRenderBackend::NVRenderBackendComputeShaderObject)0;
-    }
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-    void NVRenderBackendGLBase::ReleaseVertexShader(NVRenderBackendVertexShaderObject vso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
+    return (NVRenderBackend::NVRenderBackendComputeShaderObject)0;
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void NVRenderBackendGLBase::ReleaseVertexShader(NVRenderBackendVertexShaderObject vso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
 
-    void NVRenderBackendGLBase::ReleaseFragmentShader(NVRenderBackendFragmentShaderObject fso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void NVRenderBackendGLBase::ReleaseFragmentShader(NVRenderBackendFragmentShaderObject fso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
 
-    void
-    NVRenderBackendGLBase::ReleaseTessControlShader(NVRenderBackendTessControlShaderObject tcso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void
+NVRenderBackendGLBase::ReleaseTessControlShader(NVRenderBackendTessControlShaderObject tcso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
 
-    void NVRenderBackendGLBase::ReleaseTessEvaluationShader(
-        NVRenderBackendTessEvaluationShaderObject teso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void NVRenderBackendGLBase::ReleaseTessEvaluationShader(
+    NVRenderBackendTessEvaluationShaderObject teso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
 
-    void NVRenderBackendGLBase::ReleaseGeometryShader(NVRenderBackendGeometryShaderObject gso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void NVRenderBackendGLBase::ReleaseGeometryShader(NVRenderBackendGeometryShaderObject gso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
 
-    void NVRenderBackendGLBase::ReleaseComputeShader(NVRenderBackendComputeShaderObject cso)
-    {
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glDeleteShader(shaderID));
-    }
+void NVRenderBackendGLBase::ReleaseComputeShader(NVRenderBackendComputeShaderObject cso)
+{
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendVertexShaderObject vso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
+    GL_CALL_FUNCTION(glDeleteShader(shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendVertexShaderObject vso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendFragmentShaderObject fso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendFragmentShaderObject fso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendTessControlShaderObject tcso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendTessControlShaderObject tcso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendTessEvaluationShaderObject teso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendTessEvaluationShaderObject teso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendGeometryShaderObject gso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendGeometryShaderObject gso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
 
-    void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendComputeShaderObject cso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::AttachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendComputeShaderObject cso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendVertexShaderObject vso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
+    GL_CALL_FUNCTION(glAttachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendVertexShaderObject vso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, vso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendFragmentShaderObject fso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendFragmentShaderObject fso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, fso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendTessControlShaderObject tcso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendTessControlShaderObject tcso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, tcso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendTessEvaluationShaderObject teso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendTessEvaluationShaderObject teso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, teso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendGeometryShaderObject gso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendGeometryShaderObject gso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, gso);
 
-    void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
-                                             NVRenderBackendComputeShaderObject cso)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
-    }
+void NVRenderBackendGLBase::DetachShader(NVRenderBackendShaderProgramObject po,
+                                         NVRenderBackendComputeShaderObject cso)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint shaderID = HandleToID_cast(GLuint, size_t, cso);
 
-    NVRenderBackend::NVRenderBackendShaderProgramObject
-    NVRenderBackendGLBase::CreateShaderProgram(bool isSeparable)
-    {
-        NVRenderBackendShaderProgramGL *theProgram = NULL;
-        GLuint programID = GL_CALL_FUNCTION(glCreateProgram());
+    GL_CALL_FUNCTION(glDetachShader(static_cast<GLuint>(pProgram->m_ProgramID), shaderID));
+}
 
-        if (programID) {
-            theProgram =
-                QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendShaderProgramGL)(programID);
+NVRenderBackend::NVRenderBackendShaderProgramObject
+NVRenderBackendGLBase::CreateShaderProgram(bool isSeparable)
+{
+    NVRenderBackendShaderProgramGL *theProgram = nullptr;
+    GLuint programID = GL_CALL_FUNCTION(glCreateProgram());
 
-            if (!theProgram) {
-                GL_CALL_FUNCTION(glDeleteProgram(programID));
-            } else if (isSeparable && m_backendSupport.caps.bits.bProgramPipelineSupported) {
-                GL_CALL_EXTRA_FUNCTION(glProgramParameteri(programID, GL_PROGRAM_SEPARABLE, GL_TRUE));
-            }
+    if (programID) {
+        theProgram =
+            QT3DS_NEW(m_Foundation.getAllocator(), NVRenderBackendShaderProgramGL)(programID);
+
+        if (!theProgram) {
+            GL_CALL_FUNCTION(glDeleteProgram(programID));
+        } else if (isSeparable && m_backendSupport.caps.bits.bProgramPipelineSupported) {
+            GL_CALL_EXTRA_FUNCTION(glProgramParameteri(programID, GL_PROGRAM_SEPARABLE, GL_TRUE));
         }
+    }
 
-        return (NVRenderBackend::NVRenderBackendShaderProgramObject)theProgram;
+    return (NVRenderBackend::NVRenderBackendShaderProgramObject)theProgram;
+}
+
+void NVRenderBackendGLBase::ReleaseShaderProgram(NVRenderBackendShaderProgramObject po)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+
+    GL_CALL_FUNCTION(glDeleteProgram(programID));
+
+    if (pProgram->m_shaderInput) {
+        NVDelete(m_Foundation.getAllocator(), pProgram->m_shaderInput);
+        pProgram->m_shaderInput = nullptr;
     }
 
-    void NVRenderBackendGLBase::ReleaseShaderProgram(NVRenderBackendShaderProgramObject po)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+    NVDelete(m_Foundation.getAllocator(), pProgram);
+}
+
+bool NVRenderBackendGLBase::LinkProgram(NVRenderBackendShaderProgramObject po,
+                                        eastl::string &errorMessage)
+{
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+
+    GL_CALL_FUNCTION(glLinkProgram(programID));
 
-        GL_CALL_FUNCTION(glDeleteProgram(programID));
+    GLint linkStatus, logLen;
+    GL_CALL_FUNCTION(glGetProgramiv(programID, GL_LINK_STATUS, &linkStatus));
+    GL_CALL_FUNCTION(glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLen));
 
+    // if successfully linked get the attribute information
+    if (linkStatus) {
+        // release old stuff
         if (pProgram->m_shaderInput) {
             NVDelete(m_Foundation.getAllocator(), pProgram->m_shaderInput);
-            pProgram->m_shaderInput = NULL;
+            pProgram->m_shaderInput = nullptr;
         }
 
-        NVDelete(m_Foundation.getAllocator(), pProgram);
-    }
+        GLint numAttribs;
+        GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_ATTRIBUTES, &numAttribs));
 
-    bool NVRenderBackendGLBase::LinkProgram(NVRenderBackendShaderProgramObject po,
-                                            eastl::string &errorMessage)
-    {
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+        if (numAttribs) {
+            NVRenderBackendShaderInputEntryGL *tempShaderInputEntry =
+                (NVRenderBackendShaderInputEntryGL *)QT3DS_ALLOC(
+                    m_Foundation.getAllocator(),
+                    sizeof(NVRenderBackendShaderInputEntryGL) * m_MaxAttribCount,
+                    "BackendShaderInputEntryGL");
 
-        GL_CALL_FUNCTION(glLinkProgram(programID));
+            GLint maxLength;
+            GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength));
+            QT3DSI8 *nameBuf =
+                (QT3DSI8 *)QT3DS_ALLOC(m_Foundation.getAllocator(), maxLength, "LinkProgram");
 
-        GLint linkStatus, logLen;
-        GL_CALL_FUNCTION(glGetProgramiv(programID, GL_LINK_STATUS, &linkStatus));
-        GL_CALL_FUNCTION(glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLen));
-
-        // if succesfuly linked get the attribute information
-        if (linkStatus) {
-            // release old stuff
-            if (pProgram->m_shaderInput) {
-                NVDelete(m_Foundation.getAllocator(), pProgram->m_shaderInput);
-                pProgram->m_shaderInput = NULL;
+            // fill in data
+            QT3DSU32 count = 0;
+            QT3DS_FOREACH(idx, numAttribs)
+            {
+                GLint size = 0;
+                GLenum glType;
+                NVRenderComponentTypes::Enum compType = NVRenderComponentTypes::Unknown;
+                QT3DSU32 numComps = 0;
+
+                GL_CALL_FUNCTION(glGetActiveAttrib(programID, idx, maxLength, nullptr, &size,
+                                                   &glType, (char *)nameBuf));
+                // Skip anything named with gl_
+                if (memcmp(nameBuf, "gl_", 3) == 0)
+                    continue;
+
+                m_Conversion.fromAttribGLToComponentTypeAndNumComps(glType, compType, numComps);
+
+                tempShaderInputEntry[count].m_AttribName =
+                    m_StringTable->RegisterStr((char *)nameBuf);
+                tempShaderInputEntry[count].m_AttribLocation =
+                    GL_CALL_FUNCTION(glGetAttribLocation(programID, (char *)nameBuf));
+                tempShaderInputEntry[count].m_Type = glType;
+                tempShaderInputEntry[count].m_NumComponents = numComps;
+
+                ++count;
             }
 
-            GLint numAttribs;
-            GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_ATTRIBUTES, &numAttribs));
-
-            if (numAttribs) {
-                NVRenderBackendShaderInputEntryGL *tempShaderInputEntry =
-                    (NVRenderBackendShaderInputEntryGL *)QT3DS_ALLOC(
-                        m_Foundation.getAllocator(),
-                        sizeof(NVRenderBackendShaderInputEntryGL) * m_MaxAttribCount,
-                        "BackendShaderInputEntryGL");
-
-                GLint maxLength;
-                GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength));
-                QT3DSI8 *nameBuf =
-                    (QT3DSI8 *)QT3DS_ALLOC(m_Foundation.getAllocator(), maxLength, "LinkProgram");
-
-                // fill in data
-                QT3DSU32 count = 0;
-                QT3DS_FOREACH(idx, numAttribs)
-                {
-                    GLint size = 0;
-                    GLenum glType;
-                    NVRenderComponentTypes::Enum compType = NVRenderComponentTypes::Unknown;
-                    QT3DSU32 numComps = 0;
-
-                    GL_CALL_FUNCTION(glGetActiveAttrib(programID, idx, maxLength, NULL, &size, &glType,
-                                                 (char *)nameBuf));
-                    // Skip anything named with gl_
-                    if (memcmp(nameBuf, "gl_", 3) == 0)
-                        continue;
-
-                    m_Conversion.fromAttribGLToComponentTypeAndNumComps(glType, compType, numComps);
-
-                    tempShaderInputEntry[count].m_AttribName =
-                        m_StringTable->RegisterStr((char *)nameBuf);
-                    tempShaderInputEntry[count].m_AttribLocation =
-                        GL_CALL_FUNCTION(glGetAttribLocation(programID, (char *)nameBuf));
-                    tempShaderInputEntry[count].m_Type = glType;
-                    tempShaderInputEntry[count].m_NumComponents = numComps;
-
-                    ++count;
-                }
-
-                // Now allocate space for the actuall entries
-                QT3DSU32 shaderInputSize = sizeof(NVRenderBackendShaderInputGL);
-                QT3DSU32 entrySize = sizeof(NVRenderBackendShaderInputEntryGL) * count;
-                QT3DSU8 *newMem =
-                    (QT3DSU8 *)QT3DS_ALLOC(m_Foundation.getAllocator(), shaderInputSize + entrySize,
-                                     "BackendShaderInputEntryGL");
-                NVDataRef<NVRenderBackendShaderInputEntryGL> entryRef =
-                    PtrAtOffset<NVRenderBackendShaderInputEntryGL>(newMem, shaderInputSize,
-                                                                   entrySize);
-                // fill data
-                QT3DS_FOREACH(idx, count)
-                {
-                    entryRef[idx].m_AttribName = tempShaderInputEntry[idx].m_AttribName;
-                    entryRef[idx].m_AttribLocation = tempShaderInputEntry[idx].m_AttribLocation;
-                    entryRef[idx].m_Type = tempShaderInputEntry[idx].m_Type;
-                    entryRef[idx].m_NumComponents = tempShaderInputEntry[idx].m_NumComponents;
-                }
-
-                // placement new
-                NVRenderBackendShaderInputGL *shaderInput =
-                    new (newMem) NVRenderBackendShaderInputGL(entryRef);
-                // set the pointer
-                pProgram->m_shaderInput = shaderInput;
-
-                QT3DS_FREE(m_Foundation.getAllocator(), nameBuf);
-                QT3DS_FREE(m_Foundation.getAllocator(), tempShaderInputEntry);
+            // Now allocate space for the actuall entries
+            QT3DSU32 shaderInputSize = sizeof(NVRenderBackendShaderInputGL);
+            QT3DSU32 entrySize = sizeof(NVRenderBackendShaderInputEntryGL) * count;
+            QT3DSU8 *newMem =
+                (QT3DSU8 *)QT3DS_ALLOC(m_Foundation.getAllocator(), shaderInputSize + entrySize,
+                                 "BackendShaderInputEntryGL");
+            NVDataRef<NVRenderBackendShaderInputEntryGL> entryRef =
+                PtrAtOffset<NVRenderBackendShaderInputEntryGL>(newMem, shaderInputSize,
+                                                               entrySize);
+            // fill data
+            QT3DS_FOREACH(idx, count)
+            {
+                entryRef[idx].m_AttribName = tempShaderInputEntry[idx].m_AttribName;
+                entryRef[idx].m_AttribLocation = tempShaderInputEntry[idx].m_AttribLocation;
+                entryRef[idx].m_Type = tempShaderInputEntry[idx].m_Type;
+                entryRef[idx].m_NumComponents = tempShaderInputEntry[idx].m_NumComponents;
             }
-        }
 
-        // Check if some log exists. We also write warnings here
-        // Should at least contain more than the null termination
-        if (logLen > 2) {
-            errorMessage.resize(logLen + 1);
+            // placement new
+            NVRenderBackendShaderInputGL *shaderInput =
+                new (newMem) NVRenderBackendShaderInputGL(entryRef);
+            // set the pointer
+            pProgram->m_shaderInput = shaderInput;
 
-            GLint lenWithoutNull;
-            GL_CALL_FUNCTION(glGetProgramInfoLog(programID, logLen, &lenWithoutNull,
-                                           (char *)errorMessage.c_str()));
+            QT3DS_FREE(m_Foundation.getAllocator(), nameBuf);
+            QT3DS_FREE(m_Foundation.getAllocator(), tempShaderInputEntry);
         }
+    }
+
+    // Check if some log exists. We also write warnings here
+    // Should at least contain more than the null termination
+    if (logLen > 2) {
+        errorMessage.resize(logLen + 1);
 
-        return (linkStatus == GL_TRUE);
+        GLint lenWithoutNull;
+        GL_CALL_FUNCTION(glGetProgramInfoLog(programID, logLen, &lenWithoutNull,
+                                       (char *)errorMessage.c_str()));
     }
 
-    void NVRenderBackendGLBase::SetActiveProgram(NVRenderBackendShaderProgramObject po)
-    {
-        GLuint programID = 0;
+    return (linkStatus == GL_TRUE);
+}
 
-        if (po) {
-            NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-            programID = static_cast<GLuint>(pProgram->m_ProgramID);
-        }
+void NVRenderBackendGLBase::SetActiveProgram(NVRenderBackendShaderProgramObject po)
+{
+    GLuint programID = 0;
 
-        GL_CALL_FUNCTION(glUseProgram(programID));
+    if (po) {
+        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+        programID = static_cast<GLuint>(pProgram->m_ProgramID);
     }
 
-    NVRenderBackend::NVRenderBackendProgramPipeline NVRenderBackendGLBase::CreateProgramPipeline()
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-        return NVRenderBackend::NVRenderBackendProgramPipeline(0);
-    }
+    GL_CALL_FUNCTION(glUseProgram(programID));
+}
 
-    void NVRenderBackendGLBase::ReleaseProgramPipeline(NVRenderBackendProgramPipeline)
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+NVRenderBackend::NVRenderBackendProgramPipeline NVRenderBackendGLBase::CreateProgramPipeline()
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+    return NVRenderBackend::NVRenderBackendProgramPipeline(0);
+}
 
-    void NVRenderBackendGLBase::SetActiveProgramPipeline(NVRenderBackendProgramPipeline)
-    {
-        // needs GL 4 context
-        //TODO: should be fixed?
-        //        QT3DS_ASSERT(false);
-    }
+void NVRenderBackendGLBase::ReleaseProgramPipeline(NVRenderBackendProgramPipeline)
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::SetProgramStages(NVRenderBackendProgramPipeline,
-                                                 NVRenderShaderTypeFlags,
-                                                 NVRenderBackendShaderProgramObject)
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::SetActiveProgramPipeline(NVRenderBackendProgramPipeline)
+{
+    // needs GL 4 context
+    //TODO: should be fixed?
+    //        QT3DS_ASSERT(false);
+}
 
-    void NVRenderBackendGLBase::DispatchCompute(NVRenderBackendShaderProgramObject, QT3DSU32, QT3DSU32,
-                                                QT3DSU32)
-    {
-        // needs GL 4 context
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::SetProgramStages(NVRenderBackendProgramPipeline,
+                                             NVRenderShaderTypeFlags,
+                                             NVRenderBackendShaderProgramObject)
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    QT3DSI32 NVRenderBackendGLBase::GetConstantCount(NVRenderBackendShaderProgramObject po)
-    {
-        QT3DS_ASSERT(po);
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+void NVRenderBackendGLBase::DispatchCompute(NVRenderBackendShaderProgramObject, QT3DSU32, QT3DSU32,
+                                            QT3DSU32)
+{
+    // needs GL 4 context
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        GLint numUniforms;
-        GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_UNIFORMS, &numUniforms));
+QT3DSI32 NVRenderBackendGLBase::GetConstantCount(NVRenderBackendShaderProgramObject po)
+{
+    QT3DS_ASSERT(po);
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
 
-        return numUniforms;
-    }
+    GLint numUniforms;
+    GL_CALL_FUNCTION(glGetProgramiv(programID, GL_ACTIVE_UNIFORMS, &numUniforms));
 
-    QT3DSI32 NVRenderBackendGLBase::GetConstantBufferCount(NVRenderBackendShaderProgramObject po)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(po);
+    return numUniforms;
+}
 
-        return 0;
-    }
+QT3DSI32 NVRenderBackendGLBase::GetConstantBufferCount(NVRenderBackendShaderProgramObject po)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(po);
 
-    QT3DSI32
-    NVRenderBackendGLBase::GetConstantInfoByID(NVRenderBackendShaderProgramObject po, QT3DSU32 id,
-                                               QT3DSU32 bufSize, QT3DSI32 *numElem,
-                                               NVRenderShaderDataTypes::Enum *type, QT3DSI32 *binding,
-                                               char *nameBuf)
-    {
-        QT3DS_ASSERT(po);
-        NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
-        GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
+    return 0;
+}
 
-        GLenum glType;
-        GL_CALL_FUNCTION(glGetActiveUniform(programID, id, bufSize, NULL, numElem, &glType, nameBuf));
-        *type = m_Conversion.fromShaderGLToPropertyDataTypes(glType);
+QT3DSI32
+NVRenderBackendGLBase::GetConstantInfoByID(NVRenderBackendShaderProgramObject po, QT3DSU32 id,
+                                           QT3DSU32 bufSize, QT3DSI32 *numElem,
+                                           NVRenderShaderDataTypes::Enum *type, QT3DSI32 *binding,
+                                           char *nameBuf)
+{
+    QT3DS_ASSERT(po);
+    NVRenderBackendShaderProgramGL *pProgram = (NVRenderBackendShaderProgramGL *)po;
+    GLuint programID = static_cast<GLuint>(pProgram->m_ProgramID);
 
-        QT3DSI32 uniformLoc = GL_CALL_FUNCTION(glGetUniformLocation(programID, nameBuf));
+    GLenum glType;
+    GL_CALL_FUNCTION(glGetActiveUniform(programID, id, bufSize, nullptr, numElem, &glType, nameBuf));
+    *type = m_Conversion.fromShaderGLToPropertyDataTypes(glType);
 
-        // get unit binding point
-        *binding = -1;
-        if (uniformLoc != -1 && (glType == GL_IMAGE_2D || glType == GL_UNSIGNED_INT_IMAGE_2D
-                                 || glType == GL_UNSIGNED_INT_ATOMIC_COUNTER)) {
-            GL_CALL_FUNCTION(glGetUniformiv(programID, uniformLoc, binding));
-        }
+    QT3DSI32 uniformLoc = GL_CALL_FUNCTION(glGetUniformLocation(programID, nameBuf));
 
-        return uniformLoc;
+    // get unit binding point
+    *binding = -1;
+    if (uniformLoc != -1 && (glType == GL_IMAGE_2D || glType == GL_UNSIGNED_INT_IMAGE_2D
+                             || glType == GL_UNSIGNED_INT_ATOMIC_COUNTER)) {
+        GL_CALL_FUNCTION(glGetUniformiv(programID, uniformLoc, binding));
     }
 
-    QT3DSI32
-    NVRenderBackendGLBase::GetConstantBufferInfoByID(NVRenderBackendShaderProgramObject po,
-                                                     QT3DSU32 id, QT3DSU32 nameBufSize, QT3DSI32 *paramCount,
-                                                     QT3DSI32 *bufferSize, QT3DSI32 *length,
-                                                     char *nameBuf)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(id);
-        NVRENDER_BACKEND_UNUSED(nameBufSize);
-        NVRENDER_BACKEND_UNUSED(paramCount);
-        NVRENDER_BACKEND_UNUSED(bufferSize);
-        NVRENDER_BACKEND_UNUSED(length);
-        NVRENDER_BACKEND_UNUSED(nameBuf);
-
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-
-        return -1;
-    }
+    return uniformLoc;
+}
 
-    void NVRenderBackendGLBase::GetConstantBufferParamIndices(NVRenderBackendShaderProgramObject po,
-                                                              QT3DSU32 id, QT3DSI32 *indices)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(id);
-        NVRENDER_BACKEND_UNUSED(indices);
+QT3DSI32
+NVRenderBackendGLBase::GetConstantBufferInfoByID(NVRenderBackendShaderProgramObject po,
+                                                 QT3DSU32 id, QT3DSU32 nameBufSize,
+                                                 QT3DSI32 *paramCount,
+                                                 QT3DSI32 *bufferSize, QT3DSI32 *length,
+                                                 char *nameBuf)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(id);
+    NVRENDER_BACKEND_UNUSED(nameBufSize);
+    NVRENDER_BACKEND_UNUSED(paramCount);
+    NVRENDER_BACKEND_UNUSED(bufferSize);
+    NVRENDER_BACKEND_UNUSED(length);
+    NVRENDER_BACKEND_UNUSED(nameBuf);
+
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+
+    return -1;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::GetConstantBufferParamIndices(NVRenderBackendShaderProgramObject po,
+                                                          QT3DSU32 id, QT3DSI32 *indices)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(id);
+    NVRENDER_BACKEND_UNUSED(indices);
 
-    void NVRenderBackendGLBase::GetConstantBufferParamInfoByIndices(
-        NVRenderBackendShaderProgramObject po, QT3DSU32 count, QT3DSU32 *indices, QT3DSI32 *type,
-        QT3DSI32 *size, QT3DSI32 *offset)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(count);
-        NVRENDER_BACKEND_UNUSED(indices);
-        NVRENDER_BACKEND_UNUSED(type);
-        NVRENDER_BACKEND_UNUSED(size);
-        NVRENDER_BACKEND_UNUSED(offset);
-
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::ProgramSetConstantBlock(NVRenderBackendShaderProgramObject po,
-                                                        QT3DSU32 blockIndex, QT3DSU32 binding)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(blockIndex);
-        NVRENDER_BACKEND_UNUSED(binding);
+void NVRenderBackendGLBase::GetConstantBufferParamInfoByIndices(
+    NVRenderBackendShaderProgramObject po, QT3DSU32 count, QT3DSU32 *indices, QT3DSI32 *type,
+    QT3DSI32 *size, QT3DSI32 *offset)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(count);
+    NVRENDER_BACKEND_UNUSED(indices);
+    NVRENDER_BACKEND_UNUSED(type);
+    NVRENDER_BACKEND_UNUSED(size);
+    NVRENDER_BACKEND_UNUSED(offset);
+
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::ProgramSetConstantBlock(NVRenderBackendShaderProgramObject po,
+                                                    QT3DSU32 blockIndex, QT3DSU32 binding)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(blockIndex);
+    NVRENDER_BACKEND_UNUSED(binding);
 
-    void NVRenderBackendGLBase::ProgramSetConstantBuffer(QT3DSU32 index,
-                                                         NVRenderBackendBufferObject bo)
-    {
-        // needs GL3 and above
-        NVRENDER_BACKEND_UNUSED(index);
-        NVRENDER_BACKEND_UNUSED(bo);
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::ProgramSetConstantBuffer(QT3DSU32 index,
+                                                     NVRenderBackendBufferObject bo)
+{
+    // needs GL3 and above
+    NVRENDER_BACKEND_UNUSED(index);
+    NVRENDER_BACKEND_UNUSED(bo);
 
-    QT3DSI32 NVRenderBackendGLBase::GetStorageBufferCount(NVRenderBackendShaderProgramObject po)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(po);
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-        return 0;
-    }
+QT3DSI32 NVRenderBackendGLBase::GetStorageBufferCount(NVRenderBackendShaderProgramObject po)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(po);
 
-    QT3DSI32
-    NVRenderBackendGLBase::GetStorageBufferInfoByID(NVRenderBackendShaderProgramObject po, QT3DSU32 id,
-                                                    QT3DSU32 nameBufSize, QT3DSI32 *paramCount,
-                                                    QT3DSI32 *bufferSize, QT3DSI32 *length, char *nameBuf)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(id);
-        NVRENDER_BACKEND_UNUSED(nameBufSize);
-        NVRENDER_BACKEND_UNUSED(paramCount);
-        NVRENDER_BACKEND_UNUSED(bufferSize);
-        NVRENDER_BACKEND_UNUSED(length);
-        NVRENDER_BACKEND_UNUSED(nameBuf);
-
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-
-        return -1;
-    }
+    return 0;
+}
 
-    void NVRenderBackendGLBase::ProgramSetStorageBuffer(QT3DSU32 index, NVRenderBackendBufferObject bo)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(index);
-        NVRENDER_BACKEND_UNUSED(bo);
-    }
+QT3DSI32
+NVRenderBackendGLBase::GetStorageBufferInfoByID(NVRenderBackendShaderProgramObject po, QT3DSU32 id,
+                                                QT3DSU32 nameBufSize, QT3DSI32 *paramCount,
+                                                QT3DSI32 *bufferSize, QT3DSI32 *length, char *nameBuf)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(id);
+    NVRENDER_BACKEND_UNUSED(nameBufSize);
+    NVRENDER_BACKEND_UNUSED(paramCount);
+    NVRENDER_BACKEND_UNUSED(bufferSize);
+    NVRENDER_BACKEND_UNUSED(length);
+    NVRENDER_BACKEND_UNUSED(nameBuf);
+
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+
+    return -1;
+}
 
-    QT3DSI32 NVRenderBackendGLBase::GetAtomicCounterBufferCount(NVRenderBackendShaderProgramObject po)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(po);
+void NVRenderBackendGLBase::ProgramSetStorageBuffer(QT3DSU32 index, NVRenderBackendBufferObject bo)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(index);
+    NVRENDER_BACKEND_UNUSED(bo);
+}
 
-        return 0;
-    }
+QT3DSI32 NVRenderBackendGLBase::GetAtomicCounterBufferCount(NVRenderBackendShaderProgramObject po)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(po);
 
-    QT3DSI32
-    NVRenderBackendGLBase::GetAtomicCounterBufferInfoByID(NVRenderBackendShaderProgramObject po,
-                                                          QT3DSU32 id, QT3DSU32 nameBufSize,
-                                                          QT3DSI32 *paramCount, QT3DSI32 *bufferSize,
-                                                          QT3DSI32 *length, char *nameBuf)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(po);
-        NVRENDER_BACKEND_UNUSED(id);
-        NVRENDER_BACKEND_UNUSED(nameBufSize);
-        NVRENDER_BACKEND_UNUSED(paramCount);
-        NVRENDER_BACKEND_UNUSED(bufferSize);
-        NVRENDER_BACKEND_UNUSED(length);
-        NVRENDER_BACKEND_UNUSED(nameBuf);
-
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-
-        return -1;
-    }
+    return 0;
+}
 
-    void NVRenderBackendGLBase::ProgramSetAtomicCounterBuffer(QT3DSU32 index,
-                                                              NVRenderBackendBufferObject bo)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(index);
-        NVRENDER_BACKEND_UNUSED(bo);
-    }
+QT3DSI32
+NVRenderBackendGLBase::GetAtomicCounterBufferInfoByID(NVRenderBackendShaderProgramObject po,
+                                                      QT3DSU32 id, QT3DSU32 nameBufSize,
+                                                      QT3DSI32 *paramCount, QT3DSI32 *bufferSize,
+                                                      QT3DSI32 *length, char *nameBuf)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(po);
+    NVRENDER_BACKEND_UNUSED(id);
+    NVRENDER_BACKEND_UNUSED(nameBufSize);
+    NVRENDER_BACKEND_UNUSED(paramCount);
+    NVRENDER_BACKEND_UNUSED(bufferSize);
+    NVRENDER_BACKEND_UNUSED(length);
+    NVRENDER_BACKEND_UNUSED(nameBuf);
+
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+
+    return -1;
+}
 
-    void NVRenderBackendGLBase::SetConstantValue(NVRenderBackendShaderProgramObject, QT3DSU32 id,
-                                                 NVRenderShaderDataTypes::Enum type, QT3DSI32 count,
-                                                 const void *value, bool transpose)
-    {
-        GLenum glType = m_Conversion.fromPropertyDataTypesToShaderGL(type);
-
-        switch (glType) {
-        case GL_FLOAT:
-            GL_CALL_FUNCTION(glUniform1fv(id, count, (GLfloat *)value));
-            break;
-        case GL_FLOAT_VEC2:
-            GL_CALL_FUNCTION(glUniform2fv(id, count, (GLfloat *)value));
-            break;
-        case GL_FLOAT_VEC3:
-            GL_CALL_FUNCTION(glUniform3fv(id, count, (GLfloat *)value));
-            break;
-        case GL_FLOAT_VEC4:
-            GL_CALL_FUNCTION(glUniform4fv(id, count, (GLfloat *)value));
-            break;
-        case GL_INT:
-            GL_CALL_FUNCTION(glUniform1iv(id, count, (GLint *)value));
-            break;
-        case GL_BOOL:
-            {
-                GLint boolValue = *(GLboolean *)value;
-                GL_CALL_FUNCTION(glUniform1iv(id, count, &boolValue));
-            }
-            break;
-        case GL_INT_VEC2:
-        case GL_BOOL_VEC2:
-            GL_CALL_FUNCTION(glUniform2iv(id, count, (GLint *)value));
-            break;
-        case GL_INT_VEC3:
-        case GL_BOOL_VEC3:
-            GL_CALL_FUNCTION(glUniform3iv(id, count, (GLint *)value));
-            break;
-        case GL_INT_VEC4:
-        case GL_BOOL_VEC4:
-            GL_CALL_FUNCTION(glUniform4iv(id, count, (GLint *)value));
-            break;
-        case GL_FLOAT_MAT3:
-            GL_CALL_FUNCTION(glUniformMatrix3fv(id, count, transpose, (GLfloat *)value));
-            break;
-        case GL_FLOAT_MAT4:
-            GL_CALL_FUNCTION(glUniformMatrix4fv(id, count, transpose, (GLfloat *)value));
-            break;
-        case GL_IMAGE_2D:
-        case GL_SAMPLER_2D:
-        case GL_SAMPLER_2D_ARRAY:
-        case GL_SAMPLER_2D_SHADOW:
-        case GL_SAMPLER_CUBE: {
-            if (count > 1) {
-                GLint *sampler = (GLint *)value;
-                GL_CALL_FUNCTION(glUniform1iv(id, count, sampler));
-            } else {
-                GLint sampler = *(GLint *)value;
-                GL_CALL_FUNCTION(glUniform1i(id, sampler));
-            }
-        } break;
-        default:
-            qCCritical(INTERNAL_ERROR, "Unknown shader type format %d", type);
-            QT3DS_ASSERT(false);
-            break;
+void NVRenderBackendGLBase::ProgramSetAtomicCounterBuffer(QT3DSU32 index,
+                                                          NVRenderBackendBufferObject bo)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(index);
+    NVRENDER_BACKEND_UNUSED(bo);
+}
+
+void NVRenderBackendGLBase::SetConstantValue(NVRenderBackendShaderProgramObject, QT3DSU32 id,
+                                             NVRenderShaderDataTypes::Enum type, QT3DSI32 count,
+                                             const void *value, bool transpose)
+{
+    GLenum glType = m_Conversion.fromPropertyDataTypesToShaderGL(type);
+
+    switch (glType) {
+    case GL_FLOAT:
+        GL_CALL_FUNCTION(glUniform1fv(id, count, (GLfloat *)value));
+        break;
+    case GL_FLOAT_VEC2:
+        GL_CALL_FUNCTION(glUniform2fv(id, count, (GLfloat *)value));
+        break;
+    case GL_FLOAT_VEC3:
+        GL_CALL_FUNCTION(glUniform3fv(id, count, (GLfloat *)value));
+        break;
+    case GL_FLOAT_VEC4:
+        GL_CALL_FUNCTION(glUniform4fv(id, count, (GLfloat *)value));
+        break;
+    case GL_INT:
+        GL_CALL_FUNCTION(glUniform1iv(id, count, (GLint *)value));
+        break;
+    case GL_BOOL:
+        {
+            GLint boolValue = *(GLboolean *)value;
+            GL_CALL_FUNCTION(glUniform1iv(id, count, &boolValue));
         }
+        break;
+    case GL_INT_VEC2:
+    case GL_BOOL_VEC2:
+        GL_CALL_FUNCTION(glUniform2iv(id, count, (GLint *)value));
+        break;
+    case GL_INT_VEC3:
+    case GL_BOOL_VEC3:
+        GL_CALL_FUNCTION(glUniform3iv(id, count, (GLint *)value));
+        break;
+    case GL_INT_VEC4:
+    case GL_BOOL_VEC4:
+        GL_CALL_FUNCTION(glUniform4iv(id, count, (GLint *)value));
+        break;
+    case GL_FLOAT_MAT3:
+        GL_CALL_FUNCTION(glUniformMatrix3fv(id, count, transpose, (GLfloat *)value));
+        break;
+    case GL_FLOAT_MAT4:
+        GL_CALL_FUNCTION(glUniformMatrix4fv(id, count, transpose, (GLfloat *)value));
+        break;
+    case GL_IMAGE_2D:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_ARRAY:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_CUBE: {
+        if (count > 1) {
+            GLint *sampler = (GLint *)value;
+            GL_CALL_FUNCTION(glUniform1iv(id, count, sampler));
+        } else {
+            GLint sampler = *(GLint *)value;
+            GL_CALL_FUNCTION(glUniform1i(id, sampler));
+        }
+    } break;
+    default:
+        qCCritical(INTERNAL_ERROR, "Unknown shader type format %d", type);
+        QT3DS_ASSERT(false);
+        break;
     }
+}
 
-    void NVRenderBackendGLBase::Draw(NVRenderDrawMode::Enum drawMode, QT3DSU32 start, QT3DSU32 count)
-    {
-        GL_CALL_FUNCTION(glDrawArrays(m_Conversion.fromDrawModeToGL(
-                                    drawMode, m_backendSupport.caps.bits.bTessellationSupported),
-                                start, count));
-    }
+void NVRenderBackendGLBase::Draw(NVRenderDrawMode::Enum drawMode, QT3DSU32 start, QT3DSU32 count)
+{
+    GL_CALL_FUNCTION(glDrawArrays(m_Conversion.fromDrawModeToGL(
+                                drawMode, m_backendSupport.caps.bits.bTessellationSupported),
+                            start, count));
+}
 
-    void NVRenderBackendGLBase::DrawIndirect(NVRenderDrawMode::Enum drawMode, const void *indirect)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(drawMode);
-        NVRENDER_BACKEND_UNUSED(indirect);
-    }
+void NVRenderBackendGLBase::DrawIndirect(NVRenderDrawMode::Enum drawMode, const void *indirect)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(drawMode);
+    NVRENDER_BACKEND_UNUSED(indirect);
+}
 
-    void NVRenderBackendGLBase::DrawIndexed(NVRenderDrawMode::Enum drawMode, QT3DSU32 count,
-                                            NVRenderComponentTypes::Enum type, const void *indices)
-    {
-        GL_CALL_FUNCTION(glDrawElements(m_Conversion.fromDrawModeToGL(
-                                      drawMode, m_backendSupport.caps.bits.bTessellationSupported),
-                                  count, m_Conversion.fromIndexBufferComponentsTypesToGL(type),
-                                  indices));
-    }
+void NVRenderBackendGLBase::DrawIndexed(NVRenderDrawMode::Enum drawMode, QT3DSU32 count,
+                                        NVRenderComponentTypes::Enum type, const void *indices)
+{
+    GL_CALL_FUNCTION(glDrawElements(m_Conversion.fromDrawModeToGL(
+                                  drawMode, m_backendSupport.caps.bits.bTessellationSupported),
+                              count, m_Conversion.fromIndexBufferComponentsTypesToGL(type),
+                              indices));
+}
 
-    void NVRenderBackendGLBase::DrawIndexedIndirect(NVRenderDrawMode::Enum drawMode,
-                                                    NVRenderComponentTypes::Enum type,
-                                                    const void *indirect)
-    {
-        // needs GL4 and above
-        NVRENDER_BACKEND_UNUSED(drawMode);
-        NVRENDER_BACKEND_UNUSED(type);
-        NVRENDER_BACKEND_UNUSED(indirect);
-    }
+void NVRenderBackendGLBase::DrawIndexedIndirect(NVRenderDrawMode::Enum drawMode,
+                                                NVRenderComponentTypes::Enum type,
+                                                const void *indirect)
+{
+    // needs GL4 and above
+    NVRENDER_BACKEND_UNUSED(drawMode);
+    NVRENDER_BACKEND_UNUSED(type);
+    NVRENDER_BACKEND_UNUSED(indirect);
+}
 
-    void NVRenderBackendGLBase::ReadPixel(NVRenderBackendRenderTargetObject /* rto */, QT3DSI32 x,
-                                          QT3DSI32 y, QT3DSI32 width, QT3DSI32 height,
-                                          NVRenderReadPixelFormats::Enum inFormat, void *pixels)
-    {
-        GLuint glFormat;
-        GLuint glType;
-        if (m_Conversion.fromReadPixelsToGlFormatAndType(inFormat, &glFormat, &glType)) {
-            GL_CALL_FUNCTION(glReadPixels(x, y, width, height, glFormat, glType, pixels));
-        }
+void NVRenderBackendGLBase::ReadPixel(NVRenderBackendRenderTargetObject /* rto */, QT3DSI32 x,
+                                      QT3DSI32 y, QT3DSI32 width, QT3DSI32 height,
+                                      NVRenderReadPixelFormats::Enum inFormat, void *pixels)
+{
+    GLuint glFormat;
+    GLuint glType;
+    if (m_Conversion.fromReadPixelsToGlFormatAndType(inFormat, &glFormat, &glType)) {
+        GL_CALL_FUNCTION(glReadPixels(x, y, width, height, glFormat, glType, pixels));
     }
+}
 
-    NVRenderBackend::NVRenderBackendPathObject NVRenderBackendGLBase::CreatePathNVObject(size_t)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderBackend::NVRenderBackendPathObject NVRenderBackendGLBase::CreatePathNVObject(size_t)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-        return NVRenderBackend::NVRenderBackendPathObject(0);
-    }
+    return NVRenderBackend::NVRenderBackendPathObject(0);
+}
 
-    void NVRenderBackendGLBase::ReleasePathNVObject(NVRenderBackendPathObject, size_t)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::ReleasePathNVObject(NVRenderBackendPathObject, size_t)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
+
+void NVRenderBackendGLBase::LoadPathGlyphs(NVRenderBackendPathObject,
+                                           NVRenderPathFontTarget::Enum, const void *,
+                                           NVRenderPathFontStyleFlags, size_t,
+                                           NVRenderPathFormatType::Enum, const void *,
+                                           NVRenderPathMissingGlyphs::Enum,
+                                           NVRenderBackendPathObject, QT3DSF32)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::LoadPathGlyphs(NVRenderBackendPathObject,
+void NVRenderBackendGLBase::LoadPathGlyphRange(NVRenderBackendPathObject,
                                                NVRenderPathFontTarget::Enum, const void *,
-                                               NVRenderPathFontStyleFlags, size_t,
-                                               NVRenderPathFormatType::Enum, const void *,
+                                               NVRenderPathFontStyleFlags, QT3DSU32, size_t,
                                                NVRenderPathMissingGlyphs::Enum,
                                                NVRenderBackendPathObject, QT3DSF32)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
-
-    void NVRenderBackendGLBase::LoadPathGlyphRange(NVRenderBackendPathObject,
-                                                   NVRenderPathFontTarget::Enum, const void *,
-                                                   NVRenderPathFontStyleFlags, QT3DSU32, size_t,
-                                                   NVRenderPathMissingGlyphs::Enum,
-                                                   NVRenderBackendPathObject, QT3DSF32)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    NVRenderPathReturnValues::Enum NVRenderBackendGLBase::LoadPathGlyphsIndexed(
-        NVRenderBackendPathObject, NVRenderPathFontTarget::Enum, const void *,
-        NVRenderPathFontStyleFlags, QT3DSU32, size_t, NVRenderBackendPathObject, QT3DSF32)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+NVRenderPathReturnValues::Enum NVRenderBackendGLBase::LoadPathGlyphsIndexed(
+    NVRenderBackendPathObject, NVRenderPathFontTarget::Enum, const void *,
+    NVRenderPathFontStyleFlags, QT3DSU32, size_t, NVRenderBackendPathObject, QT3DSF32)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
 
-        return NVRenderPathReturnValues::FontUnavailable;
-    }
+    return NVRenderPathReturnValues::FontUnavailable;
+}
 
-    NVRenderBackend::NVRenderBackendPathObject NVRenderBackendGLBase::LoadPathGlyphsIndexedRange(
-        NVRenderPathFontTarget::Enum, const void *, NVRenderPathFontStyleFlags,
-        NVRenderBackend::NVRenderBackendPathObject, QT3DSF32, QT3DSU32 *)
-    {
-        return NVRenderBackendPathObject(0);
-    }
+NVRenderBackend::NVRenderBackendPathObject NVRenderBackendGLBase::LoadPathGlyphsIndexedRange(
+    NVRenderPathFontTarget::Enum, const void *, NVRenderPathFontStyleFlags,
+    NVRenderBackend::NVRenderBackendPathObject, QT3DSF32, QT3DSU32 *)
+{
+    return NVRenderBackendPathObject(0);
+}
 
-    void NVRenderBackendGLBase::GetPathMetrics(NVRenderBackendPathObject, size_t,
-                                               NVRenderPathGlyphFontMetricFlags,
-                                               NVRenderPathFormatType::Enum, const void *, size_t,
-                                               QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::GetPathMetrics(NVRenderBackendPathObject, size_t,
+                                           NVRenderPathGlyphFontMetricFlags,
+                                           NVRenderPathFormatType::Enum, const void *, size_t,
+                                           QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::GetPathMetricsRange(NVRenderBackendPathObject, size_t,
-                                                    NVRenderPathGlyphFontMetricFlags, size_t,
-                                                    QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::GetPathMetricsRange(NVRenderBackendPathObject, size_t,
+                                                NVRenderPathGlyphFontMetricFlags, size_t,
+                                                QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::GetPathSpacing(NVRenderBackendPathObject, size_t,
-                                               NVRenderPathListMode::Enum,
-                                               NVRenderPathFormatType::Enum, const void *, QT3DSF32,
-                                               QT3DSF32, NVRenderPathTransformType::Enum, QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::GetPathSpacing(NVRenderBackendPathObject, size_t,
+                                           NVRenderPathListMode::Enum,
+                                           NVRenderPathFormatType::Enum, const void *, QT3DSF32,
+                                           QT3DSF32, NVRenderPathTransformType::Enum, QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::StencilFillPathInstanced(NVRenderBackendPathObject, size_t,
-                                                         NVRenderPathFormatType::Enum, const void *,
-                                                         NVRenderPathFillMode::Enum, QT3DSU32,
-                                                         NVRenderPathTransformType::Enum,
-                                                         const QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::StencilFillPathInstanced(NVRenderBackendPathObject, size_t,
+                                                     NVRenderPathFormatType::Enum, const void *,
+                                                     NVRenderPathFillMode::Enum, QT3DSU32,
+                                                     NVRenderPathTransformType::Enum,
+                                                     const QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::StencilStrokePathInstancedN(NVRenderBackendPathObject, size_t,
-                                                            NVRenderPathFormatType::Enum,
-                                                            const void *, QT3DSI32, QT3DSU32,
-                                                            NVRenderPathTransformType::Enum,
-                                                            const QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::StencilStrokePathInstancedN(NVRenderBackendPathObject, size_t,
+                                                        NVRenderPathFormatType::Enum,
+                                                        const void *, QT3DSI32, QT3DSU32,
+                                                        NVRenderPathTransformType::Enum,
+                                                        const QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::CoverFillPathInstanced(NVRenderBackendPathObject, size_t,
-                                                       NVRenderPathFormatType::Enum, const void *,
-                                                       NVRenderPathCoverMode::Enum,
-                                                       NVRenderPathTransformType::Enum,
-                                                       const QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::CoverFillPathInstanced(NVRenderBackendPathObject, size_t,
+                                                   NVRenderPathFormatType::Enum, const void *,
+                                                   NVRenderPathCoverMode::Enum,
+                                                   NVRenderPathTransformType::Enum,
+                                                   const QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    void NVRenderBackendGLBase::CoverStrokePathInstanced(NVRenderBackendPathObject, size_t,
-                                                         NVRenderPathFormatType::Enum, const void *,
-                                                         NVRenderPathCoverMode::Enum,
-                                                         NVRenderPathTransformType::Enum,
-                                                         const QT3DSF32 *)
-    {
-        // Needs GL 4 backend
-        qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
-    }
+void NVRenderBackendGLBase::CoverStrokePathInstanced(NVRenderBackendPathObject, size_t,
+                                                     NVRenderPathFormatType::Enum, const void *,
+                                                     NVRenderPathCoverMode::Enum,
+                                                     NVRenderPathTransformType::Enum,
+                                                     const QT3DSF32 *)
+{
+    // Needs GL 4 backend
+    qCCritical(INVALID_OPERATION) << QObject::tr("Unsupported method: ") << __FUNCTION__;
+}
 
-    ///< private calls
-    const char *NVRenderBackendGLBase::getVersionString()
-    {
-        const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_VERSION));
-        if (retval == NULL)
-            return "";
+///< private calls
+const char *NVRenderBackendGLBase::getVersionString()
+{
+    const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_VERSION));
+    if (retval == nullptr)
+        return "";
 
-        return retval;
-    }
+    return retval;
+}
 
-    const char *NVRenderBackendGLBase::getVendorString()
-    {
-        const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_VENDOR));
-        if (retval == NULL)
-            return "";
+const char *NVRenderBackendGLBase::getVendorString()
+{
+    const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_VENDOR));
+    if (retval == nullptr)
+        return "";
 
-        return retval;
-    }
+    return retval;
+}
 
-    const char *NVRenderBackendGLBase::getRendererString()
-    {
-        const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_RENDERER));
-        if (retval == NULL)
-            return "";
+const char *NVRenderBackendGLBase::getRendererString()
+{
+    const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_RENDERER));
+    if (retval == nullptr)
+        return "";
 
-        return retval;
-    }
+    return retval;
+}
 
-    const char *NVRenderBackendGLBase::getExtensionString()
-    {
-        const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_EXTENSIONS));
-        if (retval == NULL)
-            return "";
+const char *NVRenderBackendGLBase::getExtensionString()
+{
+    const char *retval = (const char *)GL_CALL_FUNCTION(glGetString(GL_EXTENSIONS));
+    if (retval == nullptr)
+        return "";
 
-        return retval;
-    }
+    return retval;
+}
 
-    /**
-     * @brief This function inspects the various strings to setup
-     *		  HW capabilities of the device.
-     *		  We can do a lot of smart things here based on GL version
-     *		  renderer string and vendor.
-     *
-     * @return No return
-     */
-    void NVRenderBackendGLBase::setAndInspectHardwareCaps()
-    {
-        eastl::string apiVersion(getVersionString());
-        qCInfo(TRACE_INFO, "GL version: %s", apiVersion.c_str());
-
-        // we assume all GLES versions running on mobile with shared memory
-        // this means framebuffer blits are slow and should be optimized or avoided
-        if (apiVersion.find("OpenGL ES") == eastl::string::npos) {
-            // no ES device
-            m_backendSupport.caps.bits.bFastBlitsSupported = true;
-        }
+/**
+ * @brief This function inspects the various strings to setup
+ *        HW capabilities of the device.
+ *        We can do a lot of smart things here based on GL version
+ *        renderer string and vendor.
+ *
+ * @return No return
+ */
+void NVRenderBackendGLBase::setAndInspectHardwareCaps()
+{
+    eastl::string apiVersion(getVersionString());
+    qCInfo(TRACE_INFO, "GL version: %s", apiVersion.c_str());
+
+    // we assume all GLES versions running on mobile with shared memory
+    // this means framebuffer blits are slow and should be optimized or avoided
+    if (apiVersion.find("OpenGL ES") == eastl::string::npos) {
+        // no ES device
+        m_backendSupport.caps.bits.bFastBlitsSupported = true;
     }
+}
 
 #ifdef RENDER_BACKEND_LOG_GL_ERRORS
-    void NVRenderBackendGLBase::checkGLError(const char *function, const char *file,
-                                             const unsigned int line) const
-    {
-        GLenum error = m_glFunctions->glGetError();
-        if (error != GL_NO_ERROR) {
-            qCCritical(GL_ERROR) << GLConversion::processGLError(error) << " "
-                                 << function << " " << file << " " << line;
-        }
+void NVRenderBackendGLBase::checkGLError(const char *function, const char *file,
+                                         const unsigned int line) const
+{
+    GLenum error = m_glFunctions->glGetError();
+    if (error != GL_NO_ERROR) {
+        qCCritical(GL_ERROR) << GLConversion::processGLError(error) << " "
+                             << function << " " << file << " " << line;
     }
+}
 #else
-    void NVRenderBackendGLBase::checkGLError() const
-    {
+void NVRenderBackendGLBase::checkGLError() const
+{
 #if !defined(NDEBUG) || defined(_DEBUG)
-        GLenum error = m_glFunctions->glGetError();
-        if (error != GL_NO_ERROR)
-            qCCritical(GL_ERROR) << GLConversion::processGLError(error);
+    GLenum error = m_glFunctions->glGetError();
+    if (error != GL_NO_ERROR)
+        qCCritical(GL_ERROR) << GLConversion::processGLError(error);
 #endif
-    }
+}
 #endif
 
 }