0032082: Visualization, TKOpenGl - improve formatting of error messages

Error messages in TKOpenGl package have been improved to format
GLenum values as string constants or hex values.
OpenGl_VertexBuffer::init() now logs a message with error details
instead of just returning Boolean flag.

src/OpenGl/OpenGl_Context.cxx

@@ -43,6 +43,11 @@
 #include <Standard_ProgramError.hxx>
 #include <Standard_WarningDisableFunctionCast.hxx>
 
+#if defined(_WIN32) && defined(max)
+  #undef max
+#endif
+#include <limits>
+
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context,Standard_Transient)
 
 #if defined(HAVE_EGL)
@@ -1004,6 +1009,62 @@ Standard_Boolean OpenGl_Context::Init (const Aspect_Drawable         theWindow,
   return Standard_True;
 }
 
+// =======================================================================
+// function : FormatGlEnumHex
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_Context::FormatGlEnumHex (int theGlEnum)
+{
+  char aBuff[16];
+  Sprintf (aBuff, theGlEnum < (int )std::numeric_limits<uint16_t>::max()
+                ? "0x%04X"
+                : "0x%08X", theGlEnum);
+  return aBuff;
+}
+
+// =======================================================================
+// function : FormatSize
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_Context::FormatSize (Standard_Size theSize)
+{
+  char aBuff[32];
+  Sprintf (aBuff, "%" PRIu64, (uint64_t )theSize);
+  return aBuff;
+}
+
+// =======================================================================
+// function : FormatPointer
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_Context::FormatPointer (const void* thePtr)
+{
+  char aBuff[32];
+  Sprintf (aBuff, "0x%" PRIXPTR, (uintptr_t )thePtr);
+  return aBuff;
+}
+
+// =======================================================================
+// function : FormatGlError
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_Context::FormatGlError (int theGlError)
+{
+  switch (theGlError)
+  {
+    case GL_INVALID_ENUM:      return "GL_INVALID_ENUM";
+    case GL_INVALID_VALUE:     return "GL_INVALID_VALUE";
+    case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
+  #ifdef GL_STACK_OVERFLOW
+    case GL_STACK_OVERFLOW:    return "GL_STACK_OVERFLOW";
+    case GL_STACK_UNDERFLOW:   return "GL_STACK_UNDERFLOW";
+  #endif
+    case GL_OUT_OF_MEMORY:     return "GL_OUT_OF_MEMORY";
+    case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION";
+  }
+  return FormatGlEnumHex (theGlError);
+}
+
 // =======================================================================
 // function : ResetErrors
 // purpose  :
@@ -1024,31 +1085,42 @@ bool OpenGl_Context::ResetErrors (const bool theToPrintErrors)
 
   for (; anErr != GL_NO_ERROR && aPrevErr != anErr; aPrevErr = anErr, anErr = ::glGetError())
   {
-    TCollection_ExtendedString anErrId;
+    const TCollection_ExtendedString aMsg = TCollection_ExtendedString ("Unhandled GL error: ") + FormatGlError (anErr);
-    switch (anErr)
-    {
-      case GL_INVALID_ENUM:      anErrId = "GL_INVALID_ENUM";      break;
-      case GL_INVALID_VALUE:     anErrId = "GL_INVALID_VALUE";     break;
-      case GL_INVALID_OPERATION: anErrId = "GL_INVALID_OPERATION"; break;
-    #ifdef GL_STACK_OVERFLOW
-      case GL_STACK_OVERFLOW:    anErrId = "GL_STACK_OVERFLOW";    break;
-      case GL_STACK_UNDERFLOW:   anErrId = "GL_STACK_UNDERFLOW";   break;
-    #endif
-      case GL_OUT_OF_MEMORY:     anErrId = "GL_OUT_OF_MEMORY";     break;
-      case GL_INVALID_FRAMEBUFFER_OPERATION:
-        anErrId = "GL_INVALID_FRAMEBUFFER_OPERATION";
-        break;
-      default:
-        anErrId = TCollection_ExtendedString("#") + anErr;
-        break;
-    }
-
-    const TCollection_ExtendedString aMsg = TCollection_ExtendedString ("Unhandled GL error: ") + anErrId;
     PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
   }
   return hasError;
 }
 
+// =======================================================================
+// function : debugPrintError
+// purpose  :
+// =======================================================================
+bool OpenGl_GlFunctions::debugPrintError (const char* theName) const
+{
+  const int anErr = ::glGetError();
+  if (anErr != GL_NO_ERROR)
+  {
+    Message::SendFail() << theName << "(), unhandled GL error: " << OpenGl_Context::FormatGlError (anErr);
+    // there is no glSetError(), just emulate non-clear state
+    switch (anErr)
+    {
+      case GL_INVALID_VALUE:
+      {
+        ::glLineWidth(-1.0f);
+        ::glLineWidth( 1.0f);
+        break;
+      }
+      default:
+      case GL_INVALID_ENUM:
+      {
+        ::glEnable (0xFFFF);
+        break;
+      }
+    }
+  }
+  return anErr != GL_NO_ERROR;
+}
+
 // =======================================================================
 // function : ReadGlVersion
 // purpose  :

src/OpenGl/OpenGl_Context.hxx

@@ -232,6 +232,18 @@ public:
     return theThreshold;
   }
 
+  //! Format GL constant as hex value 0xABCD.
+  Standard_EXPORT static TCollection_AsciiString FormatGlEnumHex (int theGlEnum);
+
+  //! Format pointer as hex value 0xABCD.
+  Standard_EXPORT static TCollection_AsciiString FormatPointer (const void* thePtr);
+
+  //! Format size value.
+  Standard_EXPORT static TCollection_AsciiString FormatSize (Standard_Size theSize);
+
+  //! Return text description of GL error.
+  Standard_EXPORT static TCollection_AsciiString FormatGlError (int theGlError);
+
 public:
 
   //! Empty constructor. You should call Init() to perform initialization with bound GL context.

src/OpenGl/OpenGl_GlCore11Fwd.hxx

@@ -30,56 +30,67 @@ public: //! @name Miscellaneous
   inline void glClearColor (GLclampf theRed, GLclampf theGreen, GLclampf theBlue, GLclampf theAlpha)
   {
     ::glClearColor  (theRed, theGreen, theBlue, theAlpha);
+    OpenGl_TRACE(glClearColor)
   }
 
   inline void glClear (GLbitfield theMask)
   {
     ::glClear (theMask);
+    OpenGl_TRACE(glClear)
   }
 
   inline void glColorMask (GLboolean theRed, GLboolean theGreen, GLboolean theBlue, GLboolean theAlpha)
   {
     ::glColorMask (theRed, theGreen, theBlue, theAlpha);
+    OpenGl_TRACE(glColorMask)
   }
 
   inline void glBlendFunc (GLenum sfactor, GLenum dfactor)
   {
     ::glBlendFunc(sfactor, dfactor);
+    OpenGl_TRACE(glBlendFunc)
   }
 
   inline void glCullFace (GLenum theMode)
   {
     ::glCullFace (theMode);
+    OpenGl_TRACE(glCullFace)
   }
 
   inline void glFrontFace (GLenum theMode)
   {
     ::glFrontFace (theMode);
+    OpenGl_TRACE(glFrontFace)
   }
 
   inline void glLineWidth (GLfloat theWidth)
   {
     ::glLineWidth (theWidth);
+    OpenGl_TRACE(glLineWidth)
   }
 
   inline void glPolygonOffset (GLfloat theFactor, GLfloat theUnits)
   {
     ::glPolygonOffset (theFactor, theUnits);
+    OpenGl_TRACE(glPolygonOffset)
   }
 
   inline void glScissor (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
   {
     ::glScissor (theX, theY, theWidth, theHeight);
+    OpenGl_TRACE(glScissor)
   }
 
   inline void glEnable (GLenum theCap)
   {
     ::glEnable (theCap);
+    OpenGl_TRACE(glEnable)
   }
 
   inline void glDisable (GLenum theCap)
   {
     ::glDisable (theCap);
+    OpenGl_TRACE(glDisable)
   }
 
   inline GLboolean glIsEnabled (GLenum theCap)
@@ -90,16 +101,19 @@ public: //! @name Miscellaneous
   inline void glGetBooleanv (GLenum theParamName, GLboolean* theValues)
   {
     ::glGetBooleanv (theParamName, theValues);
+    OpenGl_TRACE(glGetBooleanv)
   }
 
   inline void glGetFloatv (GLenum theParamName, GLfloat* theValues)
   {
     ::glGetFloatv (theParamName, theValues);
+    OpenGl_TRACE(glGetFloatv)
   }
 
   inline void glGetIntegerv (GLenum theParamName, GLint* theValues)
   {
     ::glGetIntegerv (theParamName, theValues);
+    OpenGl_TRACE(glGetIntegerv)
   }
 
   inline GLenum glGetError()
@@ -109,22 +123,27 @@ public: //! @name Miscellaneous
 
   inline const GLubyte* glGetString (GLenum theName)
   {
-    return ::glGetString (theName);
+    const GLubyte* aRes = ::glGetString (theName);
+    OpenGl_TRACE(glGetString)
+    return aRes;
   }
 
   inline void glFinish()
   {
     ::glFinish();
+    OpenGl_TRACE(glFinish)
   }
 
   inline void glFlush()
   {
     ::glFlush();
+    OpenGl_TRACE(glFlush)
   }
 
   inline void glHint (GLenum theTarget, GLenum theMode)
   {
     ::glHint (theTarget, theMode);
+    OpenGl_TRACE(glHint)
   }
 
 public: //! @name Depth Buffer
@@ -136,6 +155,7 @@ public: //! @name Depth Buffer
   #else
     ::glClearDepth (theDepth);
   #endif
+    OpenGl_TRACE(glClearDepth)
   }
 
   inline void glClearDepthf (GLfloat theDepth)
