Don't use parameters and functions which are not supported by OpenGL ES.

Remove the usage of unsupported functions and invalid parameters of
various functions (e.g. Enable/Disable/Get/etc).

renderdoc/driver/gl/gl_common.cpp

@@ -33,6 +33,7 @@ bool VendorCheck[VendorCheck_Count] = {};
 
 int GLCoreVersion = 0;
 bool GLIsCore = false;
+bool IsGLES = false;
 
 bool CheckReplayContext(PFNGLGETSTRINGPROC getStr, PFNGLGETINTEGERVPROC getInt,
                         PFNGLGETSTRINGIPROC getStri)
@@ -383,6 +384,12 @@ void CheckExtensions(const GLHookSet &gl)
     const char *version = (const char *)gl.glGetString(eGL_VERSION);
 
     RDCLOG("Vendor checks for %u (%s / %s / %s)", GLCoreVersion, vendor, renderer, version);
+
+    // check whether we are using OpenGL ES
+    // GL_VERSION for OpenGL ES:
+    //   "OpenGL ES N.M vendor-specific information"
+    if(strncmp(version, "OpenGL ES", 9) == 0)
+      IsGLES = true;
   }
 
   if(gl.glGetStringi)
@@ -444,8 +451,12 @@ void DoVendorChecks(const GLHookSet &gl, GLPlatform &platform, GLWindowingData c
     }
   }
 
