Example #1
0
const GLubyte *WrappedOpenGL::glGetStringi(GLenum name, GLuint i)
{
	if(name == eGL_EXTENSIONS)
	{
		if((size_t)i < GetCtxData().glExts.size())
			return (const GLubyte *)GetCtxData().glExts[i].c_str();

		return (const GLubyte *)"";
	}
	return m_Real.glGetStringi(name, i);
}
GLuint WrappedOpenGL::GetUniformProgram()
{
  ContextData &cd = GetCtxData();

  // program gets first dibs, if one is bound then that's where glUniform* calls go.
  if(cd.m_Program != 0)
  {
    return cd.m_Program;
  }
  else if(cd.m_ProgramPipeline != 0)
  {
    GLuint ret = 0;

    // otherwise, query the active program for the pipeline (could cache this above in
    // glActiveShaderProgram)
    // we do this query every time instead of caching the result, since I think it's unlikely that
    // we'll ever
    // hit this path (most people using separable programs will use the glProgramUniform*
    // interface).
    // That way we don't pay the cost of a potentially expensive query unless we really need it.
    m_Real.glGetProgramPipelineiv(cd.m_ProgramPipeline, eGL_ACTIVE_PROGRAM, (GLint *)&ret);

    return ret;
  }

  return 0;
}
Example #3
0
void WrappedOpenGL::glGetBufferPointerv(GLenum target, GLenum pname, void **params)
{
	CoherentMapImplicitBarrier();

	// intercept GL_BUFFER_MAP_POINTER queries
	if(pname == eGL_BUFFER_MAP_POINTER)
	{
		GLResourceRecord *record = GetCtxData().m_BufferRecord[BufferIdx(target)];
		RDCASSERT(record);

		if(record)
		{
			if(record->Map.status == GLResourceRecord::Unmapped)
				*params = NULL;
			else
				*params = (void *)record->Map.ptr;
		}
		else
		{
			*params = NULL;
		}
	}
	else
	{
	m_Real.glGetBufferPointerv(target, pname, params);
	}
}
Example #4
0
const GLubyte *WrappedOpenGL::glGetString(GLenum name)
{
	if(name == eGL_EXTENSIONS)
	{
		return (const GLubyte *)GetCtxData().glExtsString.c_str();
	}
	return m_Real.glGetString(name);
}
Example #5
0
const GLubyte *WrappedOpenGL::glGetString(GLenum name)
{
  if(name == eGL_EXTENSIONS)
  {
    return (const GLubyte *)GetCtxData().glExtsString.c_str();
  }
  else if(name == eGL_DEBUG_TOOL_NAME_EXT)
  {
    return (const GLubyte *)"RenderDoc";
  }
  return m_Real.glGetString(name);
}
Example #6
0
void WrappedOpenGL::glUseProgram(GLuint program)
{
	m_Real.glUseProgram(program);

	GetCtxData().m_Program = program;

	if(m_State == WRITING_CAPFRAME)
	{
		SCOPED_SERIALISE_CONTEXT(USEPROGRAM);
		Serialise_glUseProgram(program);

		m_ContextRecord->AddChunk(scope.Get());
	}
}
Example #7
0
void WrappedOpenGL::glBindProgramPipeline(GLuint pipeline)
{
	m_Real.glBindProgramPipeline(pipeline);

	GetCtxData().m_ProgramPipeline = pipeline;

	if(m_State == WRITING_CAPFRAME)
	{
		SCOPED_SERIALISE_CONTEXT(BIND_PROGRAMPIPE);
		Serialise_glBindProgramPipeline(pipeline);

		m_ContextRecord->AddChunk(scope.Get());
	}
}
void WrappedOpenGL::glUseProgram(GLuint program)
{
  m_Real.glUseProgram(program);

  GetCtxData().m_Program = program;

  if(m_State == WRITING_CAPFRAME)
  {
    SCOPED_SERIALISE_CONTEXT(USEPROGRAM);
    Serialise_glUseProgram(program);

    m_ContextRecord->AddChunk(scope.Get());
    GetResourceManager()->MarkResourceFrameReferenced(ProgramRes(GetCtx(), program), eFrameRef_Read);
  }
}
void WrappedOpenGL::glBindProgramPipeline(GLuint pipeline)
{
  m_Real.glBindProgramPipeline(pipeline);

  GetCtxData().m_ProgramPipeline = pipeline;

  if(m_State == WRITING_CAPFRAME)
  {
    SCOPED_SERIALISE_CONTEXT(BIND_PROGRAMPIPE);
    Serialise_glBindProgramPipeline(pipeline);

    m_ContextRecord->AddChunk(scope.Get());
    GetResourceManager()->MarkResourceFrameReferenced(ProgramPipeRes(GetCtx(), pipeline),
                                                      eFrameRef_Read);
  }
}
Example #10
0
void WrappedOpenGL::glGetIntegerv(GLenum pname, GLint *params)
{
	if(pname == eGL_MIN_MAP_BUFFER_ALIGNMENT)
	{
		if(params)
			*params = (GLint)64;
		return;
	}
	if(pname == eGL_NUM_EXTENSIONS)
	{
		if(params)
			*params = (GLint)GetCtxData().glExts.size();
		return;
	}

	m_Real.glGetIntegerv(pname, params);
}
Example #11
0
void WrappedOpenGL::glGetIntegerv(GLenum pname, GLint *params)
{
  if(pname == eGL_MIN_MAP_BUFFER_ALIGNMENT)
  {
    if(params)
      *params = (GLint)64;
    return;
  }
  else if(pname == eGL_NUM_EXTENSIONS)
  {
    if(params)
      *params = (GLint)GetCtxData().glExts.size();
    return;
  }
  else if(pname == eGL_DEBUG_TOOL_PURPOSE_EXT)
  {
    if(params)
      *params = GLint(eGL_DEBUG_TOOL_FRAME_CAPTURE_BIT_EXT);
    return;
  }

  m_Real.glGetIntegerv(pname, params);
}