@@ -145,16 +165,19 @@ public: //! @name Depth Buffer
   #else
     ::glClearDepth ((GLclampd )theDepth);
   #endif
+    OpenGl_TRACE(glClearDepthf)
   }
 
   inline void glDepthFunc (GLenum theFunc)
   {
     ::glDepthFunc (theFunc);
+    OpenGl_TRACE(glDepthFunc)
   }
 
   inline void glDepthMask (GLboolean theFlag)
   {
     ::glDepthMask (theFlag);
+    OpenGl_TRACE(glDepthMask)
   }
 
   inline void glDepthRange (GLclampd theNearValue,
@@ -165,6 +188,7 @@ public: //! @name Depth Buffer
   #else
     ::glDepthRange (theNearValue, theFarValue);
   #endif
+    OpenGl_TRACE(glDepthRange)
   }
 
   inline void glDepthRangef (GLfloat theNearValue,
@@ -175,6 +199,7 @@ public: //! @name Depth Buffer
   #else
     ::glDepthRange ((GLclampd )theNearValue, (GLclampd )theFarValue);
   #endif
+    OpenGl_TRACE(glDepthRangef)
   }
 
 public: //! @name Transformation
@@ -182,6 +207,7 @@ public: //! @name Transformation
   inline void glViewport (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
   {
     ::glViewport (theX, theY, theWidth, theHeight);
+    OpenGl_TRACE(glViewport)
   }
 
 public: //! @name Vertex Arrays
@@ -189,11 +215,13 @@ public: //! @name Vertex Arrays
   inline void glDrawArrays (GLenum theMode, GLint theFirst, GLsizei theCount)
   {
     ::glDrawArrays (theMode, theFirst, theCount);
+    OpenGl_TRACE(glDrawArrays)
   }
 
   inline void glDrawElements (GLenum theMode, GLsizei theCount, GLenum theType, const GLvoid* theIndices)
   {
     ::glDrawElements (theMode, theCount, theType, theIndices);
+    OpenGl_TRACE(glDrawElements)
   }
 
 public: //! @name Raster functions
@@ -201,6 +229,7 @@ public: //! @name Raster functions
   inline void glPixelStorei (GLenum theParamName, GLint   theParam)
   {
     ::glPixelStorei (theParamName, theParam);
+    OpenGl_TRACE(glPixelStorei)
   }
 
   inline void glReadPixels (GLint x, GLint y,
@@ -209,6 +238,7 @@ public: //! @name Raster functions
                             GLvoid* pixels)
   {
     ::glReadPixels (x, y, width, height, format, type, pixels);
+    OpenGl_TRACE(glReadPixels)
   }
 
 public: //! @name Stenciling
@@ -216,21 +246,25 @@ public: //! @name Stenciling
   inline void glStencilFunc (GLenum func, GLint ref, GLuint mask)
   {
     ::glStencilFunc (func, ref, mask);
+    OpenGl_TRACE(glStencilFunc)
   }
 
   inline void glStencilMask (GLuint mask)
   {
     ::glStencilMask (mask);
+    OpenGl_TRACE(glStencilMask)
   }
 
   inline void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
   {
     ::glStencilOp (fail, zfail, zpass);
+    OpenGl_TRACE(glStencilOp)
   }
 
   inline void glClearStencil (GLint s)
   {
     ::glClearStencil (s);
+    OpenGl_TRACE(glClearStencil)
   }
 
 public: //! @name Texture mapping
@@ -238,31 +272,37 @@ public: //! @name Texture mapping
   inline void glTexParameterf (GLenum target, GLenum pname, GLfloat param)
   {
     ::glTexParameterf (target, pname, param);
+    OpenGl_TRACE(glTexParameterf)
   }
 
   inline void glTexParameteri (GLenum target, GLenum pname, GLint param)
   {
     ::glTexParameteri (target, pname, param);
+    OpenGl_TRACE(glTexParameteri)
   }
 
   inline void glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params)
   {
     ::glTexParameterfv (target, pname, params);
+    OpenGl_TRACE(glTexParameterfv)
   }
 
   inline void glTexParameteriv (GLenum target, GLenum pname, const GLint* params)
   {
     ::glTexParameteriv (target, pname, params);
+    OpenGl_TRACE(glTexParameteriv)
   }
 
   inline void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params)
   {
     ::glGetTexParameterfv (target, pname, params);
+    OpenGl_TRACE(glGetTexParameterfv)
   }
 
   inline void glGetTexParameteriv (GLenum target, GLenum pname, GLint* params)
   {
     ::glGetTexParameteriv (target, pname, params);
+    OpenGl_TRACE(glGetTexParameteriv)
   }
 
   inline void glTexImage2D (GLenum target, GLint level,
@@ -272,26 +312,32 @@ public: //! @name Texture mapping
                             const GLvoid* pixels)
   {
     ::glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
+    OpenGl_TRACE(glTexImage2D)
   }
 
   inline void glGenTextures (GLsizei n, GLuint* textures)
   {
     ::glGenTextures(n, textures);
+    OpenGl_TRACE(glGenTextures)
   }
 
   inline void glDeleteTextures (GLsizei n, const GLuint* textures)
   {
     ::glDeleteTextures(n, textures);
+    OpenGl_TRACE(glDeleteTextures)
   }
 
   inline void glBindTexture (GLenum target, GLuint texture)
   {
     ::glBindTexture(target, texture);
+    OpenGl_TRACE(glBindTexture)
   }
 
   inline GLboolean glIsTexture (GLuint texture)
   {
-    return ::glIsTexture (texture);
+    const GLboolean aRes = ::glIsTexture (texture);
+    OpenGl_TRACE(glIsTexture)
+    return aRes;
   }
 
   inline void glTexSubImage2D (GLenum target, GLint level,
@@ -301,6 +347,7 @@ public: //! @name Texture mapping
                                const GLvoid* pixels)
   {
     ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    OpenGl_TRACE(glTexSubImage2D)
   }
 
   inline void glCopyTexImage2D (GLenum target, GLint level,
@@ -310,6 +357,7 @@ public: //! @name Texture mapping
                                 GLint border)
   {
     ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    OpenGl_TRACE(glCopyTexImage2D)
   }
 
   inline void glCopyTexSubImage2D (GLenum target, GLint level,
@@ -318,6 +366,7 @@ public: //! @name Texture mapping
                                    GLsizei width, GLsizei height)
   {
     ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    OpenGl_TRACE(glCopyTexSubImage2D)
   }
 
 #if !defined(GL_ES_VERSION_2_0)
