自学教程：C++ GetCtx函数代码示例

bool WrappedOpenGL::Serialise_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode){	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program)));	SERIALISE_ELEMENT(uint32_t, Count, count);	SERIALISE_ELEMENT(GLenum, Mode, bufferMode);	string *vars = m_State >= WRITING ? NULL : new string[Count];	char **varstrs = m_State >= WRITING ? NULL : new char*[Count];	for(uint32_t c=0; c < Count; c++)	{		string v = varyings && varyings[c] ? varyings[c] : "";		m_pSerialiser->Serialise("Varying", v);		if(vars) { vars[c] = v; varstrs[c] = (char *)vars[c].c_str(); }	}		if(m_State == READING)	{		m_Real.glTransformFeedbackVaryings(GetResourceManager()->GetLiveResource(id).name, Count, varstrs, Mode);	}	SAFE_DELETE_ARRAY(vars);	SAFE_DELETE_ARRAY(varstrs);		return true;}

void WrappedOpenGL::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers){	m_Real.glDeleteFramebuffers(n, framebuffers);	for(GLsizei i=0; i < n; i++)		GetResourceManager()->UnregisterResource(FramebufferRes(GetCtx(), framebuffers[i]));}

GLuint WrappedOpenGL::glCreateShader(GLenum type){	GLuint real = m_Real.glCreateShader(type);	GLResource res = ShaderRes(GetCtx(), real);	ResourceId id = GetResourceManager()->RegisterResource(res);	if(m_State >= WRITING)	{		Chunk *chunk = NULL;		{			SCOPED_SERIALISE_CONTEXT(CREATE_SHADER);			Serialise_glCreateShader(real, type);			chunk = scope.Get();		}		GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);		RDCASSERT(record);		record->AddChunk(chunk);	}	else	{		GetResourceManager()->AddLiveResource(id, res);	}	return real;}

bool WrappedOpenGL::Serialise_glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level){	SERIALISE_ELEMENT(GLenum, Attach, attachment);	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));	SERIALISE_ELEMENT(int32_t, Level, level);	SERIALISE_ELEMENT(ResourceId, fbid, (framebuffer == 0 ? ResourceId() : GetResourceManager()->GetID(FramebufferRes(GetCtx(), framebuffer))));		if(m_State < WRITING)	{		GLResource res = GetResourceManager()->GetLiveResource(id);		if(fbid == ResourceId())		{			glNamedFramebufferTextureEXT(0, Attach, res.name, Level);		}		else		{			GLResource fbres = GetResourceManager()->GetLiveResource(fbid);			glNamedFramebufferTextureEXT(fbres.name, Attach, res.name, Level);		}		if(m_State == READING)		{			m_Textures[GetResourceManager()->GetLiveID(id)].creationFlags |= eTextureCreate_RTV;		}	}	return true;}

GLuint WrappedOpenGL::glCreateProgram(){	GLuint real = m_Real.glCreateProgram();		GLResource res = ProgramRes(GetCtx(), real);	ResourceId id = GetResourceManager()->RegisterResource(res);			if(m_State >= WRITING)	{		Chunk *chunk = NULL;		{			SCOPED_SERIALISE_CONTEXT(CREATE_PROGRAM);			Serialise_glCreateProgram(real);			chunk = scope.Get();		}		GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);		RDCASSERT(record);				// we always want to mark programs as dirty so we can serialise their		// locations as initial state (and form a remapping table)		GetResourceManager()->MarkDirtyResource(id);		record->AddChunk(chunk);	}	else	{		GetResourceManager()->AddLiveResource(id, res);	}	return real;}

void WrappedOpenGL::glGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, void **params){  CoherentMapImplicitBarrier();  // intercept GL_BUFFER_MAP_POINTER queries  if(pname == eGL_BUFFER_MAP_POINTER)  {    GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer));    RDCASSERTMSG("Couldn't identify object passed to function. Mismatched or bad GLuint?", record,                 buffer);    if(record)    {      if(record->Map.status == GLResourceRecord::Unmapped)        *params = NULL;      else        *params = (void *)record->Map.ptr;    }    else    {      *params = NULL;    }  }  else  {    m_Real.glGetNamedBufferPointervEXT(buffer, pname, params);  }}

void WrappedOpenGL::glGenQueries(GLsizei count, GLuint *ids){	m_Real.glGenQueries(count, ids);	for(GLsizei i=0; i < count; i++)	{		GLResource res = QueryRes(GetCtx(), 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);		}	}}

