Update GL sampler functions to new serialisation

renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp

@@ -27,11 +27,17 @@
 #include "common/common.h"
 #include "strings/string_utils.h"
 
-bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint *samplers)
+static constexpr uint32_t numParams(GLenum pname)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers)));
+  return pname == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U;
+}
 
-  if(m_State == READING)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glGenSamplers(SerialiserType &ser, GLsizei n, GLuint *samplers)
+{
+  SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers)));
+
+  if(IsReplayingAndReading())
   {
     GLuint real = 0;
     m_Real.glGenSamplers(1, &real);
@@ -41,7 +47,7 @@ bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint *samplers)
     GLResource res = SamplerRes(GetCtx(), real);
 
     ResourceId live = m_ResourceManager->RegisterResource(res);
-    GetResourceManager()->AddLiveResource(id, res);
+    GetResourceManager()->AddLiveResource(sampler, res);
   }
 
   return true;
@@ -56,13 +62,14 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers)
     GLResource res = SamplerRes(GetCtx(), samplers[i]);
     ResourceId id = GetResourceManager()->RegisterResource(res);
 
-    if(m_State >= WRITING)
+    if(IsCaptureMode(m_State))
     {
       Chunk *chunk = NULL;
 
       {
-        SCOPED_SERIALISE_CONTEXT(GEN_SAMPLERS);
-        Serialise_glGenSamplers(1, samplers + i);
+        USE_SCRATCH_SERIALISER();
+        SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+        Serialise_glGenSamplers(ser, 1, samplers + i);
 
         chunk = scope.Get();
       }
@@ -79,11 +86,12 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers)
   }
 }
 
-bool WrappedOpenGL::Serialise_glCreateSamplers(GLsizei n, GLuint *samplers)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glCreateSamplers(SerialiserType &ser, GLsizei n, GLuint *samplers)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers)));
+  SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers)));
 
-  if(m_State == READING)
+  if(IsReplayingAndReading())
   {
     GLuint real = 0;
     m_Real.glCreateSamplers(1, &real);
@@ -91,7 +99,7 @@ bool WrappedOpenGL::Serialise_glCreateSamplers(GLsizei n, GLuint *samplers)
     GLResource res = SamplerRes(GetCtx(), real);
 
     ResourceId live = m_ResourceManager->RegisterResource(res);
-    GetResourceManager()->AddLiveResource(id, res);
+    GetResourceManager()->AddLiveResource(sampler, res);
   }
 
   return true;
@@ -106,13 +114,14 @@ void WrappedOpenGL::glCreateSamplers(GLsizei count, GLuint *samplers)
     GLResource res = SamplerRes(GetCtx(), samplers[i]);
     ResourceId id = GetResourceManager()->RegisterResource(res);
 
-    if(m_State >= WRITING)
+    if(IsCaptureMode(m_State))
     {
       Chunk *chunk = NULL;
 
       {
-        SCOPED_SERIALISE_CONTEXT(CREATE_SAMPLERS);
-        Serialise_glCreateSamplers(1, samplers + i);
+        USE_SCRATCH_SERIALISER();
+        SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+        Serialise_glCreateSamplers(ser, 1, samplers + i);
 
         chunk = scope.Get();
       }
@@ -129,25 +138,14 @@ void WrappedOpenGL::glCreateSamplers(GLsizei count, GLuint *samplers)
   }
 }
 
-bool WrappedOpenGL::Serialise_glBindSampler(GLuint unit, GLuint sampler)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glBindSampler(SerialiserType &ser, GLuint unit, GLuint samplerHandle)
 {
-  SERIALISE_ELEMENT(uint32_t, Unit, unit);
-  SERIALISE_ELEMENT(ResourceId, id, sampler
-                                        ? GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))
-                                        : ResourceId());
+  SERIALISE_ELEMENT(unit);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
 
-  if(m_State < WRITING)
-  {
-    if(id == ResourceId())
-    {
-      m_Real.glBindSampler(Unit, 0);
-    }
-    else
-    {
-      GLResource res = GetResourceManager()->GetLiveResource(id);
-      m_Real.glBindSampler(Unit, res.name);
-    }
-  }
+  if(IsReplayingAndReading())
+    m_Real.glBindSampler(unit, sampler.name);
 
   return true;
 }