-  if(gl.glGetIntegerv && gl.glGetError)
+  if(gl.glGetIntegerv && gl.glGetError && !IsGLES)
   {
+    // NOTE: in case of OpenGL ES the GL_NV_polygon_mode extension can be used, however even if the
+    // driver reports that the extension is supported, it always throws errors when we try to use it
+    // (at least with the current NVIDIA driver)
+
     // clear all error flags.
     GLenum err = eGL_NONE;
     ClearGLErrors(gl);

renderdoc/driver/gl/gl_common.h

@@ -262,52 +262,58 @@ void GetBindpointMapping(const GLHookSet &gl, GLuint curProg, int shadIdx, Shade
 
 extern int GLCoreVersion;
 extern bool GLIsCore;
+extern bool IsGLES;
 
 // list of extensions and the version when they became core
 // 99 means the extension never became core, so you can easily
 // just do a check of CoreVersion >= NN and they will always fail.
-#define EXTENSION_CHECKS()                           \
-  EXT_TO_CHECK(33, ARB_explicit_attrib_location)     \
-  EXT_TO_CHECK(33, ARB_sampler_objects)              \
-  EXT_TO_CHECK(33, ARB_texture_swizzle)              \
-  EXT_TO_CHECK(40, ARB_draw_buffers_blend)           \
-  EXT_TO_CHECK(40, ARB_draw_indirect)                \
-  EXT_TO_CHECK(40, ARB_gpu_shader5)                  \
-  EXT_TO_CHECK(40, ARB_sample_shading)               \
-  EXT_TO_CHECK(40, ARB_shader_subroutine)            \
-  EXT_TO_CHECK(40, ARB_tessellation_shader)          \
-  EXT_TO_CHECK(40, ARB_texture_cube_map_array)       \
-  EXT_TO_CHECK(40, ARB_transform_feedback2)          \
-  EXT_TO_CHECK(41, ARB_separate_shader_objects)      \
-  EXT_TO_CHECK(41, ARB_viewport_array)               \
-  EXT_TO_CHECK(42, ARB_base_instance)                \
-  EXT_TO_CHECK(42, ARB_shader_atomic_counters)       \
-  EXT_TO_CHECK(42, ARB_shader_image_load_store)      \
-  EXT_TO_CHECK(42, ARB_shading_language_420pack)     \
-  EXT_TO_CHECK(42, ARB_texture_storage)              \
-  EXT_TO_CHECK(43, ARB_clear_buffer_object)          \
-  EXT_TO_CHECK(43, ARB_compute_shader)               \
-  EXT_TO_CHECK(43, ARB_copy_image)                   \
-  EXT_TO_CHECK(43, ARB_ES3_compatibility)            \
-  EXT_TO_CHECK(43, ARB_internalformat_query2)        \
-  EXT_TO_CHECK(43, ARB_program_interface_query)      \
-  EXT_TO_CHECK(43, ARB_shader_storage_buffer_object) \
-  EXT_TO_CHECK(43, ARB_stencil_texturing)            \
-  EXT_TO_CHECK(43, ARB_texture_storage_multisample)  \
-  EXT_TO_CHECK(43, ARB_texture_view)                 \
-  EXT_TO_CHECK(43, ARB_vertex_attrib_binding)        \
-  EXT_TO_CHECK(43, KHR_debug)                        \
-  EXT_TO_CHECK(44, ARB_enhanced_layouts)             \
-  EXT_TO_CHECK(44, ARB_query_buffer_object)          \
-  EXT_TO_CHECK(45, ARB_clip_control)                 \
-  EXT_TO_CHECK(99, ARB_indirect_parameters)          \
-  EXT_TO_CHECK(99, ARB_seamless_cubemap_per_texture) \
-  EXT_TO_CHECK(99, EXT_depth_bounds_test)            \
-  EXT_TO_CHECK(99, EXT_direct_state_access)          \
-  EXT_TO_CHECK(99, EXT_polygon_offset_clamp)         \
-  EXT_TO_CHECK(99, EXT_raster_multisample)           \
-  EXT_TO_CHECK(99, EXT_texture_swizzle)              \
-  EXT_TO_CHECK(99, KHR_blend_equation_advanced_coherent)
+#define EXTENSION_CHECKS()                               \
+  EXT_TO_CHECK(33, ARB_explicit_attrib_location)         \
+  EXT_TO_CHECK(33, ARB_sampler_objects)                  \
+  EXT_TO_CHECK(33, ARB_texture_swizzle)                  \
+  EXT_TO_CHECK(40, ARB_draw_buffers_blend)               \
+  EXT_TO_CHECK(40, ARB_draw_indirect)                    \
+  EXT_TO_CHECK(40, ARB_gpu_shader5)                      \
+  EXT_TO_CHECK(40, ARB_sample_shading)                   \
+  EXT_TO_CHECK(40, ARB_shader_subroutine)                \
+  EXT_TO_CHECK(40, ARB_tessellation_shader)              \
+  EXT_TO_CHECK(40, ARB_texture_cube_map_array)           \
+  EXT_TO_CHECK(40, ARB_transform_feedback2)              \
+  EXT_TO_CHECK(41, ARB_separate_shader_objects)          \
+  EXT_TO_CHECK(41, ARB_viewport_array)                   \
+  EXT_TO_CHECK(42, ARB_base_instance)                    \
+  EXT_TO_CHECK(42, ARB_shader_atomic_counters)           \
+  EXT_TO_CHECK(42, ARB_shader_image_load_store)          \
+  EXT_TO_CHECK(42, ARB_shading_language_420pack)         \
+  EXT_TO_CHECK(42, ARB_texture_storage)                  \
+  EXT_TO_CHECK(43, ARB_clear_buffer_object)              \
+  EXT_TO_CHECK(43, ARB_compute_shader)                   \
+  EXT_TO_CHECK(43, ARB_copy_image)                       \
+  EXT_TO_CHECK(43, ARB_ES3_compatibility)                \
+  EXT_TO_CHECK(43, ARB_internalformat_query2)            \
+  EXT_TO_CHECK(43, ARB_program_interface_query)          \
+  EXT_TO_CHECK(43, ARB_shader_storage_buffer_object)     \
+  EXT_TO_CHECK(43, ARB_stencil_texturing)                \
+  EXT_TO_CHECK(43, ARB_texture_storage_multisample)      \
+  EXT_TO_CHECK(43, ARB_texture_view)                     \
+  EXT_TO_CHECK(43, ARB_vertex_attrib_binding)            \
+  EXT_TO_CHECK(43, KHR_debug)                            \
+  EXT_TO_CHECK(44, ARB_enhanced_layouts)                 \
+  EXT_TO_CHECK(44, ARB_query_buffer_object)              \
+  EXT_TO_CHECK(45, ARB_clip_control)                     \
+  EXT_TO_CHECK(99, ARB_indirect_parameters)              \
+  EXT_TO_CHECK(99, ARB_seamless_cubemap_per_texture)     \
+  EXT_TO_CHECK(99, EXT_depth_bounds_test)                \
+  EXT_TO_CHECK(99, EXT_direct_state_access)              \
+  EXT_TO_CHECK(99, EXT_polygon_offset_clamp)             \
+  EXT_TO_CHECK(99, EXT_raster_multisample)               \
+  EXT_TO_CHECK(99, EXT_texture_swizzle)                  \
+  EXT_TO_CHECK(99, KHR_blend_equation_advanced_coherent) \
+  /* OpenGL ES extensions */                             \
+  EXT_TO_CHECK(99, EXT_clip_cull_distance)               \
+  EXT_TO_CHECK(99, EXT_multisample_compatibility)        \
+  EXT_TO_CHECK(99, NV_polygon_mode)                      \
+  EXT_TO_CHECK(99, OES_sample_shading)
 
 // extensions we know we want to check for are precached, indexd by this enum
 enum ExtensionCheckEnum

renderdoc/driver/gl/gl_debug.cpp

@@ -213,6 +213,12 @@ GLuint GLReplay::CreateShaderProgram(const vector<string> &vsSources,
 
 void GLReplay::CheckGLSLVersion(const char *sl, int &glslVersion)
 {
+  // GL_SHADING_LANGUAGE_VERSION for OpenGL ES:
+  //   "OpenGL ES GLSL ES N.M vendor-specific information"
+  static const char *const GLSL_ES_STR = "OpenGL ES GLSL ES";
+  if(strncmp(sl, GLSL_ES_STR, 17) == 0)
+    sl += 18;
+
   if(sl[0] >= '0' && sl[0] <= '9' && sl[1] == '.' && sl[2] >= '0' && sl[2] <= '9')
   {
     int major = int(sl[0] - '0');
@@ -267,7 +273,7 @@ void GLReplay::InitDebugData()
   int glslCSVer;    // compute shader
   ShaderType shaderType;
 
-  if(m_pDriver->isGLESMode())
+  if(IsGLES)
   {
     glslVersion = glslBaseVer = glslCSVer = 310;
     shaderType = eShaderGLSLES;
@@ -299,7 +305,7 @@ void GLReplay::InitDebugData()
 
   RenderDoc::Inst().SetProgress(DebugManagerInit, 0.2f);
 
-  if(GLCoreVersion >= 43 && !m_pDriver->isGLESMode())    // TODO gles
+  if(GLCoreVersion >= 43 && !IsGLES)
   {
     GLint numsl = 0;
     gl.glGetIntegerv(eGL_NUM_SHADING_LANGUAGE_VERSIONS, &numsl);

renderdoc/driver/gl/gl_driver.cpp

@@ -1104,7 +1104,7 @@ void WrappedOpenGL::ContextData::AssociateWindow(WrappedOpenGL *gl, void *wndHan
   windows[wndHandle] = Timing::GetUnixTimestamp();
 }
 
-void WrappedOpenGL::ContextData::CreateDebugData(const GLHookSet &gl, const bool isGLESMode)
+void WrappedOpenGL::ContextData::CreateDebugData(const GLHookSet &gl)
 {
   // to let us display the overlay on old GL contexts, use as simple a subset of functionality as
   // possible
@@ -1211,7 +1211,7 @@ void WrappedOpenGL::ContextData::CreateDebugData(const GLHookSet &gl, const bool
       int glslVersion;
       string fragDefines;
 
-      if(isGLESMode)
+      if(IsGLES)
       {
         shaderType = eShaderGLSLES;
         glslVersion = 310;
@@ -1556,7 +1556,7 @@ struct RenderTextState
       gl.glGetIntegerv(eGL_BLEND_DST_ALPHA, (GLint *)&DestinationAlpha);
     }
 
-    if(!VendorCheck[VendorCheck_AMD_polygon_mode_query])
+    if(!VendorCheck[VendorCheck_AMD_polygon_mode_query] && !IsGLES)
     {
       GLenum dummy[2] = {eGL_FILL, eGL_FILL};
       // docs suggest this is enumeration[2] even though polygon mode can't be set independently for
@@ -2287,7 +2287,7 @@ void WrappedOpenGL::SwapBuffers(void *windowHandle)
   // that might be shared later (wglShareLists requires contexts to be
   // pristine, so can't create this from wglMakeCurrent)
   if(!ctxdata.ready)
-    ctxdata.CreateDebugData(m_Real, isGLESMode());
+    ctxdata.CreateDebugData(m_Real);
 
   bool activeWindow = RenderDoc::Inst().IsActiveWindow(ctxdata.ctx, windowHandle);
 

renderdoc/driver/gl/gl_driver.h

@@ -413,7 +413,7 @@ private:
     void UnassociateWindow(void *wndHandle);
     void AssociateWindow(WrappedOpenGL *gl, void *wndHandle);
 
-    void CreateDebugData(const GLHookSet &gl, const bool isGLESMode);
+    void CreateDebugData(const GLHookSet &gl);
 
     bool Legacy() { return !attribsCreate || version < 32; }
     bool Modern() { return !Legacy(); }

renderdoc/driver/gl/gl_renderstate.cpp

@@ -26,9 +26,47 @@
 #include "gl_renderstate.h"
 #include "gl_driver.h"
 
+static const GLenum enable_disable_cap[] = {
+    eGL_CLIP_DISTANCE0,
+    eGL_CLIP_DISTANCE1,
+    eGL_CLIP_DISTANCE2,
+    eGL_CLIP_DISTANCE3,
+    eGL_CLIP_DISTANCE4,
+    eGL_CLIP_DISTANCE5,
+    eGL_CLIP_DISTANCE6,
+    eGL_CLIP_DISTANCE7,
+    eGL_COLOR_LOGIC_OP,
+    eGL_CULL_FACE,
+    eGL_DEPTH_CLAMP,
+    eGL_DEPTH_TEST,
+    eGL_DEPTH_BOUNDS_TEST_EXT,
+    eGL_DITHER,
+    eGL_FRAMEBUFFER_SRGB,
+    eGL_LINE_SMOOTH,
+    eGL_MULTISAMPLE,
+    eGL_POLYGON_SMOOTH,
+    eGL_POLYGON_OFFSET_FILL,
+    eGL_POLYGON_OFFSET_LINE,
+    eGL_POLYGON_OFFSET_POINT,
+    eGL_PROGRAM_POINT_SIZE,
+    eGL_PRIMITIVE_RESTART,
+    eGL_PRIMITIVE_RESTART_FIXED_INDEX,
+    eGL_SAMPLE_ALPHA_TO_COVERAGE,
+    eGL_SAMPLE_ALPHA_TO_ONE,
+    eGL_SAMPLE_COVERAGE,
+    eGL_SAMPLE_MASK,
+    eGL_SAMPLE_SHADING,
+    eGL_RASTER_MULTISAMPLE_EXT,
+    eGL_STENCIL_TEST,
+    eGL_TEXTURE_CUBE_MAP_SEAMLESS,
+    eGL_BLEND_ADVANCED_COHERENT_KHR,
+    eGL_RASTERIZER_DISCARD,
+};
+
 void PixelUnpackState::Fetch(const GLHookSet *funcs, bool compressed)
 {
-  funcs->glGetIntegerv(eGL_UNPACK_SWAP_BYTES, &swapBytes);
+  if(!IsGLES)
+    funcs->glGetIntegerv(eGL_UNPACK_SWAP_BYTES, &swapBytes);
   funcs->glGetIntegerv(eGL_UNPACK_ROW_LENGTH, &rowlength);
   funcs->glGetIntegerv(eGL_UNPACK_IMAGE_HEIGHT, &imageheight);
   funcs->glGetIntegerv(eGL_UNPACK_SKIP_PIXELS, &skipPixels);
@@ -36,7 +74,7 @@ void PixelUnpackState::Fetch(const GLHookSet *funcs, bool compressed)
   funcs->glGetIntegerv(eGL_UNPACK_SKIP_IMAGES, &skipImages);
   funcs->glGetIntegerv(eGL_UNPACK_ALIGNMENT, &alignment);
 
-  if(compressed)
+  if(!IsGLES && compressed)
   {
     funcs->glGetIntegerv(eGL_UNPACK_COMPRESSED_BLOCK_WIDTH, &compressedBlockWidth);
     funcs->glGetIntegerv(eGL_UNPACK_COMPRESSED_BLOCK_HEIGHT, &compressedBlockHeight);
@@ -47,7 +85,8 @@ void PixelUnpackState::Fetch(const GLHookSet *funcs, bool compressed)
 
 void PixelUnpackState::Apply(const GLHookSet *funcs, bool compressed)
 {
-  funcs->glPixelStorei(eGL_UNPACK_SWAP_BYTES, swapBytes);
+  if(!IsGLES)
+    funcs->glPixelStorei(eGL_UNPACK_SWAP_BYTES, swapBytes);
   funcs->glPixelStorei(eGL_UNPACK_ROW_LENGTH, rowlength);
   funcs->glPixelStorei(eGL_UNPACK_IMAGE_HEIGHT, imageheight);
   funcs->glPixelStorei(eGL_UNPACK_SKIP_PIXELS, skipPixels);
@@ -55,7 +94,7 @@ void PixelUnpackState::Apply(const GLHookSet *funcs, bool compressed)
   funcs->glPixelStorei(eGL_UNPACK_SKIP_IMAGES, skipImages);
   funcs->glPixelStorei(eGL_UNPACK_ALIGNMENT, alignment);
 
-  if(compressed)
+  if(!IsGLES && compressed)
   {
     funcs->glPixelStorei(eGL_UNPACK_COMPRESSED_BLOCK_WIDTH, compressedBlockWidth);
     funcs->glPixelStorei(eGL_UNPACK_COMPRESSED_BLOCK_HEIGHT, compressedBlockHeight);
@@ -512,6 +551,71 @@ void GLRenderState::MarkDirty(WrappedOpenGL *gl)
   }
 }
 
+bool GLRenderState::CheckEnableDisableParam(GLenum pname)
+{
+  RDCCOMPILE_ASSERT(ARRAY_COUNT(enable_disable_cap) == eEnabled_Count,
+                    "Wrong number of capabilities");
+
+  if(IsGLES)
+  {
+    switch(pname)
+    {
+      case eGL_COLOR_LOGIC_OP:
+      case eGL_DEPTH_CLAMP:
+      case eGL_DEPTH_BOUNDS_TEST_EXT:
+      case eGL_LINE_SMOOTH:
+      case eGL_POLYGON_SMOOTH:
+      case eGL_PROGRAM_POINT_SIZE:
+      case eGL_PRIMITIVE_RESTART:
+      case eGL_TEXTURE_CUBE_MAP_SEAMLESS:
+        // these are not supported by OpenGL ES
+        return false;
+
+      case eGL_POLYGON_OFFSET_LINE:
+      case eGL_POLYGON_OFFSET_POINT:
+        // these are in GL_NV_polygon_mode, however they are not accepted by the NVIDIA driver
+        // see DoVendorChecks()
+        return false;
+
+      case eGL_CLIP_DISTANCE0:
+      case eGL_CLIP_DISTANCE1:
+      case eGL_CLIP_DISTANCE2:
+      case eGL_CLIP_DISTANCE3:
+      case eGL_CLIP_DISTANCE4:
+      case eGL_CLIP_DISTANCE5:
+      case eGL_CLIP_DISTANCE6:
+      case eGL_CLIP_DISTANCE7: return HasExt[EXT_clip_cull_distance];
+
+      case eGL_SAMPLE_ALPHA_TO_ONE:
+      case eGL_MULTISAMPLE: return HasExt[EXT_multisample_compatibility];
+
+      case eGL_SAMPLE_SHADING: return HasExt[OES_sample_shading];
+
+      default: break;
+    }
+  }
+  else
+  {
+    switch(pname)
+    {
+      case eGL_DEPTH_BOUNDS_TEST_EXT: return HasExt[EXT_depth_bounds_test];
+      case eGL_SAMPLE_SHADING: return HasExt[ARB_sample_shading];
+      case eGL_PRIMITIVE_RESTART_FIXED_INDEX: return HasExt[ARB_ES3_compatibility];
+      default: break;
+    }
+  }
+
+  // both OpenGL and OpenGL ES
+  switch(pname)
+  {
+    case eGL_BLEND_ADVANCED_COHERENT_KHR: return HasExt[KHR_blend_equation_advanced_coherent];
+    case eGL_RASTER_MULTISAMPLE_EXT: return HasExt[EXT_raster_multisample];
+    default: break;
+  }
+
+  return true;
+}
+
 void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
 {
   GLint boolread = 0;
@@ -522,80 +626,15 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
     return;
   }
 
+  for(GLuint i = 0; i < eEnabled_Count; i++)
   {
-    GLenum pnames[] = {
-        eGL_CLIP_DISTANCE0,
-        eGL_CLIP_DISTANCE1,
-        eGL_CLIP_DISTANCE2,
-        eGL_CLIP_DISTANCE3,
-        eGL_CLIP_DISTANCE4,
-        eGL_CLIP_DISTANCE5,
-        eGL_CLIP_DISTANCE6,
-        eGL_CLIP_DISTANCE7,
-        eGL_COLOR_LOGIC_OP,
-        eGL_CULL_FACE,
-        eGL_DEPTH_CLAMP,
-        eGL_DEPTH_TEST,
-        eGL_DEPTH_BOUNDS_TEST_EXT,
-        eGL_DITHER,
-        eGL_FRAMEBUFFER_SRGB,
-        eGL_LINE_SMOOTH,
-        eGL_MULTISAMPLE,
-        eGL_POLYGON_SMOOTH,
-        eGL_POLYGON_OFFSET_FILL,
-        eGL_POLYGON_OFFSET_LINE,
-        eGL_POLYGON_OFFSET_POINT,
-        eGL_PROGRAM_POINT_SIZE,
-        eGL_PRIMITIVE_RESTART,
-        eGL_PRIMITIVE_RESTART_FIXED_INDEX,
-        eGL_SAMPLE_ALPHA_TO_COVERAGE,
-        eGL_SAMPLE_ALPHA_TO_ONE,
-        eGL_SAMPLE_COVERAGE,
-        eGL_SAMPLE_MASK,
-        eGL_SAMPLE_SHADING,
-        eGL_RASTER_MULTISAMPLE_EXT,
-        eGL_STENCIL_TEST,
-        eGL_TEXTURE_CUBE_MAP_SEAMLESS,
-        eGL_BLEND_ADVANCED_COHERENT_KHR,
-        eGL_RASTERIZER_DISCARD,
-    };
-
-    RDCCOMPILE_ASSERT(ARRAY_COUNT(pnames) == eEnabled_Count, "Wrong number of pnames");
-
-    for(GLuint i = 0; i < eEnabled_Count; i++)
+    if(!CheckEnableDisableParam(enable_disable_cap[i]))
     {
-      if(pnames[i] == eGL_BLEND_ADVANCED_COHERENT_KHR && !HasExt[KHR_blend_equation_advanced_coherent])
-      {
-        Enabled[i] = true;
-        continue;
-      }
-
-      if(pnames[i] == eGL_RASTER_MULTISAMPLE_EXT && !HasExt[EXT_raster_multisample])
-      {
-        Enabled[i] = false;
-        continue;
-      }
-
-      if(pnames[i] == eGL_DEPTH_BOUNDS_TEST_EXT && !HasExt[EXT_depth_bounds_test])
-      {
-        Enabled[i] = false;
-        continue;
-      }
-
-      if(pnames[i] == eGL_SAMPLE_SHADING && !HasExt[ARB_sample_shading])
-      {
-        Enabled[i] = false;
-        continue;
-      }
-
-      if(pnames[i] == eGL_PRIMITIVE_RESTART_FIXED_INDEX && !HasExt[ARB_ES3_compatibility])
-      {
-        Enabled[i] = false;
-        continue;
-      }
-
-      Enabled[i] = (m_Real->glIsEnabled(pnames[i]) == GL_TRUE);
+      Enabled[i] = false;
+      continue;
     }
+
+    Enabled[i] = (m_Real->glIsEnabled(enable_disable_cap[i]) == GL_TRUE);
   }
 
   m_Real->glGetIntegerv(eGL_ACTIVE_TEXTURE, (GLint *)&ActiveTexture);
@@ -615,13 +654,22 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
   for(GLuint i = 0; i < RDCMIN(maxTextures, (GLuint)ARRAY_COUNT(Tex2D)); i++)
   {
     m_Real->glActiveTexture(GLenum(eGL_TEXTURE0 + i));
-    m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_1D, (GLint *)&Tex1D[i]);
+    if(!IsGLES)
+      m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_1D, (GLint *)&Tex1D[i]);
+    else
+      Tex1D[i] = 0;
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_2D, (GLint *)&Tex2D[i]);
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_3D, (GLint *)&Tex3D[i]);
-    m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_1D_ARRAY, (GLint *)&Tex1DArray[i]);
+    if(!IsGLES)
+      m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_1D_ARRAY, (GLint *)&Tex1DArray[i]);
+    else
+      Tex1DArray[i] = 0;
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_2D_ARRAY, (GLint *)&Tex2DArray[i]);
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_CUBE_MAP, (GLint *)&TexCube[i]);
-    m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_RECTANGLE, (GLint *)&TexRect[i]);
+    if(!IsGLES)
+      m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_RECTANGLE, (GLint *)&TexRect[i]);
+    else
+      TexRect[i] = 0;
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_BUFFER, (GLint *)&TexBuffer[i]);
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_2D_MULTISAMPLE, (GLint *)&Tex2DMS[i]);
     m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, (GLint *)&Tex2DMSArray[i]);