bool WrappedOpenGL::Serialise_glBindTexture(GLenum target, GLuint texture){	SERIALISE_ELEMENT(GLenum, Target, target);	SERIALISE_ELEMENT(ResourceId, Id, (texture ? GetResourceManager()->GetID(TextureRes(GetCtx(), texture)) : ResourceId()));		if(m_State == WRITING_IDLE)	{		m_TextureRecord[m_TextureUnit]->datatype = Target;	}	else if(m_State < WRITING)	{		if(Id == ResourceId())		{			m_Real.glBindTexture(Target, 0);		}		else		{			GLResource res = GetResourceManager()->GetLiveResource(Id);			m_Real.glBindTexture(Target, res.name);			m_Textures[GetResourceManager()->GetLiveID(Id)].curType = Target;		}	}	return true;}

void WrappedOpenGL::glDeleteTextures(GLsizei n, const GLuint *textures){	m_Real.glDeleteTextures(n, textures);	for(GLsizei i=0; i < n; i++)		GetResourceManager()->UnregisterResource(TextureRes(GetCtx(), textures[i]));}

void WrappedOpenGL::glGenTextures(GLsizei n, GLuint* textures){	m_Real.glGenTextures(n, textures);	for(GLsizei i=0; i < n; i++)	{		GLResource res = TextureRes(GetCtx(), textures[i]);		ResourceId id = GetResourceManager()->RegisterResource(res);		if(m_State >= WRITING)		{			Chunk *chunk = NULL;			{				SCOPED_SERIALISE_CONTEXT(GEN_TEXTURE);				Serialise_glGenTextures(1, textures+i);				chunk = scope.Get();			}			GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);			RDCASSERT(record);			record->AddChunk(chunk);		}		else		{			GetResourceManager()->AddLiveResource(id, res);			m_Textures[id].resource = res;			m_Textures[id].curType = eGL_UNKNOWN_ENUM;		}	}}

void WrappedOpenGL::glGenProgramPipelines(GLsizei n, GLuint *pipelines){  m_Real.glGenProgramPipelines(n, pipelines);  for(GLsizei i = 0; i < n; i++)  {    GLResource res = ProgramPipeRes(GetCtx(), pipelines[i]);    ResourceId id = GetResourceManager()->RegisterResource(res);    if(m_State >= WRITING)    {      Chunk *chunk = NULL;      {        SCOPED_SERIALISE_CONTEXT(GEN_PROGRAMPIPE);        Serialise_glGenProgramPipelines(1, pipelines + i);        chunk = scope.Get();      }      GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);      RDCASSERT(record);      record->AddChunk(chunk);    }    else    {      GetResourceManager()->AddLiveResource(id, res);    }  }}

void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers){	m_Real.glGenFramebuffers(n, framebuffers);	for(GLsizei i=0; i < n; i++)	{		GLResource res = FramebufferRes(GetCtx(), framebuffers[i]);		ResourceId id = GetResourceManager()->RegisterResource(res);				if(m_State >= WRITING)		{			Chunk *chunk = NULL;			{				SCOPED_SERIALISE_CONTEXT(GEN_FRAMEBUFFERS);				Serialise_glGenFramebuffers(1, framebuffers+i);				chunk = scope.Get();			}			GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);			RDCASSERT(record);			record->AddChunk(chunk);		}		else		{			GetResourceManager()->AddLiveResource(id, res);		}	}}