@@ -156,44 +154,48 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler)
 {
   m_Real.glBindSampler(unit, sampler);
 
-  if(m_State == WRITING_CAPFRAME)
+  if(IsActiveCapturing(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(BIND_SAMPLER);
-    Serialise_glBindSampler(unit, sampler);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glBindSampler(ser, unit, sampler);
 
     m_ContextRecord->AddChunk(scope.Get());
     GetResourceManager()->MarkResourceFrameReferenced(SamplerRes(GetCtx(), sampler), eFrameRef_Read);
   }
 }
 
-bool WrappedOpenGL::Serialise_glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glBindSamplers(SerialiserType &ser, GLuint first, GLsizei count,
+                                             const GLuint *samplerHandles)
 {
-  SERIALISE_ELEMENT(uint32_t, First, first);
-  SERIALISE_ELEMENT(int32_t, Count, count);
+  SERIALISE_ELEMENT(first);
+  SERIALISE_ELEMENT(count);
 
-  GLuint *samps = NULL;
-  if(m_State <= EXECUTING)
-    samps = new GLuint[Count];
+  // can't serialise arrays of GL handles since they're not wrapped or typed :(.
+  GLResource *samplers = NULL;
 
-  for(int32_t i = 0; i < Count; i++)
+  if(ser.IsWriting())
   {
-    SERIALISE_ELEMENT(ResourceId, id,
-                      samplers && samplers[i]
-                          ? GetResourceManager()->GetID(SamplerRes(GetCtx(), samplers[i]))
-                          : ResourceId());
-
-    if(m_State <= EXECUTING)
-    {
-      if(id != ResourceId())
-        samps[i] = GetResourceManager()->GetLiveResource(id).name;
-      else
-        samps[i] = 0;
-    }
+    samplers = new GLResource[count];
+    for(int32_t i = 0; i < count; i++)
+      samplers[i] = SamplerRes(GetCtx(), samplerHandles[i]);
   }
 
-  if(m_State <= EXECUTING)
+  uint32_t numSamps = count;
+
+  SERIALISE_ELEMENT_ARRAY(samplers, numSamps);
+
+  if(ser.IsWriting())
+    SAFE_DELETE_ARRAY(samplers);
+
+  if(IsReplayingAndReading())
   {
-    m_Real.glBindSamplers(First, Count, samps);
+    GLuint *samps = new GLuint[count];
+    for(int32_t i = 0; i < count; i++)
+      samps[i] = samplers[i].name;
+
+    m_Real.glBindSamplers(first, count, samps);
 
     delete[] samps;
   }
@@ -205,10 +207,11 @@ void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *sa
 {
   m_Real.glBindSamplers(first, count, samplers);
 
-  if(m_State == WRITING_CAPFRAME)
+  if(IsActiveCapturing(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(BIND_SAMPLERS);
-    Serialise_glBindSamplers(first, count, samplers);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glBindSamplers(ser, first, count, samplers);
 
     m_ContextRecord->AddChunk(scope.Get());
     for(GLsizei i = 0; i < count; i++)
@@ -218,36 +221,29 @@ void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *sa
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameteri(SerialiserType &ser, GLuint samplerHandle,
+                                                  GLenum pname, GLint param)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-
-  int32_t ParamValue = 0;
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
 
   RDCCOMPILE_ASSERT(sizeof(int32_t) == sizeof(GLenum),
                     "int32_t isn't the same size as GLenum - aliased serialising will break");
   // special case a few parameters to serialise their value as an enum, not an int
-  if(PName == GL_TEXTURE_WRAP_S || PName == GL_TEXTURE_WRAP_T || PName == GL_TEXTURE_WRAP_R ||
-     PName == GL_TEXTURE_MIN_FILTER || PName == GL_TEXTURE_MAG_FILTER ||
-     PName == GL_TEXTURE_COMPARE_MODE || PName == GL_TEXTURE_COMPARE_FUNC)
+  if(pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T || pname == GL_TEXTURE_WRAP_R ||
+     pname == GL_TEXTURE_MIN_FILTER || pname == GL_TEXTURE_MAG_FILTER ||
+     pname == GL_TEXTURE_COMPARE_MODE || pname == GL_TEXTURE_COMPARE_FUNC)
   {
-    SERIALISE_ELEMENT(GLenum, Param, (GLenum)param);
-
-    ParamValue = (int32_t)Param;
+    SERIALISE_ELEMENT_TYPED(GLenum, param);
   }
   else
   {
-    SERIALISE_ELEMENT(int32_t, Param, param);
-
-    ParamValue = Param;
+    SERIALISE_ELEMENT(param);
   }
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameteri(res.name, PName, ParamValue);
-  }
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameteri(sampler.name, pname, param);
 
   return true;
 }
@@ -260,12 +256,13 @@ void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint para
   if(param == eGL_CLAMP)
     param = eGL_CLAMP_TO_EDGE;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERI);
-    Serialise_glSamplerParameteri(sampler, pname, param);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameteri(ser, sampler, pname, param);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -278,17 +275,16 @@ void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint para
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameterf(SerialiserType &ser, GLuint samplerHandle,
+                                                  GLenum pname, GLfloat param)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-  SERIALISE_ELEMENT(float, Param, param);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
+  SERIALISE_ELEMENT(param);
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameterf(res.name, PName, Param);
-  }
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameterf(sampler.name, pname, param);
 
   return true;
 }
@@ -301,12 +297,13 @@ void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat pa
   if(param == (float)eGL_CLAMP)
     param = (float)eGL_CLAMP_TO_EDGE;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERF);