@@ -674,10 +722,13 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
   for(GLuint i = 0; i < RDCMIN(maxNumAttribs, (GLuint)ARRAY_COUNT(GenericVertexAttribs)); i++)
     m_Real->glGetVertexAttribfv(i, eGL_CURRENT_VERTEX_ATTRIB, &GenericVertexAttribs[i].x);
 
-  m_Real->glGetFloatv(eGL_POINT_FADE_THRESHOLD_SIZE, &PointFadeThresholdSize);
-  m_Real->glGetIntegerv(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint *)&PointSpriteOrigin);
   m_Real->glGetFloatv(eGL_LINE_WIDTH, &LineWidth);
-  m_Real->glGetFloatv(eGL_POINT_SIZE, &PointSize);
+  if(!IsGLES)
+  {
+    m_Real->glGetFloatv(eGL_POINT_FADE_THRESHOLD_SIZE, &PointFadeThresholdSize);
+    m_Real->glGetIntegerv(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint *)&PointSpriteOrigin);
+    m_Real->glGetFloatv(eGL_POINT_SIZE, &PointSize);
+  }
 
   m_Real->glGetIntegerv(eGL_PRIMITIVE_RESTART_INDEX, (GLint *)&PrimitiveRestartIndex);
   if(HasExt[ARB_clip_control])