@@ -328,6 +377,7 @@ public: //! @name Texture mapping
                             const GLvoid* pixels)
   {
     ::glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
+    OpenGl_TRACE(glTexImage1D)
   }
 
   inline void glTexSubImage1D (GLenum target, GLint level,
@@ -336,6 +386,7 @@ public: //! @name Texture mapping
                                GLenum type, const GLvoid* pixels)
   {
     ::glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    OpenGl_TRACE(glTexSubImage1D)
   }
 
   inline void glCopyTexImage1D (GLenum target, GLint level,
@@ -344,6 +395,7 @@ public: //! @name Texture mapping
                                 GLsizei width, GLint border)
   {
     ::glCopyTexImage1D(target, level, internalformat, x, y, width, border);
+    OpenGl_TRACE(glCopyTexImage1D)
   }
 
   inline void glCopyTexSubImage1D (GLenum target, GLint level,
@@ -351,6 +403,7 @@ public: //! @name Texture mapping
                                    GLsizei width)
   {
     ::glCopyTexSubImage1D(target, level, xoffset, x, y, width);
+    OpenGl_TRACE(glCopyTexSubImage1D)
   }
 
   inline void glGetTexImage (GLenum target, GLint level,
@@ -358,6 +411,7 @@ public: //! @name Texture mapping
                              GLvoid* pixels)
   {
     ::glGetTexImage (target, level, format, type, pixels);
+    OpenGl_TRACE(glGetTexImage)
   }
 #endif
 
@@ -366,11 +420,13 @@ public: //! @name Texture mapping
   inline void glAlphaFunc (GLenum theFunc, GLclampf theRef)
   {
     ::glAlphaFunc (theFunc, theRef);
+    OpenGl_TRACE(glAlphaFunc)
   }
 
   inline void glPointSize (GLfloat theSize)
   {
     ::glPointSize (theSize);
+    OpenGl_TRACE(glPointSize)
   }
 
 #endif

src/OpenGl/OpenGl_GlFunctions.hxx

@@ -100,6 +100,15 @@
 struct OpenGl_GlFunctions
 {
 
+  //! Check glGetError(); defined for debugging purposes.
+  //! @return TRUE on error
+  Standard_EXPORT bool debugPrintError (const char* theName) const;
+
+  // This debug macros can be enabled to help debugging OpenGL implementations
+  // without solid / working debugging capabilities.
+  //#define OpenGl_TRACE(theName) {OpenGl_GlFunctions::debugPrintError(#theName);}
+  #define OpenGl_TRACE(theName)
+
 public: //! @name OpenGL ES 1.1
 
 #if defined(GL_ES_VERSION_2_0)
@@ -107,71 +116,85 @@ public: //! @name OpenGL ES 1.1
   inline void glActiveTexture (GLenum texture) const
   {
     ::glActiveTexture (texture);
+    OpenGl_TRACE(glActiveTexture)
   }
 
   inline void glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) const
   {
     ::glCompressedTexImage2D (target, level, internalformat, width, height, border, imageSize, data);
+    OpenGl_TRACE(glCompressedTexImage2D)
   }
 
   inline void glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) const
   {
     ::glCompressedTexSubImage2D (target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    OpenGl_TRACE(glCompressedTexSubImage2D)
   }
 
   inline void glBindBuffer (GLenum target, GLuint buffer) const
   {
     ::glBindBuffer (target, buffer);
+    OpenGl_TRACE(glBindBuffer)
   }
 
   inline void glBufferData (GLenum target, GLsizeiptr size, const void* data, GLenum usage) const
   {
     ::glBufferData (target, size, data, usage);
+    OpenGl_TRACE(glBufferData)
   }
 
   inline void glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void* data) const
   {
     ::glBufferSubData (target, offset, size, data);
+    OpenGl_TRACE(glBufferSubData)
   }
 
   inline void glDeleteBuffers (GLsizei n, const GLuint *buffers) const
   {
     ::glDeleteBuffers (n, buffers);
+    OpenGl_TRACE(glDeleteBuffers)
   }
 
   inline void glDeleteTextures (GLsizei n, const GLuint *textures) const
   {
     ::glDeleteTextures (n, textures);
+    OpenGl_TRACE(glDeleteTextures)
   }
 
   inline void glDepthFunc (GLenum func) const
   {
     ::glDepthFunc (func);
+    OpenGl_TRACE(glDepthFunc)
   }
 
   inline void glDepthMask (GLboolean flag) const
   {
     ::glDepthMask (flag);
+    OpenGl_TRACE(glDepthMask)
   }
 
   inline void glDepthRangef (GLfloat n, GLfloat f) const
   {
     ::glDepthRangef (n, f);
+    OpenGl_TRACE(glDepthRangef)
   }
 
   inline void glGenBuffers (GLsizei n, GLuint *buffers) const
   {
     ::glGenBuffers (n, buffers);
+    OpenGl_TRACE(glGenBuffers)
   }
 
   inline void glGenTextures (GLsizei n, GLuint *textures) const
   {
     ::glGenTextures (n, textures);
+    OpenGl_TRACE(glGenTextures)
   }
 
   inline void glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params) const
   {
     ::glGetBufferParameteriv (target, pname, params);
+    OpenGl_TRACE(glGetBufferParameteriv)
   }
 
   inline GLboolean glIsBuffer (GLuint buffer) const
@@ -182,6 +205,7 @@ public: //! @name OpenGL ES 1.1
   inline void glSampleCoverage (GLfloat value, GLboolean invert) const
   {
     ::glSampleCoverage (value, invert);
+    OpenGl_TRACE(glSampleCoverage)
   }
 
   inline void glMultiDrawElements (GLenum theMode, const GLsizei* theCount, GLenum theType, const void* const* theIndices, GLsizei theDrawCount) const
@@ -196,6 +220,7 @@ public: //! @name OpenGL ES 1.1
     {
       ::glDrawElements (theMode, theCount[aBatchIter], theType, theIndices[aBatchIter]);
     }
+    OpenGl_TRACE(glMultiDrawElements)
   }
 
 #endif
@@ -206,56 +231,67 @@ public: //! @name OpenGL ES 2.0
   inline void glBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) const
   {
     ::glBlendColor (red, green, blue, alpha);
+    OpenGl_TRACE(glBlendColor)
   }
 
   inline void glBlendEquation (GLenum mode) const
   {
     ::glBlendEquation (mode);
+    OpenGl_TRACE(glBlendEquation)
   }
 
   inline void glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) const
   {
     ::glBlendFuncSeparate (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    OpenGl_TRACE(glBlendFuncSeparate)
   }
 
   inline void glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha) const
   {
     ::glBlendEquationSeparate (modeRGB, modeAlpha);
+    OpenGl_TRACE(glBlendEquationSeparate)
   }
 
   inline void glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) const
   {
     ::glStencilOpSeparate (face, sfail, dpfail, dppass);
+    OpenGl_TRACE(glStencilOpSeparate)
   }
 
   inline void glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask) const
   {
     ::glStencilFuncSeparate (face, func, ref, mask);
+    OpenGl_TRACE(glStencilFuncSeparate)
   }
 
   inline void glStencilMaskSeparate (GLenum face, GLuint mask) const
   {
     ::glStencilMaskSeparate (face, mask);
+    OpenGl_TRACE(glStencilMaskSeparate)
   }
 
   inline void glAttachShader (GLuint program, GLuint shader) const
   {
     ::glAttachShader (program, shader);
+    OpenGl_TRACE(glAttachShader)
   }
 
   inline void glBindAttribLocation (GLuint program, GLuint index, const GLchar *name) const
   {
     ::glBindAttribLocation (program, index, name);
+    OpenGl_TRACE(glBindAttribLocation)
   }
 
   inline void glBindFramebuffer (GLenum target, GLuint framebuffer) const
   {
     ::glBindFramebuffer (target, framebuffer);
+    OpenGl_TRACE(glBindFramebuffer)
   }
 
   inline void glBindRenderbuffer (GLenum target, GLuint renderbuffer) const
   {
     ::glBindRenderbuffer (target, renderbuffer);
+    OpenGl_TRACE(glBindRenderbuffer)
   }
 
   inline GLenum glCheckFramebufferStatus (GLenum target) const