-    Serialise_glSamplerParameterf(sampler, pname, param);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameterf(ser, sampler, pname, param);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -319,20 +316,16 @@ void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat pa
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameteriv(SerialiserType &ser, GLuint samplerHandle,
+                                                   GLenum pname, const GLint *params)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-  const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
-  SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
+  SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname)));
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameteriv(res.name, PName, Params);
-  }
-
-  delete[] Params;
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameteriv(sampler.name, pname, params);
 
   return true;
 }
@@ -346,12 +339,13 @@ void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLi
   if(*params == eGL_CLAMP)
     params = clamptoedge;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIV);
-    Serialise_glSamplerParameteriv(sampler, pname, params);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameteriv(ser, sampler, pname, params);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -364,20 +358,16 @@ void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLi
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameterfv(SerialiserType &ser, GLuint samplerHandle,
+                                                   GLenum pname, const GLfloat *params)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-  const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
-  SERIALISE_ELEMENT_ARR(float, Params, params, nParams);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
+  SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname)));
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameterfv(res.name, PName, Params);
-  }
-
-  delete[] Params;
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameterfv(sampler.name, pname, params);
 
   return true;
 }
@@ -391,12 +381,13 @@ void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLf
   if(*params == (float)eGL_CLAMP)
     params = clamptoedge;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERFV);
-    Serialise_glSamplerParameterfv(sampler, pname, params);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameterfv(ser, sampler, pname, params);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -409,20 +400,16 @@ void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLf
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameterIiv(SerialiserType &ser, GLuint samplerHandle,
+                                                    GLenum pname, const GLint *params)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-  const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
-  SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
+  SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname)));
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameterIiv(res.name, PName, Params);
-  }
-
-  delete[] Params;
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameterIiv(sampler.name, pname, params);
 
   return true;
 }
@@ -436,12 +423,13 @@ void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GL
   if(*params == eGL_CLAMP)
     params = clamptoedge;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIIV);
-    Serialise_glSamplerParameterIiv(sampler, pname, params);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameterIiv(ser, sampler, pname, params);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -454,21 +442,16 @@ void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GL
   }
 }
 
-bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(GLuint sampler, GLenum pname,
-                                                     const GLuint *params)
+template <typename SerialiserType>
+bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(SerialiserType &ser, GLuint samplerHandle,
+                                                     GLenum pname, const GLuint *params)
 {
-  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
-  SERIALISE_ELEMENT(GLenum, PName, pname);
-  const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
-  SERIALISE_ELEMENT_ARR(uint32_t, Params, params, nParams);
+  SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle));
+  SERIALISE_ELEMENT(pname);
+  SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname)));
 
-  if(m_State < WRITING)
-  {
-    GLResource res = GetResourceManager()->GetLiveResource(id);
-    m_Real.glSamplerParameterIuiv(res.name, PName, Params);
-  }
-
-  delete[] Params;
+  if(IsReplayingAndReading())
+    m_Real.glSamplerParameterIuiv(sampler.name, pname, params);
 
   return true;
 }
@@ -482,12 +465,13 @@ void WrappedOpenGL::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const G
   if(*params == eGL_CLAMP)
     params = clamptoedge;
 
-  if(m_State >= WRITING)
+  if(IsCaptureMode(m_State))
   {
-    SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIUIV);
-    Serialise_glSamplerParameterIuiv(sampler, pname, params);
+    USE_SCRATCH_SERIALISER();
+    SCOPED_SERIALISE_CHUNK(gl_CurChunk);
+    Serialise_glSamplerParameterIuiv(ser, sampler, pname, params);
 
-    if(m_State == WRITING_IDLE)
+    if(IsBackgroundCapturing(m_State))
     {
       GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get());
     }
@@ -515,3 +499,20 @@ void WrappedOpenGL::glDeleteSamplers(GLsizei n, const GLuint *ids)
 
   m_Real.glDeleteSamplers(n, ids);
 }
+
+INSTANTIATE_FUNCTION_SERIALISED(void, glGenSamplers, GLsizei n, GLuint *samplers);
+INSTANTIATE_FUNCTION_SERIALISED(void, glCreateSamplers, GLsizei n, GLuint *samplers);
+INSTANTIATE_FUNCTION_SERIALISED(void, glBindSampler, GLuint unit, GLuint sampler);
+INSTANTIATE_FUNCTION_SERIALISED(void, glBindSamplers, GLuint first, GLsizei count,
+                                const GLuint *samplers);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameteri, GLuint sampler, GLenum pname, GLint param);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterf, GLuint sampler, GLenum pname,
+                                GLfloat param);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameteriv, GLuint sampler, GLenum pname,
+                                const GLint *params);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterfv, GLuint sampler, GLenum pname,
+                                const GLfloat *params);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterIiv, GLuint sampler, GLenum pname,
+                                const GLint *params);
+INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterIuiv, GLuint sampler, GLenum pname,
+                                const GLuint *params);