@@ -879,7 +930,8 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
     m_Real->glGetFloatv(eGL_VIEWPORT, &Viewports[0].x);
     m_Real->glGetIntegerv(eGL_SCISSOR_BOX, &Scissors[0].x);
     Scissors[0].enabled = (m_Real->glIsEnabled(eGL_SCISSOR_TEST) == GL_TRUE);
-    m_Real->glGetDoublev(eGL_DEPTH_RANGE, &DepthRanges[0].nearZ);
+    if(!IsGLES)
+      m_Real->glGetDoublev(eGL_DEPTH_RANGE, &DepthRanges[0].nearZ);
 
     for(GLuint i = 1; i < (GLuint)ARRAY_COUNT(Viewports); i++)
       memcpy(&Viewports[i], &Viewports[0], sizeof(Viewports[i]));
@@ -887,8 +939,11 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
     for(GLuint i = 1; i < (GLuint)ARRAY_COUNT(Scissors); i++)
       memcpy(&Scissors[i], &Scissors[0], sizeof(Scissors[i]));
 
-    for(GLuint i = 1; i < (GLuint)ARRAY_COUNT(DepthRanges); i++)
-      memcpy(&DepthRanges[i], &DepthRanges[0], sizeof(DepthRanges[i]));
+    if(!IsGLES)
+    {
+      for(GLuint i = 1; i < (GLuint)ARRAY_COUNT(DepthRanges); i++)
+        memcpy(&DepthRanges[i], &DepthRanges[0], sizeof(DepthRanges[i]));
+    }
   }
 
   m_Real->glGetIntegerv(eGL_DRAW_FRAMEBUFFER_BINDING, (GLint *)&DrawFBO);
