void InterceptLogText::LogFunctionPost(const FunctionData *funcData,uint index, const FunctionRetValue & retVal)
{
//Check the function data
if(!funcData)
{
LOGERR(("InterceptLogText::LogFunctionPost - Function data for index %u is NULL",index));
return;
}
//Get the return parameter
const ParameterData * returnData = &funcData->returnType;
//Determine if we are processing pointers
bool isPointer=false;
if(returnData->pointerCount > 0 || returnData->length != -1)
{
isPointer=true;
}
//Check the return value
if(isPointer ||
returnData->type != PT_void)
{
//Look up the data
ParamValue value;
if(GetReturnValue(returnData->type, retVal, isPointer, value))
{
string out = ConvertParam(value, isPointer, returnData);
//Log the result
fprintf(logFile,"=%s ",out.c_str());
}
}
}
void InterceptLog::GetReturnString(const FunctionData *funcData,uint index, const FunctionRetValue & retVal, string &retString)
{
//Empty the return string
retString = "";
//Check the function data
if(!funcData)
{
LOGERR(("InterceptLog::GetReturnString - Function data for index %u is NULL",index));
return;
}
//Get the return parameter
const ParameterData * returnData = &funcData->returnType;
//Determine if we are processing pointers
bool isPointer=false;
if(returnData->pointerCount > 0 || returnData->length != -1)
{
isPointer=true;
}
//Check the return value
if(isPointer ||
returnData->type != PT_void)
{
//Look up the data
ParamValue value;
if(GetReturnValue(returnData->type, retVal, isPointer, value))
{
retString = ConvertParam(value, isPointer, returnData);
}
}
}
void Effect::GetEffectParameterInfo(HANDLE hObject, EffectParameterInfo ¶mInfo) const
{
traceIn(Effect::GetEffectParameterInfo);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
paramInfo.name = param->name;
paramInfo.propertyType = param->propertyType;
paramInfo.type = param->type;
paramInfo.fullName = param->fullName;
if(paramInfo.propertyType == EffectProperty_Float)
{
paramInfo.fMin = param->fMin;
paramInfo.fMax = param->fMax;
paramInfo.fInc = param->fInc;
paramInfo.fMul = param->fMul;
}
else if(paramInfo.propertyType == EffectProperty_Texture)
{
if(param->DefaultValue.Num())
{
BufferInputSerializer s(param->DefaultValue);
s << paramInfo.strDefaultTexture;
}
}
traceOut;
}
inline BOOL Effect::GetDefaultVector(HANDLE hObject, Vect &value) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < sizeof(float)*3)) return FALSE;
mcpy(value, param->DefaultValue.Array(), sizeof(float)*3);
return TRUE;
}
inline BOOL Effect::GetDefaultMatrix(HANDLE hObject, float *matrix) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < (sizeof(float)*4*4))) return FALSE;
mcpy(matrix, param->DefaultValue.Array(), sizeof(float)*4*4);
return TRUE;
}
inline BOOL Effect::GetDefaultInt(HANDLE hObject, int &iValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < sizeof(int))) return FALSE;
iValue = *(int*)param->DefaultValue.Array();
return TRUE;
}
inline BOOL Effect::GetDefaultFloat(HANDLE hObject, float &fValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < sizeof(float))) return FALSE;
fValue = *(float*)param->DefaultValue.Array();
return TRUE;
}
inline BOOL Effect::GetDefaultBool(HANDLE hObject, BOOL &bValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < sizeof(BOOL))) return FALSE;
bValue = *(BOOL*)param->DefaultValue.Array();
return TRUE;
}
inline void Effect::GetMatrix(HANDLE hObject, float *matrix) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num() == (sizeof(float)*16))
mcpy(matrix, param->CurValue.Array(), (sizeof(float)*16));
}
inline void Effect::GetVector4(HANDLE hObject, Vect4 &value) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num() >= sizeof(Vect4))
value = *(Vect4*)param->CurValue.Array();
}
inline void Effect::GetInt(HANDLE hObject, int &iValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num() >= sizeof(int))
iValue = *(int*)param->CurValue.Array();
}
inline void Effect::GetFloat(HANDLE hObject, float &fValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num() >= sizeof(float))
fValue = *(float*)param->CurValue.Array();
}
inline void Effect::GetBool(HANDLE hObject, BOOL &bValue) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num() >= sizeof(BOOL))
bValue = *(BOOL*)param->CurValue.Array();
}
inline BOOL Effect::GetDefaultVector4(HANDLE hObject, Vect4 &value) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || (param->DefaultValue.Num() < sizeof(Vect4))) return FALSE;
value = *(Vect4*)param->DefaultValue.Array();
return TRUE;
}
inline BOOL Effect::GetDefaultTexture(HANDLE hObject, String &value) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
if(!param || !param->DefaultValue.Num()) return FALSE;
BufferInputSerializer sIn(param->DefaultValue);
sIn << value;
return TRUE;
}
inline void Effect::GetString(HANDLE hObject, String &value) const
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
if(param->CurValue.Num())
{
BufferInputSerializer s(param->CurValue);
s << value;
}
}
inline void Effect::SetValue(HANDLE hObject, const void *val, DWORD dwSize)
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
BOOL bSizeChanged = param->CurValue.SetSize(dwSize);
if(bSizeChanged || !mcmp(param->CurValue.Array(), val, dwSize))
{
mcpy(param->CurValue.Array(), val, dwSize);
if(param->bValid && !param->bChanged)
{
param->nextChanged = firstChanged;
firstChanged = param;
param->bChanged = TRUE;
}
}
}
inline void Effect::SetTexture(HANDLE hObject, const BaseTexture *texture)
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
BOOL bSizeChanged = param->CurValue.SetSize(sizeof(const BaseTexture*));
const BaseTexture *&curVal = *(const BaseTexture**)param->CurValue.Array();
if(bSizeChanged || curVal != texture)
{
curVal = texture;
if(param->bValid && !param->bChanged)
{
param->nextChanged = firstChanged;
firstChanged = param;
param->bChanged = TRUE;
}
}
}
inline void Effect::SetInt(HANDLE hObject, int iValue)
{
assert(hObject);
EffectParam *param = ConvertParam(hObject);
//if(!param) return;
BOOL bSizeChanged = param->CurValue.SetSize(sizeof(int));
int &curVal = *(int*)param->CurValue.Array();
if(bSizeChanged || curVal != iValue)
{
curVal = iValue;
if(param->bValid && !param->bChanged)
{
param->nextChanged = firstChanged;
firstChanged = param;
param->bChanged = TRUE;
}
}
}
void InterceptLog::GetErrorStringValue(uint errorCode, string &retString)
{
//If we do no have the index of glGetError yet, get it
if(glGetErrorFuncIndex < 0)
{
//Get the index of the function
glGetErrorFuncIndex = functionTable->FindFunction("glGetError");
}
//If there is a valid index
const FunctionData * glGetErrorFuncData = NULL;
if(glGetErrorFuncIndex != -1)
{
//Get the function data
// (Note: The returned pointer is not permanent (as future calls may add to the table)
// so we can only store the function index)
glGetErrorFuncData = functionTable->GetFunctionData(glGetErrorFuncIndex);
}
//If the function is still not found, just log the number
if(glGetErrorFuncData == NULL || glGetErrorFuncData->returnType.type != PT_enum)
{
StringPrintF(retString,"0x%04x",errorCode);
}
else
{
//Get the return parameter
const ParameterData * returnData = &glGetErrorFuncData->returnType;
//Get the string version
ParamValue value;
value.enumValue = errorCode;
retString = ConvertParam(value, false, returnData);
}
}
void InterceptLog::GetFunctionString(const FunctionData *funcData,uint index, const FunctionArgs & args, string &retString)
{
//Append the function name first
retString = funcData->GetName() + "(";
//Get a copy of the arguments
FunctionArgs newArgs(args);
//Loop for all the parameters
for(uint i=0;i<funcData->parameterArray.size();i++)
{
// LOGERR(("arg.size()=%d\n",funcData->parameterArray.size()));
//Get the parameter
const ParameterData * paramData = &funcData->parameterArray[i];
LOGERR(("The paramDateName:%d, %s\n",paramData->type,paramData->paramName.c_str()));
//Determine if we are processing pointers
bool isPointer=false;
if(paramData->pointerCount > 0 || paramData->length != -1)
{
isPointer=true;
}
//Get the value
ParamValue value;
////¼Ó²âÊÔÖ¸Õë
if(strcmp((funcData->GetName()).c_str(),"glLightfv")==0&&isPointer){
const GLfloat* V; newArgs.Get(V);
value.pointerValue =(void*) V;
LOGERR(("The length of this parametre is : lengh = %d\n ,Count = %d\n ", paramData->length,paramData->pointerCount));
LOGERR(("glLightfv:%f,%f,%f,%f\n",V[0],V[1],V[2],V[3]));
//LOGERR(("²ÎÊýÐòºÅ%d\n",i))
}
////²âÊÔÖ¸ÕëÍê±Ï
else if(!GetNextValue(paramData->GetGLType(),newArgs,isPointer, value))
{
break;
}
//Test if this is an array value
if(paramData->length != -1)
{
bool isArrayOfPointers = false;
//Test for an array of pointers
if(paramData->pointerCount > 0)
{
isArrayOfPointers = true;
}
//Assign the array
void * array = value.pointerValue;
//Loop and print the array
retString += "[";
for(uint i2=0;i2<(uint)paramData->length;i2++)
{
//Get the value from the array
if(!GetNextArrayValue(paramData->GetGLType(),&array,isArrayOfPointers, value))
{
break;
}
//Convert and print the value
retString += ConvertParam(value,isArrayOfPointers,paramData);
//Add a comma
if(i2 != (uint)(paramData->length - 1))
{
retString += ",";
}
}
retString += "]";
}
else
{
//Just get the single value
retString += ConvertParam(value,isPointer,paramData);
}
//Add a comma if there are more parameters
if(i != funcData->parameterArray.size() - 1)
{
retString += ",";
}
}
//If there are no parameters (unknown function)
if(funcData->parameterArray.size() == 0)
{
retString += " ??? ";
}
//Close the bracket
retString += ")";
}
