void ShaderEditASM::CreateARBShadersPre(FunctionArgs & args)
{
//Get the number of shader ID's created
args.Get(inumNewShaders);
//Get the shader array
args.Get(inewShaderIDs);
}
void ShaderEditASM::BindARBShaderPre(FunctionArgs & args)
{
//Get the target type
GLenum newType;
args.Get(newType);
//Get the shader id
GLuint shaderID;
args.Get(shaderID);
//Check if the shader exists yet or not
ShaderDataASM * shaderData = shaderManager.GetData(shaderID);
if(!shaderData)
{
//Add the shader data to the array
shaderManager.AddData(shaderID);
//Retrieve the pointer
shaderData = shaderManager.GetData(shaderID);
if(shaderData)
{
//Update the frame number
shaderData->GetUniqueID()->SetLastFrameUsed(gliCallBacks->GetFrameNumber());
}
}
else
{
//Update the frame number
shaderData->GetUniqueID()->SetLastFrameUsed(gliCallBacks->GetFrameNumber());
//If the shader is ready, ensure it was bound to the correct target
if(shaderData->IsReady() && newType != shaderData->GetGLType())
{
LOGERR(("ShaderEditASM::BindARBShaderPre - Binding shader %u to a different target?",shaderID));
}
}
}
void ShaderEditASM::DeleteARBShaders(FunctionArgs & args)
{
//Get the count
GLsizei numShaders;
args.Get(numShaders);
//Get the shader array
const GLuint *shaderIDs;
args.Get(shaderIDs);
//Catch bad values
if(numShaders <= 0)
{
return;
}
//Loop for all the shaders
for(uint i=0;i<(uint)numShaders;i++)
{
//Remove the shader ID
shaderManager.RemoveData(shaderIDs[i]);
}
}
void ShaderEditASM::SetARBShaderReadyPre(uint updateID, FunctionArgs & args)
{
//Reset the flag
validShaderReady = false;
if(updateID == CBI_glProgramString)
{
//Get the target
args.Get(ishaderTarget);
//Return false for unknown shader types
if(ishaderTarget != GL_VERTEX_PROGRAM_ARB &&
ishaderTarget != GL_FRAGMENT_PROGRAM_ARB)
{
LOGERR(("ShaderEditASM::SetARBShaderReadyPre - Unknown/unsupported shader type: 0x%x",ishaderTarget));
return;
}
//Get the current shader index for the target
ishaderID = GetActiveShaderID(ishaderTarget);
//Get the format
GLenum shaderFormat;
args.Get(shaderFormat);
//Check the format
if(shaderFormat != GL_PROGRAM_FORMAT_ASCII_ARB)
{
LOGERR(("ShaderEditASM::SetARBShaderReadyPre - Need to pass ascii string for editing : ShaderID = %u",ishaderID));
return;
}
//Get the length
args.Get(ishaderLength);
//Get the string
args.Get(ishaderSrc);
}
else if(updateID == CBI_glLoadProgram)
{
//Get the target
args.Get(ishaderTarget);
//Return false for unknown shader types
if(ishaderTarget != GL_VERTEX_PROGRAM_NV &&
ishaderTarget != GL_FRAGMENT_PROGRAM_NV)
{
LOGERR(("ShaderEditASM::SetARBShaderReadyPre - Unknown/unsupported NV shader type: 0x%x",ishaderTarget));
return;
}
//Get the id
args.Get(ishaderID);
//NV state programs do not need a bind call so
// check if the shader exists yet or not
ShaderDataASM * shaderData = shaderManager.GetData(ishaderID);
if(!shaderData)
{
//Add the shader data to the array
shaderManager.AddData(ishaderID);
}
//Get the length
args.Get(ishaderLength);
//Get the string
args.Get(ishaderSrc);
}
else
{
LOGERR(("ShaderEditASM::SetARBShaderReadyPre - Unhandled program type"));
return;
}
//Flag success
if(ishaderLength > 0 && ishaderSrc != NULL && ishaderID != 0)
{
validShaderReady = true;
}
}
void UniformData::Update(const char *charptr, FunctionArgs &accessArgs){
unsigned int arraysize = 0;
void *pointer;
GLint sizei;
if (isValueSet){
free(data);
data=0;
isValueSet=false;
}
switch(charptr[0]){
case '1':
arraysize = 1;
break;
case '2':
arraysize = 2;
break;
case '3':
arraysize = 3;
break;
case '4':
arraysize = 4;
break;
}
//only if it's not matrix which start as glProgramUniformMatrices
if (arraysize){
// types: "f","i","ui","fv","iv","uiv"
switch(charptr[1]){
case 'f':
data = malloc(sizeof(float) * arraysize);
if (charptr[2]){ //fv
accessArgs.Get(sizei);
accessArgs.Get(pointer);
memcpy(data,pointer,sizeof(float) * arraysize);
SetTypeManual(CFLOAT, arraysize, 1);
}
else{ //f
GLfloat value;
for(unsigned int i=0; i<arraysize; i++){
float *tmp = (float *) data;
accessArgs.Get(value);
tmp[i] = value;
}
SetTypeManual(CFLOAT, 1, 1);
}
break;
case 'i':
data = malloc(sizeof(int) * arraysize);
if (charptr[2]){ //iv
accessArgs.Get(sizei);
accessArgs.Get(pointer);
memcpy(data,pointer,sizeof(int) * arraysize);
SetTypeManual(CINT, arraysize, 1);
}
else{ //i
GLint value;
for(unsigned int i=0; i<arraysize; i++){
int *tmp = (int *) data;
accessArgs.Get(value);
tmp[i] = value;
}
SetTypeManual(CINT, 1, 1);
}
break;
case 'u':
data = malloc(sizeof(unsigned int) * arraysize);
if (charptr[3]){ //uiv
accessArgs.Get(sizei);
accessArgs.Get(pointer);
memcpy(data,pointer,sizeof(unsigned int) * arraysize);
SetTypeManual(CUINT, arraysize, 1);
}
else{ //ui
GLuint value;
for(unsigned int i=0; i<arraysize; i++){
unsigned int *tmp = (unsigned int *) data;
accessArgs.Get(value);
tmp[i] = value;
}
SetTypeManual(CUINT, 1, 1);
}
break;
}
}
else{
charptr += 8;
unsigned int rows, columns;
switch(charptr[0]){
case '2':
rows = 2;
break;
case '3':
rows = 3;
break;
case '4':
rows = 4;
break;
}
if (charptr[1] == 'x'){
switch(charptr[2]){
case '2':
columns = 2;
break;
case '3':
columns = 3;
break;
case '4':
columns = 4;
break;
}
}
arraysize = rows * columns;
data = malloc(sizeof(float) * arraysize);
accessArgs.Get(sizei);
accessArgs.Get(pointer);
memcpy(data,pointer,sizeof(float) * arraysize);
SetTypeManual(CFLOAT, columns, rows);
}
isValueSet = true;
}
bool InterceptLog::GetNextValue(ParameterType pType, FunctionArgs &args, bool isPointer, ParamValue &value)
{
//Test if we are getting a pointer
if(isPointer)
{
//Get the pointer value
args.Get(value.pointerValue);
LOGERR(("This pointer date %p\n",value.pointerValue));
//LOGERR(("The 1st element of the pointer is %f\n",*(value.pointerValue)));
//Return true
return true;
}
//Determine the type to return
switch(pType)
{
case(PT_enum):
args.Get(value.enumValue);
break;
case(PT_bitfield):
args.Get(value.bitfieldValue);
break;
case(PT_void):
break;
case(PT_byte):
args.Get(value.byteValue);
break;
case(PT_short):
args.Get(value.shortValue);
break;
case(PT_int):
args.Get(value.intValue);
break;
case(PT_sizei):
args.Get(value.sizeiValue);
break;
case(PT_ubyte):
args.Get(value.ubyteValue);
break;
case(PT_char):
args.Get(value.charValue);
break;
case(PT_boolean):
args.Get(value.booleanValue);
break;
case(PT_ushort):
args.Get(value.ushortValue);
break;
case(PT_uint):
args.Get(value.uintValue);
break;
case(PT_handle):
args.Get(value.uintValue);
break;
case(PT_float):
args.Get(value.floatValue);
//LOGERR(("this is a float data %f\n",value.floatValue));
break;
case(PT_double):
args.Get(value.doubleValue);
//LOGERR(("this is a double data %f\n",value.doubleValue));
break;
case(PT_intptr):
args.Get(value.intptrValue);
break;
case(PT_sizeiptr):
args.Get(value.sizeiptrValue);
break;
case(PT_int64):
args.Get(value.int64Value);
break;
case(PT_uint64):
args.Get(value.uint64Value);
break;
case(PT_sync):
args.Get(value.syncValue);
break;
default:
LOGERR(("InterceptLog::GetNextValue - Unhandled parameter in function of type %d",(int)pType));
return false;
}
return true;
}
