void WrappedOpenGL::glGenQueries(GLsizei count, GLuint *ids)
{
m_Real.glGenSamplers(count, ids);
for(GLsizei i=0; i < count; i++)
{
GLResource res = QueryRes(ids[i]);
ResourceId id = GetResourceManager()->RegisterResource(res);
if(m_State >= WRITING)
{
Chunk *chunk = NULL;
{
SCOPED_SERIALISE_CONTEXT(GEN_QUERIES);
Serialise_glGenQueries(1, ids+i);
chunk = scope.Get();
}
GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);
RDCASSERT(record);
record->AddChunk(chunk);
}
else
{
GetResourceManager()->AddLiveResource(id, res);
}
}
}
void WrappedOpenGL::glDeleteQueries(GLsizei n, const GLuint *ids)
{
m_Real.glDeleteQueries(n, ids);
for(GLsizei i=0; i < n; i++)
GetResourceManager()->UnregisterResource(QueryRes(ids[i]));
}
bool WrappedOpenGL::Serialise_glGenQueries(GLsizei n, GLuint* ids)
{
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(QueryRes(*ids)));
if(m_State == READING)
{
GLuint real = 0;
m_Real.glGenSamplers(1, &real);
GLResource res = QueryRes(real);
ResourceId live = m_ResourceManager->RegisterResource(res);
GetResourceManager()->AddLiveResource(id, res);
}
return true;
}
bool WrappedOpenGL::Serialise_glCreateQueries(GLenum target, GLsizei n, GLuint* ids)
{
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(QueryRes(GetCtx(), *ids)));
SERIALISE_ELEMENT(GLenum, Target, target);
if(m_State == READING)
{
GLuint real = 0;
m_Real.glCreateQueries(Target, 1, &real);
GLResource res = QueryRes(GetCtx(), real);
ResourceId live = m_ResourceManager->RegisterResource(res);
GetResourceManager()->AddLiveResource(id, res);
}
return true;
}
bool WrappedOpenGL::Serialise_glBeginQuery(GLenum target, GLuint qid)
{
SERIALISE_ELEMENT(GLenum, Target, target);
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(QueryRes(qid)));
if(m_State < WRITING)
{
glBeginQuery(Target, GetResourceManager()->GetLiveResource(id).name);
}
return true;
}
bool WrappedOpenGL::Serialise_glQueryCounter(GLuint query, GLenum target)
{
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(QueryRes(GetCtx(), query)));
SERIALISE_ELEMENT(GLenum, Target, target);
if(m_State < WRITING)
{
m_Real.glQueryCounter(GetResourceManager()->GetLiveResource(id).name, Target);
}
return true;
}
bool WrappedOpenGL::Serialise_glBeginConditionalRender(GLuint id, GLenum mode)
{
SERIALISE_ELEMENT(ResourceId, qid, GetResourceManager()->GetID(QueryRes(GetCtx(), id)));
SERIALISE_ELEMENT(GLenum, Mode, mode);
if(m_State < WRITING)
{
m_ActiveConditional = true;
m_Real.glBeginConditionalRender(GetResourceManager()->GetLiveResource(qid).name, Mode);
}
return true;
}
bool WrappedOpenGL::Serialise_glBeginQuery(GLenum target, GLuint qid)
{
SERIALISE_ELEMENT(GLenum, Target, target);
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(QueryRes(GetCtx(), qid)));
if(m_State < WRITING)
{
m_Real.glBeginQuery(Target, GetResourceManager()->GetLiveResource(id).name);
m_ActiveQueries[QueryIdx(Target)][0] = true;
}
return true;
}
void WrappedOpenGL::glDeleteQueries(GLsizei n, const GLuint *ids)
{
for(GLsizei i=0; i < n; i++)
{
GLResource res = QueryRes(GetCtx(), ids[i]);
if(GetResourceManager()->HasCurrentResource(res))
{
if(GetResourceManager()->HasResourceRecord(res))
GetResourceManager()->GetResourceRecord(res)->Delete(GetResourceManager());
GetResourceManager()->UnregisterResource(res);
}
}
m_Real.glDeleteQueries(n, ids);
}
bool WrappedOpenGL::Serialise_glObjectLabel(GLenum identifier, GLuint name, GLsizei length,
const GLchar *label)
{
ResourceId liveid;
bool extvariant = false;
string Label;
if(m_State >= WRITING)
{
if(length == 0)
Label = "";
else
Label = string(label, label + (length > 0 ? length : strlen(label)));
switch(identifier)
{
case eGL_TEXTURE: liveid = GetResourceManager()->GetID(TextureRes(GetCtx(), name)); break;
case eGL_BUFFER_OBJECT_EXT: extvariant = true;
case eGL_BUFFER: liveid = GetResourceManager()->GetID(BufferRes(GetCtx(), name)); break;
case eGL_PROGRAM_OBJECT_EXT: extvariant = true;
case eGL_PROGRAM: liveid = GetResourceManager()->GetID(ProgramRes(GetCtx(), name)); break;
case eGL_PROGRAM_PIPELINE_OBJECT_EXT: extvariant = true;
case eGL_PROGRAM_PIPELINE:
liveid = GetResourceManager()->GetID(ProgramPipeRes(GetCtx(), name));
break;
case eGL_VERTEX_ARRAY_OBJECT_EXT: extvariant = true;
case eGL_VERTEX_ARRAY:
liveid = GetResourceManager()->GetID(VertexArrayRes(GetCtx(), name));
break;
case eGL_SHADER_OBJECT_EXT: extvariant = true;
case eGL_SHADER: liveid = GetResourceManager()->GetID(ShaderRes(GetCtx(), name)); break;
case eGL_QUERY_OBJECT_EXT: extvariant = true;
case eGL_QUERY: liveid = GetResourceManager()->GetID(QueryRes(GetCtx(), name)); break;
case eGL_TRANSFORM_FEEDBACK:
liveid = GetResourceManager()->GetID(FeedbackRes(GetCtx(), name));
break;
case eGL_SAMPLER: liveid = GetResourceManager()->GetID(SamplerRes(GetCtx(), name)); break;
case eGL_RENDERBUFFER:
liveid = GetResourceManager()->GetID(RenderbufferRes(GetCtx(), name));
break;
case eGL_FRAMEBUFFER:
liveid = GetResourceManager()->GetID(FramebufferRes(GetCtx(), name));
break;
default: RDCERR("Unhandled namespace in glObjectLabel");
}
}
SERIALISE_ELEMENT(GLenum, Identifier, identifier);
SERIALISE_ELEMENT(ResourceId, id, liveid);
SERIALISE_ELEMENT(uint32_t, Length, length);
SERIALISE_ELEMENT(bool, HasLabel, label != NULL);
m_pSerialiser->SerialiseString("label", Label);
if(m_State == READING && GetResourceManager()->HasLiveResource(id))
{
GLResource res = GetResourceManager()->GetLiveResource(id);
if(extvariant && m_Real.glLabelObjectEXT)
m_Real.glLabelObjectEXT(Identifier, res.name, Length, HasLabel ? Label.c_str() : NULL);
else
m_Real.glObjectLabel(Identifier, res.name, Length, HasLabel ? Label.c_str() : NULL);
}
return true;
}
bool WrappedOpenGL::Serialise_glObjectLabel(SerialiserType &ser, GLenum identifier, GLuint name,
GLsizei length, const GLchar *label)
{
GLResource Resource;
std::string Label;
if(ser.IsWriting())
{
// we share implementations between KHR_debug and EXT_debug_label, however KHR_debug follows the
// pattern elsewhere (e.g. in glShaderSource) of a length of -1 meaning indeterminate
// NULL-terminated length, but EXT_debug_label takes length of 0 to mean that.
GLsizei realLength = length;
if(gl_CurChunk == GLChunk::glLabelObjectEXT && length == 0)
realLength = -1;
// if length is negative (after above twiddling), it's taken from strlen and the label must be
// NULL-terminated
if(realLength < 0)
realLength = label ? (GLsizei)strlen(label) : 0;
if(realLength == 0 || label == NULL)
Label = "";
else
Label = std::string(label, label + realLength);
switch(identifier)
{
case eGL_TEXTURE: Resource = TextureRes(GetCtx(), name); break;
case eGL_BUFFER_OBJECT_EXT:
case eGL_BUFFER: Resource = BufferRes(GetCtx(), name); break;
case eGL_PROGRAM_OBJECT_EXT:
case eGL_PROGRAM: Resource = ProgramRes(GetCtx(), name); break;
case eGL_PROGRAM_PIPELINE_OBJECT_EXT:
case eGL_PROGRAM_PIPELINE: Resource = ProgramPipeRes(GetCtx(), name); break;
case eGL_VERTEX_ARRAY_OBJECT_EXT:
case eGL_VERTEX_ARRAY: Resource = VertexArrayRes(GetCtx(), name); break;
case eGL_SHADER_OBJECT_EXT:
case eGL_SHADER: Resource = ShaderRes(GetCtx(), name); break;
case eGL_QUERY_OBJECT_EXT:
case eGL_QUERY: Resource = QueryRes(GetCtx(), name); break;
case eGL_TRANSFORM_FEEDBACK: Resource = FeedbackRes(GetCtx(), name); break;
case eGL_SAMPLER: Resource = SamplerRes(GetCtx(), name); break;
case eGL_RENDERBUFFER: Resource = RenderbufferRes(GetCtx(), name); break;
case eGL_FRAMEBUFFER: Resource = FramebufferRes(GetCtx(), name); break;
default: RDCERR("Unhandled namespace in glObjectLabel");
}
}
SERIALISE_ELEMENT(Resource);
SERIALISE_ELEMENT(length);
SERIALISE_ELEMENT(Label);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading() && Resource.name)
{
ResourceId origId = GetResourceManager()->GetOriginalID(GetResourceManager()->GetID(Resource));
GetResourceManager()->SetName(origId, Label);
ResourceDescription &descr = GetReplay()->GetResourceDesc(origId);
descr.SetCustomName(Label);
AddResourceCurChunk(descr);
}
return true;
}