@@ -906,9 +961,12 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
   m_Real->glBindFramebuffer(eGL_READ_FRAMEBUFFER, ReadFBO);
 
   m_Real->glGetIntegerv(eGL_FRAGMENT_SHADER_DERIVATIVE_HINT, (GLint *)&Hints.Derivatives);
-  m_Real->glGetIntegerv(eGL_LINE_SMOOTH_HINT, (GLint *)&Hints.LineSmooth);
-  m_Real->glGetIntegerv(eGL_POLYGON_SMOOTH_HINT, (GLint *)&Hints.PolySmooth);
-  m_Real->glGetIntegerv(eGL_TEXTURE_COMPRESSION_HINT, (GLint *)&Hints.TexCompression);
+  if(!IsGLES)
+  {
+    m_Real->glGetIntegerv(eGL_LINE_SMOOTH_HINT, (GLint *)&Hints.LineSmooth);
+    m_Real->glGetIntegerv(eGL_POLYGON_SMOOTH_HINT, (GLint *)&Hints.PolySmooth);
+    m_Real->glGetIntegerv(eGL_TEXTURE_COMPRESSION_HINT, (GLint *)&Hints.TexCompression);
+  }
 
   m_Real->glGetBooleanv(eGL_DEPTH_WRITEMASK, &DepthWriteMask);
   m_Real->glGetFloatv(eGL_DEPTH_CLEAR_VALUE, &DepthClearValue);
