lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-15 11:06:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Serialise glUniform through glProgramUniform

Browse Source
This commit is contained in:
baldurk
2014-11-03 20:59:28 +00:00
parent b590377345
commit c7528aeb49
3 changed files with 135 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/gl/gl_common.h
-2
View File
@@ -186,8 +186,6 @@ enum GLChunkType
BINDVERTEXARRAY,
BINDVERTEXBUFFER,
VERTEXDIVISOR,
UNIFORM_MATRIX,
UNIFORM_VECTOR,
DISPATCH_COMPUTE,
MEMORY_BARRIER,
DRAWARRAYS,
renderdoc/driver/gl/gl_driver.cpp
-8
View File
@@ -139,8 +139,6 @@ const char *GLChunkNames[] =
"glBindVertexArray",
"glBindVertexBuffer",
"glVertexBindingDivisor",
"glUniformMatrix*",
"glUniformVector*",
"glDispatchCompute",
"glMemoryBarrier",
"glDrawArrays",
@@ -1704,12 +1702,6 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
case VERTEXDIVISOR:
Serialise_glVertexBindingDivisor(0, 0);
break;
case UNIFORM_MATRIX:
Serialise_glUniformMatrix(0, 0, 0, NULL, UNIFORM_UNKNOWN);
break;
case UNIFORM_VECTOR:
Serialise_glUniformVector(0, 0, NULL, UNIFORM_UNKNOWN);
break;
case DISPATCH_COMPUTE:
Serialise_glDispatchCompute(0, 0, 0);
break;
renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp
+135 -297
View File
@@ -26,385 +26,223 @@
#include "common/string_utils.h"
#include "../gl_driver.h"
bool WrappedOpenGL::Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type)
{
SERIALISE_ELEMENT(UniformType, Type, type);
SERIALISE_ELEMENT(int32_t, Loc, location);
SERIALISE_ELEMENT(uint32_t, Count, count);
SERIALISE_ELEMENT(uint8_t, Transpose, transpose);
size_t elemsPerMat = 0;
switch(Type)
{
case MAT4FV: elemsPerMat = 16; break;
default:
RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type);
}
if(m_State >= WRITING)
{
m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerMat*Count);
}
else if(m_State <= EXECUTING)
{
value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerMat*Count);
switch(Type)
{
case MAT4FV: m_Real.glUniformMatrix4fv(Loc, Count, Transpose, (const GLfloat *)value); break;
default:
RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type);
}
}
if(m_pSerialiser->GetDebugText())
{
switch(Type)
{
case MAT4FV:
{
float *f = (float *)value;
if(Transpose)
{
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[4], f[8], f[12]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[1], f[5], f[9], f[13]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[2], f[6], f[10], f[14]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[3], f[7], f[11], f[15]);
}
else
{
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[4], f[5], f[6], f[7]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[8], f[9], f[10], f[11]);
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[12], f[13], f[14], f[15]);
}
break;
}
default:
RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type);
}
}
return true;
}
void WrappedOpenGL::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
{
m_Real.glUniformMatrix4fv(location, count, transpose, value);
if(m_State == WRITING_CAPFRAME)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_MATRIX);
Serialise_glUniformMatrix(location, count, transpose, value, MAT4FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_MATRIX);
Serialise_glProgramUniformMatrix(m_Program, location, count, transpose, value, MAT4FV);
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
}
}
bool WrappedOpenGL::Serialise_glUniformVector(GLint location, GLsizei count, const void *value, UniformType type)
{
SERIALISE_ELEMENT(UniformType, Type, type);
SERIALISE_ELEMENT(int32_t, Loc, location);
SERIALISE_ELEMENT(uint32_t, Count, count);
size_t elemsPerVec = 0;
switch(Type)
{
case VEC1IV:
case VEC1UIV:
case VEC1FV: elemsPerVec = 1; break;
case VEC2FV: elemsPerVec = 2; break;
case VEC3FV: elemsPerVec = 3; break;
case VEC4FV: elemsPerVec = 4; break;
default:
RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type);
}
if(m_State >= WRITING)
{
m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count);
}
else if(m_State <= EXECUTING)
{
value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
switch(Type)
if(record)
{
case VEC1FV: m_Real.glUniform1fv(Loc, Count, (const GLfloat *)value); break;
case VEC1IV: m_Real.glUniform1iv(Loc, Count, (const GLint *)value); break;
case VEC1UIV: m_Real.glUniform1uiv(Loc, Count, (const GLuint *)value); break;
case VEC2FV: m_Real.glUniform2fv(Loc, Count, (const GLfloat *)value); break;
case VEC3FV: m_Real.glUniform3fv(Loc, Count, (const GLfloat *)value); break;
case VEC4FV: m_Real.glUniform4fv(Loc, Count, (const GLfloat *)value); break;
default:
RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type);
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_MATRIX);
Serialise_glProgramUniformMatrix(m_Program, location, count, transpose, value, MAT4FV);
record->AddChunk(scope.Get());
}
}
if(m_pSerialiser->GetDebugText())
{
switch(Type)
{
case VEC1FV:
{
float *f = (float *)value;
m_pSerialiser->DebugPrint("value: {%f}\n", f[0]);
break;
}
case VEC1IV:
{
int32_t *i = (int32_t *)value;
m_pSerialiser->DebugPrint("value: {%d}\n", i[0]);
break;
}
case VEC1UIV:
{
uint32_t *u = (uint32_t *)value;
m_pSerialiser->DebugPrint("value: {%u}\n", u[0]);
break;
}
case VEC2FV:
{
float *f = (float *)value;
m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]);
break;
}
case VEC3FV:
{
float *f = (float *)value;
m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]);
break;
}
case VEC4FV:
{
float *f = (float *)value;
m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]);
break;
}
default:
RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type);
}
}
return true;
}
void WrappedOpenGL::glUniform1f(GLint location, GLfloat value)
{
m_Real.glUniform1f(location, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, 1, &value, VEC1FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1FV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1FV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform1i(GLint location, GLint value)
{
m_Real.glUniform1i(location, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, 1, &value, VEC1IV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1IV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1IV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform1ui(GLint location, GLuint value)
{
m_Real.glUniform1ui(location, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, 1, &value, VEC1UIV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1UIV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, 1, &value, VEC1UIV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
{
m_Real.glUniform1fv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC1FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC1FV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC1FV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform1iv(GLint location, GLsizei count, const GLint *value)
{
m_Real.glUniform1iv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC1IV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC1IV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC1IV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
{
m_Real.glUniform1uiv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC1UIV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC1UIV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC1UIV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
{
m_Real.glUniform2fv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC2FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC2FV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC2FV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
{
m_Real.glUniform3fv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC3FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC3FV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC3FV);
record->AddChunk(scope.Get());
}
}
}
void WrappedOpenGL::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
{
m_Real.glUniform4fv(location, count, value);
if(m_State == WRITING_CAPFRAME)
if(m_State >= WRITING)
{
SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR);
Serialise_glUniformVector(location, count, value, VEC4FV);
m_ContextRecord->AddChunk(scope.Get());
}
else if(m_State == WRITING_IDLE)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, &value, VEC4FV);
GLResourceRecord *record = m_ContextRecord;
// TODO grab this at capture time as initial state for program resources
GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
RDCASSERT(record);
record->AddChunk(scope.Get());
if(m_State == WRITING_IDLE)
record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), m_Program));
if(record)
{
SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
Serialise_glProgramUniformVector(m_Program, location, count, value, VEC4FV);
record->AddChunk(scope.Get());
}
}
}