@@ -266,6 +302,7 @@ public: //! @name OpenGL ES 2.0
   inline void glCompileShader (GLuint shader) const
   {
     ::glCompileShader (shader);
+    OpenGl_TRACE(glCompileShader)
   }
 
   inline GLuint glCreateProgram() const
@@ -281,151 +318,183 @@ public: //! @name OpenGL ES 2.0
   inline void glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers) const
   {
     ::glDeleteFramebuffers (n, framebuffers);
+    OpenGl_TRACE(glDeleteFramebuffers)
   }
 
   inline void glDeleteProgram (GLuint program) const
   {
     ::glDeleteProgram (program);
+    OpenGl_TRACE(glDeleteProgram)
   }
 
   inline void glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers) const
   {
     ::glDeleteRenderbuffers (n, renderbuffers);
+    OpenGl_TRACE(glDeleteRenderbuffers)
   }
 
   inline void glDeleteShader (GLuint shader) const
   {
     ::glDeleteShader (shader);
+    OpenGl_TRACE(glDeleteShader)
   }
 
   inline void glDetachShader (GLuint program, GLuint shader) const
   {
     ::glDetachShader (program, shader);
+    OpenGl_TRACE(glDetachShader)
   }
 
   inline void glDisableVertexAttribArray (GLuint index) const
   {
     ::glDisableVertexAttribArray (index);
+    OpenGl_TRACE(glDisableVertexAttribArray)
   }
 
   inline void glEnableVertexAttribArray (GLuint index) const
   {
     ::glEnableVertexAttribArray (index);
+    OpenGl_TRACE(glEnableVertexAttribArray)
   }
 
   inline void glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) const
   {
     ::glFramebufferRenderbuffer (target, attachment, renderbuffertarget, renderbuffer);
+    OpenGl_TRACE(glFramebufferRenderbuffer)
   }
 
   inline void glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) const
   {
     ::glFramebufferTexture2D (target, attachment, textarget, texture, level);
+    OpenGl_TRACE(glFramebufferTexture2D)
   }
 
   inline void glGenerateMipmap (GLenum target) const
   {
     ::glGenerateMipmap (target);
+    OpenGl_TRACE(glGenerateMipmap)
   }
 
   inline void glGenFramebuffers (GLsizei n, GLuint *framebuffers) const
   {
     ::glGenFramebuffers (n, framebuffers);
+    OpenGl_TRACE(glGenFramebuffers)
   }
 
   inline void glGenRenderbuffers (GLsizei n, GLuint *renderbuffers) const
   {
     ::glGenRenderbuffers (n, renderbuffers);
+    OpenGl_TRACE(glGenRenderbuffers)
   }
 
   inline void glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint* size, GLenum *type, GLchar *name) const
   {
     ::glGetActiveAttrib (program, index, bufSize, length, size, type, name);
+    OpenGl_TRACE(glGetActiveAttrib)
   }
 
   inline void glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint* size, GLenum *type, GLchar *name) const
   {
     ::glGetActiveUniform (program, index, bufSize, length, size, type, name);
+    OpenGl_TRACE(glGetActiveUniform)
   }
 
   inline void glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) const
   {
     ::glGetAttachedShaders (program, maxCount, count, shaders);
+    OpenGl_TRACE(glGetAttachedShaders)
   }
 
   inline GLint glGetAttribLocation (GLuint program, const GLchar *name) const
   {
-    return ::glGetAttribLocation (program, name);
+    const GLint aRes = ::glGetAttribLocation (program, name);
+    OpenGl_TRACE(glGetAttribLocation)
+    return aRes;
   }
 
   inline void glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params) const
   {
     ::glGetFramebufferAttachmentParameteriv (target, attachment, pname, params);
+    OpenGl_TRACE(glGetFramebufferAttachmentParameteriv)
   }
 
   inline void glGetProgramiv (GLuint program, GLenum pname, GLint* params) const
   {
     ::glGetProgramiv (program, pname, params);
+    OpenGl_TRACE(glGetProgramiv)
   }
 
   inline void glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) const
   {
     ::glGetProgramInfoLog (program, bufSize, length, infoLog);
+    OpenGl_TRACE(glGetProgramInfoLog)
   }
 
   inline void glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params) const
   {
     ::glGetRenderbufferParameteriv (target, pname, params);
+    OpenGl_TRACE(glGetRenderbufferParameteriv)
   }
 
   inline void glGetShaderiv (GLuint shader, GLenum pname, GLint* params) const
   {
     ::glGetShaderiv (shader, pname, params);
+    OpenGl_TRACE(glGetShaderiv)
   }
 
   inline void glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) const
   {
     ::glGetShaderInfoLog (shader, bufSize, length, infoLog);
+    OpenGl_TRACE(glGetShaderInfoLog)
   }
 
   inline void glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) const
   {
     ::glGetShaderPrecisionFormat (shadertype, precisiontype, range, precision);
+    OpenGl_TRACE(glGetShaderPrecisionFormat)
   }
 
   inline void glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) const
   {
     ::glGetShaderSource (shader, bufSize, length, source);
+    OpenGl_TRACE(glGetShaderSource)
   }
 
   inline void glGetUniformfv (GLuint program, GLint location, GLfloat* params) const
   {
     ::glGetUniformfv (program, location, params);
+    OpenGl_TRACE(glGetUniformfv)
   }
 
   inline void glGetUniformiv (GLuint program, GLint location, GLint* params) const
   {
     ::glGetUniformiv (program, location, params);
+    OpenGl_TRACE(glGetUniformiv)
   }
 
   GLint glGetUniformLocation (GLuint program, const GLchar *name) const
   {
-    return ::glGetUniformLocation (program, name);
+    const GLint aRes = ::glGetUniformLocation (program, name);
+    OpenGl_TRACE(glGetUniformLocation)
+    return aRes;
   }
 
   inline void glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params) const
   {
     ::glGetVertexAttribfv (index, pname, params);
+    OpenGl_TRACE(glGetVertexAttribfv)
   }
 
   inline void glGetVertexAttribiv (GLuint index, GLenum pname, GLint* params) const
   {
     ::glGetVertexAttribiv (index, pname, params);
+    OpenGl_TRACE(glGetVertexAttribiv)
   }
 
   inline void glGetVertexAttribPointerv (GLuint index, GLenum pname, void* *pointer) const
   {
     ::glGetVertexAttribPointerv (index, pname, pointer);
+    OpenGl_TRACE(glGetVertexAttribPointerv)
   }
 
   inline GLboolean glIsFramebuffer (GLuint framebuffer) const