@@ -977,7 +1035,8 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
   else
     RasterFixed = false;
 
-  m_Real->glGetIntegerv(eGL_LOGIC_OP_MODE, (GLint *)&LogicOp);
+  if(!IsGLES)
+    m_Real->glGetIntegerv(eGL_LOGIC_OP_MODE, (GLint *)&LogicOp);
 
   m_Real->glGetFloatv(eGL_COLOR_CLEAR_VALUE, &ColorClearValue.red);
 
@@ -995,7 +1054,7 @@ void GLRenderState::FetchState(void *ctx, WrappedOpenGL *gl)
         PatchParams.defaultOuterLevel[2] = PatchParams.defaultOuterLevel[3] = 1.0f;
   }
 
-  if(!VendorCheck[VendorCheck_AMD_polygon_mode_query])
+  if(!VendorCheck[VendorCheck_AMD_polygon_mode_query] && !IsGLES)
   {
     // This was listed in docs as enumeration[2] even though polygon mode can't be set independently
     // for front
@@ -1031,68 +1090,15 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
   if(!ContextPresent || ctx == NULL)
     return;
 
+  for(GLuint i = 0; i < eEnabled_Count; i++)
   {
-    GLenum pnames[] = {
-        eGL_CLIP_DISTANCE0,
-        eGL_CLIP_DISTANCE1,
-        eGL_CLIP_DISTANCE2,
-        eGL_CLIP_DISTANCE3,
-        eGL_CLIP_DISTANCE4,
-        eGL_CLIP_DISTANCE5,
-        eGL_CLIP_DISTANCE6,
-        eGL_CLIP_DISTANCE7,
-        eGL_COLOR_LOGIC_OP,
-        eGL_CULL_FACE,
-        eGL_DEPTH_CLAMP,
-        eGL_DEPTH_TEST,
-        eGL_DEPTH_BOUNDS_TEST_EXT,
-        eGL_DITHER,
-        eGL_FRAMEBUFFER_SRGB,
-        eGL_LINE_SMOOTH,
-        eGL_MULTISAMPLE,
-        eGL_POLYGON_SMOOTH,
-        eGL_POLYGON_OFFSET_FILL,
-        eGL_POLYGON_OFFSET_LINE,
-        eGL_POLYGON_OFFSET_POINT,
-        eGL_PROGRAM_POINT_SIZE,
-        eGL_PRIMITIVE_RESTART,
-        eGL_PRIMITIVE_RESTART_FIXED_INDEX,
-        eGL_SAMPLE_ALPHA_TO_COVERAGE,
-        eGL_SAMPLE_ALPHA_TO_ONE,
-        eGL_SAMPLE_COVERAGE,
-        eGL_SAMPLE_MASK,
-        eGL_SAMPLE_SHADING,
-        eGL_RASTER_MULTISAMPLE_EXT,
-        eGL_STENCIL_TEST,
-        eGL_TEXTURE_CUBE_MAP_SEAMLESS,
-        eGL_BLEND_ADVANCED_COHERENT_KHR,
-        eGL_RASTERIZER_DISCARD,
-    };
+    if(!CheckEnableDisableParam(enable_disable_cap[i]))
+      continue;
 
-    RDCCOMPILE_ASSERT(ARRAY_COUNT(pnames) == eEnabled_Count, "Wrong number of pnames");
-
-    for(GLuint i = 0; i < eEnabled_Count; i++)
-    {
-      if(pnames[i] == eGL_BLEND_ADVANCED_COHERENT_KHR && !HasExt[KHR_blend_equation_advanced_coherent])
-        continue;
-
-      if(pnames[i] == eGL_RASTER_MULTISAMPLE_EXT && !HasExt[EXT_raster_multisample])
-        continue;
-
-      if(pnames[i] == eGL_DEPTH_BOUNDS_TEST_EXT && !HasExt[EXT_depth_bounds_test])
-        continue;
-
-      if(pnames[i] == eGL_SAMPLE_SHADING && !HasExt[ARB_sample_shading])
-        continue;
-
-      if(pnames[i] == eGL_PRIMITIVE_RESTART_FIXED_INDEX && !HasExt[ARB_ES3_compatibility])
-        continue;
-
-      if(Enabled[i])
-        m_Real->glEnable(pnames[i]);
-      else
-        m_Real->glDisable(pnames[i]);
-    }
+    if(Enabled[i])
+      m_Real->glEnable(enable_disable_cap[i]);
+    else
+      m_Real->glDisable(enable_disable_cap[i]);
   }
 
   GLuint maxTextures = 0;
@@ -1101,12 +1107,15 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
   for(GLuint i = 0; i < RDCMIN(maxTextures, (GLuint)ARRAY_COUNT(Tex2D)); i++)
   {
     m_Real->glActiveTexture(GLenum(eGL_TEXTURE0 + i));
-    m_Real->glBindTexture(eGL_TEXTURE_1D, Tex1D[i]);
+    if(!IsGLES)
+      m_Real->glBindTexture(eGL_TEXTURE_1D, Tex1D[i]);
     m_Real->glBindTexture(eGL_TEXTURE_2D, Tex2D[i]);
     m_Real->glBindTexture(eGL_TEXTURE_3D, Tex3D[i]);
-    m_Real->glBindTexture(eGL_TEXTURE_1D_ARRAY, Tex1DArray[i]);
+    if(!IsGLES)
+      m_Real->glBindTexture(eGL_TEXTURE_1D_ARRAY, Tex1DArray[i]);
     m_Real->glBindTexture(eGL_TEXTURE_2D_ARRAY, Tex2DArray[i]);
-    m_Real->glBindTexture(eGL_TEXTURE_RECTANGLE, TexRect[i]);
+    if(!IsGLES)
+      m_Real->glBindTexture(eGL_TEXTURE_RECTANGLE, TexRect[i]);
     m_Real->glBindTexture(eGL_TEXTURE_BUFFER, TexBuffer[i]);
     m_Real->glBindTexture(eGL_TEXTURE_CUBE_MAP, TexCube[i]);
     m_Real->glBindTexture(eGL_TEXTURE_2D_MULTISAMPLE, Tex2DMS[i]);
@@ -1148,10 +1157,13 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
   for(GLuint i = 0; i < RDCMIN(maxNumAttribs, (GLuint)ARRAY_COUNT(GenericVertexAttribs)); i++)
     m_Real->glVertexAttrib4fv(i, &GenericVertexAttribs[i].x);
 
-  m_Real->glPointParameterf(eGL_POINT_FADE_THRESHOLD_SIZE, PointFadeThresholdSize);
-  m_Real->glPointParameteri(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint)PointSpriteOrigin);
   m_Real->glLineWidth(LineWidth);
-  m_Real->glPointSize(PointSize);
+  if(!IsGLES)
+  {
+    m_Real->glPointParameterf(eGL_POINT_FADE_THRESHOLD_SIZE, PointFadeThresholdSize);
+    m_Real->glPointParameteri(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint)PointSpriteOrigin);
+    m_Real->glPointSize(PointSize);
+  }
 
   m_Real->glPrimitiveRestartIndex(PrimitiveRestartIndex);
   if(m_Real->glClipControl && HasExt[ARB_clip_control])