bool WrappedOpenGL::Serialise_glCreateSamplers(GLsizei n, GLuint *samplers){  SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers)));  if(m_State == READING)  {    GLuint real = 0;    m_Real.glCreateSamplers(1, &real);    GLResource res = SamplerRes(GetCtx(), 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_glAttachShader(GLuint program, GLuint shader){  SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(GetCtx(), program)));  SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(GetCtx(), shader)));  if(m_State == READING)  {    ResourceId liveProgId = GetResourceManager()->GetLiveID(progid);    ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid);    m_Programs[liveProgId].shaders.push_back(liveShadId);    m_Real.glAttachShader(GetResourceManager()->GetLiveResource(progid).name,                          GetResourceManager()->GetLiveResource(shadid).name);  }  return true;}

void WrappedOpenGL::glAttachShader(GLuint program, GLuint shader){	m_Real.glAttachShader(program, shader);		if(m_State >= WRITING && program != 0 && shader != 0)	{		GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program));		GLResourceRecord *shadRecord = GetResourceManager()->GetResourceRecord(ShaderRes(GetCtx(), shader));		RDCASSERT(progRecord && shadRecord);		{			SCOPED_SERIALISE_CONTEXT(ATTACHSHADER);			Serialise_glAttachShader(program, shader);			progRecord->AddParent(shadRecord);			progRecord->AddChunk(scope.Get());		}	}}

GLuint WrappedOpenGL::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings){  GLuint real = m_Real.glCreateShaderProgramv(type, count, strings);  GLResource res = ProgramRes(GetCtx(), real);  ResourceId id = GetResourceManager()->RegisterResource(res);  if(m_State >= WRITING)  {    Chunk *chunk = NULL;    {      SCOPED_SERIALISE_CONTEXT(CREATE_SHADERPROGRAM);      Serialise_glCreateShaderProgramv(real, type, count, strings);      chunk = scope.Get();    }    GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);    RDCASSERT(record);    // we always want to mark programs as dirty so we can serialise their    // locations as initial state (and form a remapping table)    GetResourceManager()->MarkDirtyResource(id);    record->AddChunk(chunk);  }  else  {    GetResourceManager()->AddLiveResource(id, res);    vector<string> src;    for(GLsizei i = 0; i < count; i++)      src.push_back(strings[i]);    GLuint sepprog = MakeSeparableShaderProgram(*this, type, src, NULL);    auto &progDetails = m_Programs[id];    progDetails.linked = true;    progDetails.shaders.push_back(id);    progDetails.stageShaders[ShaderIdx(type)] = id;    auto &shadDetails = m_Shaders[id];    shadDetails.type = type;    shadDetails.sources.swap(src);    shadDetails.prog = sepprog;    shadDetails.Compile(*this);  }  return real;}

void WrappedOpenGL::glCompileShader(GLuint shader){  m_Real.glCompileShader(shader);  if(m_State >= WRITING)  {    GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ShaderRes(GetCtx(), shader));    RDCASSERT(record);    {      SCOPED_SERIALISE_CONTEXT(COMPILESHADER);      Serialise_glCompileShader(shader);      record->AddChunk(scope.Get());    }  }  else  {    m_Shaders[GetResourceManager()->GetID(ShaderRes(GetCtx(), shader))].Compile(*this);  }}

void WrappedOpenGL::glBindFramebuffer(GLenum target, GLuint framebuffer){	if(m_State == WRITING_CAPFRAME)	{		SCOPED_SERIALISE_CONTEXT(BIND_FRAMEBUFFER);		Serialise_glBindFramebuffer(target, framebuffer);				m_ContextRecord->AddChunk(scope.Get());	}	if(framebuffer == 0 && m_State < WRITING)		framebuffer = m_FakeBB_FBO;	if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER)		m_DrawFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(GetCtx(), framebuffer));	else		m_ReadFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(GetCtx(), framebuffer));	m_Real.glBindFramebuffer(target, framebuffer);}

void WrappedOpenGL::glDeleteShader(GLuint shader){  m_Real.glDeleteShader(shader);  GLResource res = ShaderRes(GetCtx(), shader);  if(GetResourceManager()->HasCurrentResource(res))  {    if(GetResourceManager()->HasResourceRecord(res))      GetResourceManager()->GetResourceRecord(res)->Delete(GetResourceManager());    GetResourceManager()->UnregisterResource(res);  }}