@@ -451,176 +520,211 @@ public: //! @name OpenGL ES 2.0
   inline void glLinkProgram (GLuint program) const
   {
     ::glLinkProgram (program);
+    OpenGl_TRACE(glLinkProgram)
   }
 
   inline void glReleaseShaderCompiler() const
   {
     ::glReleaseShaderCompiler();
+    OpenGl_TRACE(glReleaseShaderCompiler)
   }
 
   inline void glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) const
   {
     ::glRenderbufferStorage (target, internalformat, width, height);
+    OpenGl_TRACE(glRenderbufferStorage)
   }
 
   inline void glShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const void* binary, GLsizei length) const
   {
     ::glShaderBinary (count, shaders, binaryformat, binary, length);
+    OpenGl_TRACE(glShaderBinary)
   }
 
   inline void glShaderSource (GLuint shader, GLsizei count, const GLchar** string, const GLint* length) const
   {
     ::glShaderSource (shader, count, string, length);
+    OpenGl_TRACE(glShaderSource)
   }
 
   inline void glUniform1f (GLint location, GLfloat v0) const
   {
     ::glUniform1f (location, v0);
+    OpenGl_TRACE(glUniform1f)
   }
 
   inline void glUniform1fv (GLint location, GLsizei count, const GLfloat* value) const
   {
     ::glUniform1fv (location, count, value);
+    OpenGl_TRACE(glUniform1fv)
   }
 
   inline void glUniform1i (GLint location, GLint v0) const
   {
     ::glUniform1i (location, v0);
+    OpenGl_TRACE(glUniform1i)
   }
 
   inline void glUniform1iv (GLint location, GLsizei count, const GLint* value) const
   {
     ::glUniform1iv (location, count, value);
+    OpenGl_TRACE(glUniform1iv)
   }
 
   inline void glUniform2f (GLint location, GLfloat v0, GLfloat v1) const
   {
     ::glUniform2f (location, v0, v1);
+    OpenGl_TRACE(glUniform2f)
   }
 
   inline void glUniform2fv (GLint location, GLsizei count, const GLfloat* value) const
   {
     ::glUniform2fv (location, count, value);
+    OpenGl_TRACE(glUniform2fv)
   }
 
   inline void glUniform2i (GLint location, GLint v0, GLint v1) const
   {
     ::glUniform2i (location, v0, v1);
+    OpenGl_TRACE(glUniform2i)
   }
 
   inline void glUniform2iv (GLint location, GLsizei count, const GLint* value) const
   {
     ::glUniform2iv (location, count, value);
+    OpenGl_TRACE(glUniform2iv)
   }
 
   inline void glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2) const
   {
     ::glUniform3f (location, v0, v1, v2);
+    OpenGl_TRACE(glUniform3f)
   }
 
   inline void glUniform3fv (GLint location, GLsizei count, const GLfloat* value) const
   {
     ::glUniform3fv (location, count, value);
+    OpenGl_TRACE(glUniform3fv)
   }
 
   inline void glUniform3i (GLint location, GLint v0, GLint v1, GLint v2) const
   {
     ::glUniform3i (location, v0, v1, v2);
+    OpenGl_TRACE(glUniform3i)
   }
 
   inline void glUniform3iv (GLint location, GLsizei count, const GLint* value) const
   {
     ::glUniform3iv (location, count, value);
+    OpenGl_TRACE(glUniform3iv)
   }
 
   inline void glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) const
   {
     ::glUniform4f (location, v0, v1, v2, v3);
+    OpenGl_TRACE(glUniform4f)
   }
 
   inline void glUniform4fv (GLint location, GLsizei count, const GLfloat* value) const
   {
     ::glUniform4fv (location, count, value);
+    OpenGl_TRACE(glUniform4fv)
   }
 
   inline void glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3) const
   {
     ::glUniform4i (location, v0, v1, v2, v3);
+    OpenGl_TRACE(glUniform4i)
   }
 
   inline void glUniform4iv (GLint location, GLsizei count, const GLint* value) const
   {
     ::glUniform4iv (location, count, value);
+    OpenGl_TRACE(glUniform4iv)
   }
 
   inline void glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) const
   {
     ::glUniformMatrix2fv (location, count, transpose, value);
+    OpenGl_TRACE(glUniformMatrix2fv)
   }
 
   inline void glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) const
   {
     ::glUniformMatrix3fv (location, count, transpose, value);
+    OpenGl_TRACE(glUniformMatrix3fv)
   }
 
   inline void glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) const
   {
     ::glUniformMatrix4fv (location, count, transpose, value);
+    OpenGl_TRACE(glUniformMatrix4fv)
   }
 
   inline void glUseProgram (GLuint program) const
   {
     ::glUseProgram (program);
+    OpenGl_TRACE(glUseProgram)
   }
 
   inline void glValidateProgram (GLuint program) const
   {
     ::glValidateProgram (program);
+    OpenGl_TRACE(glValidateProgram)
   }
 
   inline void glVertexAttrib1f (GLuint index, GLfloat x) const
   {
     ::glVertexAttrib1f (index, x);
+    OpenGl_TRACE(glVertexAttrib1f)
   }
 
   inline void glVertexAttrib1fv (GLuint index, const GLfloat* v) const
   {
     ::glVertexAttrib1fv (index, v);
+    OpenGl_TRACE(glVertexAttrib1fv)
   }
 
   inline void glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y) const
   {
     ::glVertexAttrib2f (index, x, y);
+    OpenGl_TRACE(glVertexAttrib2f)
   }
 
   inline void glVertexAttrib2fv (GLuint index, const GLfloat* v) const
   {
     ::glVertexAttrib2fv (index, v);
+    OpenGl_TRACE(glVertexAttrib2fv)
   }
 
   inline void glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z) const
   {
     ::glVertexAttrib3f (index, x, y, z);
+    OpenGl_TRACE(glVertexAttrib3f)
   }
 
   inline void glVertexAttrib3fv (GLuint index, const GLfloat* v) const
   {
     ::glVertexAttrib3fv (index, v);
+    OpenGl_TRACE(glVertexAttrib3fv)
   }
 
   inline void glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) const
   {
     ::glVertexAttrib4f (index, x, y, z, w);
+    OpenGl_TRACE(glVertexAttrib4f)
   }
 
   inline void glVertexAttrib4fv (GLuint index, const GLfloat* v) const
   {
     ::glVertexAttrib4fv (index, v);
+    OpenGl_TRACE(glVertexAttrib4fv)
   }
 
   inline void glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer) const
   {
     ::glVertexAttribPointer (index, size, type, normalized, stride, pointer);
+    OpenGl_TRACE(glVertexAttribPointer)
   }
 
 public: //! @name OpenGL ES 3.0

src/OpenGl/OpenGl_SceneGeometry.cxx

@@ -404,22 +404,22 @@ Standard_Boolean OpenGl_RaytraceGeometry::AcquireTextures (const Handle(OpenGl_C
 
       aTexture->Sampler()->SetImmutable();
       aHandle = theContext->arbTexBindless->glGetTextureSamplerHandleARB (aTexture->TextureId(), aTexture->Sampler()->SamplerID());
-      const GLenum anErr = glGetError();
+      const GLenum anErr = theContext->core11fwd->glGetError();
       if (anErr != GL_NO_ERROR)
       {
         theContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                                 TCollection_AsciiString ("Error: Failed to get 64-bit handle of OpenGL texture #") + int(anErr));
+                                 TCollection_AsciiString ("Error: Failed to get 64-bit handle of OpenGL texture ") + OpenGl_Context::FormatGlError (anErr));
         myTextureHandles.clear();
         return Standard_False;
       }
     }
 
     theContext->arbTexBindless->glMakeTextureHandleResidentARB (aHandle);
-    const GLenum anErr = glGetError();
+    const GLenum anErr = theContext->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       theContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                               TCollection_AsciiString ("Error: Failed to make OpenGL texture resident #") + int(anErr));
+                               TCollection_AsciiString ("Error: Failed to make OpenGL texture resident ") + OpenGl_Context::FormatGlError (anErr));
       return Standard_False;
     }
   }
@@ -443,11 +443,11 @@ Standard_Boolean OpenGl_RaytraceGeometry::ReleaseTextures (const Handle(OpenGl_C
   for (size_t aTexIter = 0; aTexIter < myTextureHandles.size(); ++aTexIter)
   {
     theContext->arbTexBindless->glMakeTextureHandleNonResidentARB (myTextureHandles[aTexIter]);
-    const GLenum anErr = glGetError();
+    const GLenum anErr = theContext->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       theContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                               TCollection_AsciiString("Error: Failed to make OpenGL texture non-resident #") + int(anErr));
+                               TCollection_AsciiString("Error: Failed to make OpenGL texture non-resident ") + OpenGl_Context::FormatGlError (anErr));
       return Standard_False;
     }
   }
@@ -513,11 +513,11 @@ Standard_Boolean OpenGl_RaytraceGeometry::UpdateTextureHandles (const Handle(Ope
 
     aTexture->Sampler()->SetImmutable();
     aHandle = theContext->arbTexBindless->glGetTextureSamplerHandleARB (aTexture->TextureId(), aTexture->Sampler()->SamplerID());
-    const GLenum anErr = glGetError();
+    const GLenum anErr = theContext->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       theContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                               TCollection_AsciiString ("Error: Failed to get 64-bit handle of OpenGL texture #") + int(anErr));
+                               TCollection_AsciiString ("Error: Failed to get 64-bit handle of OpenGL texture ") + OpenGl_Context::FormatGlError(anErr));
       myTextureHandles.clear();
       return Standard_False;
     }

src/OpenGl/OpenGl_Texture.cxx