@@ -1304,7 +1316,8 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
     else
       m_Real->glDisable(eGL_SCISSOR_TEST);
 
-    m_Real->glDepthRange(DepthRanges[0].nearZ, DepthRanges[0].farZ);
+    if(!IsGLES)
+      m_Real->glDepthRange(DepthRanges[0].nearZ, DepthRanges[0].farZ);
   }
 
   GLenum DBs[8] = {eGL_NONE};
@@ -1353,9 +1366,12 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
   }
 
   m_Real->glHint(eGL_FRAGMENT_SHADER_DERIVATIVE_HINT, Hints.Derivatives);
-  m_Real->glHint(eGL_LINE_SMOOTH_HINT, Hints.LineSmooth);
-  m_Real->glHint(eGL_POLYGON_SMOOTH_HINT, Hints.PolySmooth);
-  m_Real->glHint(eGL_TEXTURE_COMPRESSION_HINT, Hints.TexCompression);
+  if(!IsGLES)
+  {
+    m_Real->glHint(eGL_LINE_SMOOTH_HINT, Hints.LineSmooth);
+    m_Real->glHint(eGL_POLYGON_SMOOTH_HINT, Hints.PolySmooth);
+    m_Real->glHint(eGL_TEXTURE_COMPRESSION_HINT, Hints.TexCompression);
+  }
 
   m_Real->glDepthMask(DepthWriteMask);
   m_Real->glClearDepth(DepthClearValue);
@@ -1392,7 +1408,8 @@ void GLRenderState::ApplyState(void *ctx, WrappedOpenGL *gl)
   if(HasExt[EXT_raster_multisample] && m_Real->glRasterSamplesEXT)
     m_Real->glRasterSamplesEXT(RasterSamples, RasterFixed);
 
-  m_Real->glLogicOp(LogicOp);
+  if(!IsGLES)
+    m_Real->glLogicOp(LogicOp);
 
   m_Real->glClearColor(ColorClearValue.red, ColorClearValue.green, ColorClearValue.blue,
                        ColorClearValue.alpha);

renderdoc/driver/gl/gl_renderstate.h

@@ -282,4 +282,5 @@ private:
   const GLHookSet *m_Real;
 
   Serialiser *GetSerialiser() { return m_pSerialiser; }
+  bool CheckEnableDisableParam(GLenum pname);
 };