@@ -350,13 +350,13 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
   if (aDataPtr != NULL)
   {
     const GLint anAligment = Min ((GLint )theImage->MaxRowAligmentBytes(), 8); // OpenGL supports alignment upto 8 bytes
-    glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
+    theCtx->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
 
   #if !defined(GL_ES_VERSION_2_0)
     // notice that GL_UNPACK_ROW_LENGTH is not available on OpenGL ES 2.0 without GL_EXT_unpack_subimage extension
     const GLint anExtraBytes = GLint(theImage->RowExtraBytes());
     const GLint aPixelsWidth = GLint(theImage->SizeRowBytes() / theImage->SizePixelBytes());
-    glPixelStorei (GL_UNPACK_ROW_LENGTH, (anExtraBytes >= anAligment) ? aPixelsWidth : 0);
+    theCtx->core11fwd->glPixelStorei (GL_UNPACK_ROW_LENGTH, (anExtraBytes >= anAligment) ? aPixelsWidth : 0);
   #endif
   }
 
@@ -370,14 +370,14 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
       applyDefaultSamplerParams (theCtx);
       if (toPatchExisting)
       {
-        glTexSubImage1D (GL_TEXTURE_1D, 0, 0,
+        theCtx->core11fwd->glTexSubImage1D (GL_TEXTURE_1D, 0, 0,
                                             theSizeXY.x(), theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
         Unbind (theCtx);
         return true;
       }
 
       // use proxy to check texture could be created or not
-      glTexImage1D (GL_PROXY_TEXTURE_1D, 0, anIntFormat,
+      theCtx->core11fwd->glTexImage1D (GL_PROXY_TEXTURE_1D, 0, anIntFormat,
                                        theSizeXY.x(), 0,
                                        theFormat.PixelFormat(), theFormat.DataType(), NULL);
       glGetTexLevelParameteriv (GL_PROXY_TEXTURE_1D, 0, GL_TEXTURE_WIDTH, &aTestWidth);
@@ -390,10 +390,10 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
         return false;
       }
 
-      glTexImage1D (GL_TEXTURE_1D, 0, anIntFormat,
+      theCtx->core11fwd->glTexImage1D (GL_TEXTURE_1D, 0, anIntFormat,
                                        theSizeXY.x(), 0,
                                        theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
-      if (glGetError() != GL_NO_ERROR)
+      if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
       {
         Unbind (theCtx);
         Release (theCtx.get());
@@ -419,7 +419,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
       applyDefaultSamplerParams (theCtx);
       if (toPatchExisting)
       {
-        glTexSubImage2D (GL_TEXTURE_2D, 0,
+        theCtx->core11fwd->glTexSubImage2D (GL_TEXTURE_2D, 0,
                                             0, 0,
                                             theSizeXY.x(), theSizeXY.y(),
                                             theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
@@ -428,7 +428,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
         {
           // generate mipmaps
           theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
-          if (glGetError() != GL_NO_ERROR)
+          if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
           {
             myMaxMipLevel = 0;
           }
@@ -440,7 +440,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
 
     #if !defined(GL_ES_VERSION_2_0)
       // use proxy to check texture could be created or not
-      glTexImage2D (GL_PROXY_TEXTURE_2D, 0, anIntFormat,
+      theCtx->core11fwd->glTexImage2D (GL_PROXY_TEXTURE_2D, 0, anIntFormat,
                                        theSizeXY.x(), theSizeXY.y(), 0,
                                        theFormat.PixelFormat(), theFormat.DataType(), NULL);
       glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH,  &aTestWidth);
@@ -455,17 +455,18 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
       }
     #endif
 
-      glTexImage2D (GL_TEXTURE_2D, 0, anIntFormat,
+      theCtx->core11fwd->glTexImage2D (GL_TEXTURE_2D, 0, anIntFormat,
                                        theSizeXY.x(), theSizeXY.y(), 0,
                                        theFormat.PixelFormat(), theFormat.DataType(), aDataPtr);
-      GLenum anErr = glGetError();
+      GLenum anErr = theCtx->core11fwd->glGetError();
       if (anErr != GL_NO_ERROR)
       {
         theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
                              TCollection_AsciiString ("Error: 2D texture ") + theSizeXY.x() + "x" + theSizeXY.y()
-                                                   + " IF: " + int(anIntFormat) + " PF: " + int(theFormat.PixelFormat())
+                                                   + " IF: " + OpenGl_TextureFormat::FormatFormat (anIntFormat)
-                                                   + " DT: " + int(theFormat.DataType())
+                                                   + " PF: " + OpenGl_TextureFormat::FormatFormat (theFormat.PixelFormat())
-                                                   + " can not be created with error " + int(anErr) + ".");
+                                                   + " DT: " + OpenGl_TextureFormat::FormatDataType (theFormat.DataType())
+                                                   + " can not be created with error " + OpenGl_Context::FormatGlError (anErr) + ".");
         Unbind (theCtx);
         Release (theCtx.get());
         return false;
@@ -479,7 +480,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
         // generate mipmaps
         //glHint (GL_GENERATE_MIPMAP_HINT, GL_NICEST);
         theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
-        anErr = glGetError();
+        anErr = theCtx->core11fwd->glGetError();
         if (anErr != GL_NO_ERROR)
         {
           myMaxMipLevel = 0;
@@ -651,9 +652,10 @@ bool OpenGl_Texture::InitCompressed (const Handle(OpenGl_Context)& theCtx,
     {
       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
                            TCollection_AsciiString ("Error: 2D compressed texture ") + aMipSizeXY.x() + "x" + aMipSizeXY.y()
-                           + " IF: " + int(aFormat.Internal()) + " PF: " + int(aFormat.PixelFormat())
+                           + " IF: " + OpenGl_TextureFormat::FormatFormat (aFormat.Internal())
-                           + " DT: " + int(aFormat.DataType())
+                           + " PF: " + OpenGl_TextureFormat::FormatFormat (aFormat.PixelFormat())
-                           + " can not be created with error " + int(aTexImgErr) + ".");
+                           + " DT: " + OpenGl_TextureFormat::FormatDataType (aFormat.DataType())
+                           + " can not be created with error " + OpenGl_Context::FormatGlError (aTexImgErr) + ".");
       Unbind (theCtx);
       Release (theCtx.get());
       return false;
@@ -754,7 +756,7 @@ bool OpenGl_Texture::InitRectangle (const Handle(OpenGl_Context)& theCtx,
   // setup the alignment
   OpenGl_UnpackAlignmentSentry::Reset();
 
-  glTexImage2D (GL_PROXY_TEXTURE_RECTANGLE, 0, mySizedFormat,
+  theCtx->core11fwd->glTexImage2D (GL_PROXY_TEXTURE_RECTANGLE, 0, mySizedFormat,
                                    aSizeX, aSizeY, 0,
                                    myTextFormat, GL_FLOAT, NULL);
 
@@ -771,11 +773,11 @@ bool OpenGl_Texture::InitRectangle (const Handle(OpenGl_Context)& theCtx,
     return false;
   }
 
-  glTexImage2D (myTarget, 0, mySizedFormat,
+  theCtx->core11fwd->glTexImage2D (myTarget, 0, mySizedFormat,
                                    aSizeX, aSizeY, 0,
                                    myTextFormat, GL_FLOAT, NULL);
 
-  if (glGetError() != GL_NO_ERROR)
+  if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
   {
     Unbind (theCtx);
     return false;
@@ -868,7 +870,7 @@ bool OpenGl_Texture::Init3D (const Handle(OpenGl_Context)& theCtx,
                                      aSizeXYZ.x(), aSizeXYZ.y(), aSizeXYZ.z(), 0,
                                      theFormat.PixelFormat(), theFormat.DataType(), thePixels);
 
-  if (glGetError() != GL_NO_ERROR)
+  if (theCtx->core11fwd->glGetError() != GL_NO_ERROR)
   {
     Unbind (theCtx);
     Release (theCtx.get());
@@ -1027,9 +1029,10 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
           {
             theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
                                  TCollection_AsciiString ("Error: cubemap compressed texture ") + aMipSizeXY.x() + "x" + aMipSizeXY.y()
-                                 + " IF: " + int(aFormat.Internal()) + " PF: " + int(aFormat.PixelFormat())
+                                 + " IF: " + OpenGl_TextureFormat::FormatFormat (aFormat.Internal())
-                                 + " DT: " + int(aFormat.DataType())
+                                 + " PF: " + OpenGl_TextureFormat::FormatFormat (aFormat.PixelFormat())
-                                 + " can not be created with error " + int(aTexImgErr) + ".");
+                                 + " DT: " + OpenGl_TextureFormat::FormatDataType (aFormat.DataType())
+                                 + " can not be created with error " + OpenGl_Context::FormatGlError (aTexImgErr) + ".");
             Unbind (theCtx);
             Release (theCtx.get());
             return false;
@@ -1049,13 +1052,13 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
       {
 #if !defined(GL_ES_VERSION_2_0)
         const GLint anAligment = Min ((GLint)anImage->MaxRowAligmentBytes(), 8); // OpenGL supports alignment upto 8 bytes
-        glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
+        theCtx->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
 
         // notice that GL_UNPACK_ROW_LENGTH is not available on OpenGL ES 2.0 without GL_EXT_unpack_subimage extension
         const GLint anExtraBytes = GLint(anImage->RowExtraBytes());
         const GLint aPixelsWidth = GLint(anImage->SizeRowBytes() / anImage->SizePixelBytes());
         const GLint aRowLength = (anExtraBytes >= anAligment) ? aPixelsWidth : 0;
-        glPixelStorei (GL_UNPACK_ROW_LENGTH, aRowLength);
+        theCtx->core11fwd->glPixelStorei (GL_UNPACK_ROW_LENGTH, aRowLength);
 #else
         Handle(Image_PixMap) aCopyImage = new Image_PixMap();
         aCopyImage->InitTrash (theFormat, theSize, theSize);
@@ -1071,7 +1074,7 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
         }
         anImage = aCopyImage;
         const GLint anAligment = Min((GLint)anImage->MaxRowAligmentBytes(), 8); // OpenGL supports alignment upto 8 bytes
-        glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
+        theCtx->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, anAligment);
 #endif
         aData = anImage->Data();
       }
@@ -1086,7 +1089,7 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
       theCubeMap->Next();
     }
 
-    glTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
+    theCtx->core11fwd->glTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
                                      anIntFormat,
                                      GLsizei(theSize), GLsizei(theSize),
                                      0, aFormat.PixelFormat(), aFormat.DataType(),
@@ -1094,11 +1097,11 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
 
     OpenGl_UnpackAlignmentSentry::Reset();
 
-    const GLenum anErr = glGetError();
+    const GLenum anErr = theCtx->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                           TCollection_AsciiString ("Unable to initialize side of cubemap. Error #") + int(anErr));
+                           TCollection_AsciiString ("Unable to initialize side of cubemap. Error ") + OpenGl_Context::FormatGlError (anErr));
       Unbind (theCtx);
       Release (theCtx.get());
       return false;
@@ -1108,11 +1111,11 @@ bool OpenGl_Texture::InitCubeMap (const Handle(OpenGl_Context)&    theCtx,
   if (theToGenMipmap && theCtx->arbFBO != NULL)
   {
     theCtx->arbFBO->glGenerateMipmap (myTarget);
-    const GLenum anErr = glGetError();
+    const GLenum anErr = theCtx->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
-                           TCollection_AsciiString ("Unable to generate mipmap of cubemap. Error #") + int(anErr));
+                           TCollection_AsciiString ("Unable to generate mipmap of cubemap. Error ") + OpenGl_Context::FormatGlError (anErr));
       Unbind (theCtx);
       Release (theCtx.get());
       return false;

src/OpenGl/OpenGl_TextureFormat.cxx

@@ -16,6 +16,103 @@
 #include <Image_SupportedFormats.hxx>
 #include <OpenGl_Context.hxx>
 
+// =======================================================================
+// function : FormatFormat
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_TextureFormat::FormatFormat (GLint theInternalFormat)
+{
+  switch (theInternalFormat)
+  {
+    // RED variations (GL_RED, OpenGL 3.0+)
+    case GL_RED:      return "GL_RED";
+    case GL_R8:       return "GL_R8";
+    case 0x822A:      return "GL_R16";
+    case GL_R16F:     return "GL_R16F"; // half-float
+    case GL_R32F:     return "GL_R32F"; // float
+    case GL_R32I:     return "GL_R32I";
+    case GL_RED_INTEGER: return "GL_RED_INTEGER";
+    //
+    case GL_RG:       return "GL_RG";
+    case GL_RG8:      return "GL_RG8";
+    case 0x822C:      return "GL_RG16";
+    case GL_RG16F:    return "GL_RG16F";
+    case GL_RG32F:    return "GL_RG32F";
+    case GL_RG32I:    return "GL_RG32I";
+    case GL_RG_INTEGER: return "GL_RG_INTEGER";
+    // RGB variations
+    case GL_RGB:      return "GL_RGB";
+    case 0x804F:      return "GL_RGB4";
+    case 0x8050:      return "GL_RGB5";
+    case GL_RGB8:     return "GL_RGB8";
+    case GL_SRGB8:    return "GL_SRGB8";
+    case 0x8052:      return "GL_RGB10";
+    case 0x8053:      return "GL_RGB12";
+    case 0x8054:      return "GL_RGB16";
+    case GL_RGB16F:   return "GL_RGB16F"; // half-float
+    case GL_RGB32F:   return "GL_RGB32F"; // float
+    case GL_RGB32I:   return "GL_RGB32I";
+    // RGBA variations
+    case GL_RGBA:     return "GL_RGBA";
+    case GL_RGBA8:    return "GL_RGBA8";
+    case GL_SRGB8_ALPHA8: return "GL_SRGB8_ALPHA8";
+    case GL_RGB10_A2: return "GL_RGB10_A2";
+    case 0x805A:      return "GL_RGBA12";
+    case 0x805B:      return "GL_RGBA16";
+    case GL_RGBA16F:  return "GL_RGBA16F"; // half-float
+    case GL_RGBA32F:  return "GL_RGBA32F"; // float
+    case GL_RGBA32I:  return "GL_RGBA32I";
+    //
+    case 0x80E0:       return "GL_BGR";
+    case GL_BGRA_EXT:  return "GL_BGRA";
+    // ALPHA variations (deprecated)
+    case GL_ALPHA:     return "GL_ALPHA";
+    case 0x803C:       return "GL_ALPHA8";
+    case 0x803E:       return "GL_ALPHA16";
+    case GL_LUMINANCE: return "GL_LUMINANCE";
+    case GL_LUMINANCE_ALPHA: return "GL_LUMINANCE_ALPHA";
+    //
+    case GL_DEPTH_COMPONENT:    return "GL_DEPTH_COMPONENT";
+    case GL_DEPTH_COMPONENT16:  return "GL_DEPTH_COMPONENT16";
+    case GL_DEPTH_COMPONENT24:  return "GL_DEPTH_COMPONENT24";
+    case GL_DEPTH_COMPONENT32F: return "GL_DEPTH_COMPONENT32F";
+    case GL_DEPTH_STENCIL:      return "GL_DEPTH_STENCIL";
+    case GL_DEPTH24_STENCIL8:   return "GL_DEPTH24_STENCIL8";
+    case GL_DEPTH32F_STENCIL8:  return "GL_DEPTH32F_STENCIL8";
+    //
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:        return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT";
+    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:       return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT";
+    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT";
+    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT";
+    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT";
+    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+  }
+  return OpenGl_Context::FormatGlEnumHex (theInternalFormat);
+}
+
+// =======================================================================
+// function : FormatDataType
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_TextureFormat::FormatDataType (GLint theDataType)
+{
+  switch (theDataType)
+  {
+    case GL_UNSIGNED_BYTE:     return "GL_UNSIGNED_BYTE";
+    case GL_UNSIGNED_SHORT:    return "GL_UNSIGNED_SHORT";
+    case GL_INT:               return "GL_INT";
+    case GL_UNSIGNED_INT:      return "GL_UNSIGNED_INT";
+    case GL_FLOAT:             return "GL_FLOAT";
+    case GL_HALF_FLOAT:        return "GL_HALF_FLOAT";
+    case 0x8D61:               return "GL_HALF_FLOAT_OES";
+    case GL_UNSIGNED_INT_24_8: return "GL_UNSIGNED_INT_24_8";
+    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV";
+  }
+  return OpenGl_Context::FormatGlEnumHex (theDataType);
+}
+
 // =======================================================================
 // function : FindFormat
 // purpose  :

src/OpenGl/OpenGl_TextureFormat.hxx

@@ -18,6 +18,7 @@
 #include <Image_Format.hxx>
 #include <OpenGl_GlCore13.hxx>
 #include <Standard_Handle.hxx>
+#include <TCollection_AsciiString.hxx>
 
 class OpenGl_Context;
 
@@ -56,6 +57,12 @@ public:
                                                                     Image_CompressedFormat theFormat,
                                                                     bool theIsColorMap);
 
+  //! Format pixel format enumeration.
+  Standard_EXPORT static TCollection_AsciiString FormatFormat (GLint theInternalFormat);
+
+  //! Format data type enumeration.
+  Standard_EXPORT static TCollection_AsciiString FormatDataType (GLint theDataType);
+
 public:
 
   //! Empty constructor (invalid texture format).

src/OpenGl/OpenGl_TileSampler.cxx

@@ -57,7 +57,7 @@ void OpenGl_TileSampler::GrabVarianceMap (const Handle(OpenGl_Context)& theConte
   if (anErr != GL_NO_ERROR)
   {
     theContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_MEDIUM,
-                             "Error! Failed to fetch visual error map from the GPU");
+                             TCollection_AsciiString ("Error! Failed to fetch visual error map from the GPU ") + OpenGl_Context::FormatGlError (anErr));
     return;
   }
 #else

src/OpenGl/OpenGl_VertexBuffer.cxx

@@ -20,6 +20,21 @@
 
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_VertexBuffer,OpenGl_Resource)
 
+// =======================================================================
+// function : FormatTarget
+// purpose  :
+// =======================================================================
+TCollection_AsciiString OpenGl_VertexBuffer::FormatTarget (GLenum theTarget)
+{
+  switch (theTarget)
+  {
+    case GL_ARRAY_BUFFER:         return "GL_ARRAY_BUFFER";
+    case GL_ELEMENT_ARRAY_BUFFER: return "GL_ELEMENT_ARRAY_BUFFER";
+    case GL_TEXTURE_BUFFER:       return "GL_TEXTURE_BUFFER";
+  }
+  return OpenGl_Context::FormatGlEnumHex (theTarget);
+}
+
 // =======================================================================
 // function : OpenGl_VertexBuffer
 // purpose  :
@@ -128,9 +143,19 @@ bool OpenGl_VertexBuffer::init (const Handle(OpenGl_Context)& theGlCtx,
   myComponentsNb = theComponentsNb;
   myElemsNb      = theElemsNb;
   theGlCtx->core15fwd->glBufferData (GetTarget(), GLsizeiptr(myElemsNb) * theStride, theData, GL_STATIC_DRAW);
-  bool isDone = (glGetError() == GL_NO_ERROR); // GL_OUT_OF_MEMORY
+  const int anErr = theGlCtx->core15fwd->glGetError();
+  if (anErr != GL_NO_ERROR
+   && anErr != GL_OUT_OF_MEMORY) // pass-through out-of-memory error, but log unexpected errors
+  {
+    theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+                           TCollection_AsciiString ("Error: glBufferData (")
+                           + FormatTarget (GetTarget()) + ","
+                           + OpenGl_Context::FormatSize (GLsizeiptr(myElemsNb) * theStride) + ","
+                           + OpenGl_Context::FormatPointer (theData) + ") Id: " + (int )myBufferId
+                           + " failed with " + OpenGl_Context::FormatGlError (anErr));
+  }
   Unbind (theGlCtx);
-  return isDone;
+  return anErr == GL_NO_ERROR;
 }
 
 // =======================================================================
@@ -155,9 +180,19 @@ bool OpenGl_VertexBuffer::subData (const Handle(OpenGl_Context)& theGlCtx,
                                         GLintptr(theElemFrom)  * GLintptr  (myComponentsNb) * aDataSize, // offset in bytes
                                         GLsizeiptr(theElemsNb) * GLsizeiptr(myComponentsNb) * aDataSize, // size   in bytes
                                         theData);
-  bool isDone = (glGetError() == GL_NO_ERROR); // some dummy error
+  const int anErr = theGlCtx->core15fwd->glGetError();
+  if (anErr != GL_NO_ERROR)
+  {
+    theGlCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+                           TCollection_AsciiString ("Error: glBufferSubData (")
+                           + FormatTarget (GetTarget()) + ","
+                           + OpenGl_Context::FormatSize (GLintptr(theElemFrom)  * GLintptr  (myComponentsNb) * aDataSize) + ","
+                           + OpenGl_Context::FormatSize (GLsizeiptr(theElemsNb) * GLsizeiptr(myComponentsNb) * aDataSize) + ","
+                           + OpenGl_Context::FormatPointer (theData) + ") Id: " + (int )myBufferId
+                           + " failed with " + OpenGl_Context::FormatGlError (anErr));
+  }
   Unbind (theGlCtx);
-  return isDone;
+  return anErr == GL_NO_ERROR;
 }
 
 // =======================================================================

src/OpenGl/OpenGl_VertexBuffer.hxx

@@ -32,6 +32,9 @@ public:
   //! Helpful constants
   static const GLuint NO_BUFFER = 0;
 
+  //! Format VBO target enumeration value.
+  Standard_EXPORT static TCollection_AsciiString FormatTarget (GLenum theTarget);
+
 public:
 
   //! Create uninitialized VBO.

src/OpenGl/OpenGl_View.cxx

@@ -2580,7 +2580,7 @@ bool OpenGl_View::blitBuffers (OpenGl_FrameBuffer*    theReadFbo,
     aCtx->arbFBOBlit->glBlitFramebuffer (0, 0, aReadSizeX, aReadSizeY,
                                          0, 0, aDrawSizeX, aDrawSizeY,
                                          aCopyMask, GL_NEAREST);
-    const int anErr = ::glGetError();
+    const int anErr = aCtx->core11fwd->glGetError();
     if (anErr != GL_NO_ERROR)
     {
       // glBlitFramebuffer() might fail in several cases:
@@ -2592,18 +2592,14 @@ bool OpenGl_View::blitBuffers (OpenGl_FrameBuffer*    theReadFbo,
       // - Pixel formats of FBOs do not match.
       //   This also might happen with window has pixel format,
       //   e.g. Mesa fails blitting RGBA8 -> RGB8 while other drivers support this conversion.
-      TCollection_ExtendedString aMsg = TCollection_ExtendedString() + "FBO blitting has failed [Error #" + anErr + "]\n"
+      TCollection_ExtendedString aMsg = TCollection_ExtendedString() + "FBO blitting has failed [Error " + OpenGl_Context::FormatGlError (anErr) + "]\n"
                                       + "  Please check your graphics driver settings or try updating driver.";
       if (theReadFbo->NbSamples() != 0)
       {
         myToDisableMSAA = true;
         aMsg += "\n  MSAA settings should not be overridden by driver!";
       }
-      aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+      aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
-                         GL_DEBUG_TYPE_ERROR,
-                         0,
-                         GL_DEBUG_SEVERITY_HIGH,
-                         aMsg);
     }
 
     if (theDrawFbo != NULL

src/Standard/Standard_TypeDef.hxx

@@ -37,16 +37,22 @@
 #if(defined(_MSC_VER) && (_MSC_VER < 1800))
   // only Visual Studio 2013 (vc12) provides <cinttypes> header
   // we do not defined all macros here - only used by OCCT framework
+  #define PRIx64 "I64x"
+  #define PRIX64 "I64X"
   #define PRId64 "I64d"
   #define PRIu64 "I64u"
   #define SCNd64 "I64d"
   #define SCNu64 "I64u"
   #ifdef _WIN64
+    #define PRIxPTR "I64x"
+    #define PRIXPTR "I64X"
     #define PRIdPTR "I64d"
     #define PRIuPTR "I64u"
     #define SCNdPTR "I64d"
     #define SCNuPTR "I64u"
   #else
+    #define PRIxPTR "Ix"
+    #define PRIXPTR "IX"
     #define PRIdPTR "d"
     #define PRIuPTR "u"
     #define SCNdPTR "d"