dBTheme::dBTheme()
{
resourceCache.Init();
pThemeConfig = MFIni::Create("theme:theme");
MFDebug_Assert(pThemeConfig, "Couldn't load theme theme.ini");
MFIniLine *pLine = pThemeConfig->GetFirstLine();
while(pLine)
{
if(pLine->IsSection("Theme"))
{
MFIniLine *pSub = pLine->Sub();
while(pSub)
{
if(pSub->IsString(0, "name"))
{
pThemeName = pSub->GetString(1);
}
else if(pSub->IsString(0, "startscreen"))
{
pStartScreen = pSub->GetString(1);
}
pSub = pSub->Next();
}
}
else if(pLine->IsSection("Resources"))
{
LoadResources(pLine->Sub(), &resourceCache);
}
else if(pLine->IsSection("Metrics"))
{
}
pLine = pLine->Next();
}
}
dBThemeScreen::dBThemeScreen(const char *pScreenName, dBTheme *_pTheme)
{
pTheme = _pTheme;
resourceCache.Init();
entityPool.Init(this);
actionManager.Init(this);
pThemeScreen = MFIni::Create(pScreenName);
MFDebug_Assert(pThemeScreen, MFStr("Couldn't load screen '%s'", pScreenName));
MFIniLine *pLine = pThemeScreen->GetFirstLine();
while(pLine)
{
if(pLine->IsSection("Screen"))
{
MFIniLine *pSLine = pLine->Sub();
while(pSLine)
{
if(pSLine->IsString(0, "name"))
{
pScreenName = pSLine->GetString(1);
}
else if(pSLine->IsString(0, "selection"))
{
// default selected entity
}
else if(pSLine->IsString(0, "clearcolour"))
{
clearColour = pSLine->GetVector4(1);
}
else if(pSLine->IsSection("Resources"))
{
LoadResources(pSLine->Sub(), &resourceCache);
}
else if(pSLine->IsSection("Metrics"))
{
MFIniLine *pSub = pSLine->Sub();
while(pSub)
{
dBThemeMetric &metric = metrics.push();
metric.pName = pSub->GetString(0);
metric.pMetric = actionManager.ParseMetric(pSub->GetString(1));
pSub = pSub->Next();
}
}
else if(pSLine->IsSection("Actions"))
{
MFIniLine *pSub = pSLine->Sub();
while(pSub)
{
dBThemeAction &action = actions.push();
action.pName = pSub->GetString(0);
action.pScript = actionManager.ParseScript(pSub->GetString(1));
pSub = pSub->Next();
}
}
else if(pSLine->IsSection("Entities"))
{
MFIniLine *pSub = pSLine->Sub();
while(pSub)
{
if(pSub->IsString(0, "section"))
{
MFIniLine *pEntity = pSub->Sub();
while(pEntity)
{
if(pEntity->IsString(0, "name"))
{
dBEntity *pNewEntity = entityPool.Create(pSub->GetString(1), pEntity->GetString(1));
pNewEntity->Init(&actionManager, pSub->Sub());
break;
}
pEntity = pEntity->Next();
}
}
pSub = pSub->Next();
}
}
pSLine = pSLine->Next();
}
}
pLine = pLine->Next();
}
// init all the entities
dBEntity *pE = NULL;
while(pE = entityPool.Iterate(pE))
{
pE->SignalEvent("init", NULL);
}
}
void MaterialInternal_InitialiseFromDefinition(MFIni *pDefIni, MFMaterial *pMat, const char *pDefinition)
{
MFCALLSTACK;
MFIniLine *pLine = pDefIni->GetFirstLine()->FindEntry("section", pDefinition);
if(pLine)
{
pLine = pLine->Sub();
if(pLine && pLine->IsString(0, "type"))
{
pMat->pType = MaterialInternal_GetMaterialType(pLine->GetString(1));
if(!pMat->pType)
pMat->pType = MaterialInternal_GetMaterialType("Standard");
pLine = pLine->Next();
}
else
{
pMat->pType = MaterialInternal_GetMaterialType("Standard");
}
if(pMat->pType->materialCallbacks.pCreateInstance)
pMat->pType->materialCallbacks.pCreateInstance(pMat);
while(pLine)
{
if(pLine->IsString(0,"type"))
{
MFDebug_Warn(2, MFStr("'type' MUST be the first parameter in a material definition... Ignored, Using type '%s'.", pMat->pType->pTypeName));
}
else if(pLine->IsString(0,"alias"))
{
MFDebug_Warn(2, "'alias' MUST be the first parameter in a material definition... Ignored.");
MFDebug_Assert(false, "Fix Me!!!");
// const char *pAlias = pLine->GetString(1);
// MaterialInternal_InitialiseFromDefinition(pDefIni, pMat, pAlias);
}
else
{
const char *pParam = pLine->GetString(0);
MFMaterialParameterInfo *pInfo = MFMaterial_GetParameterInfoFromName(pMat, pParam);
int lineArg = 1;
int param = pInfo->parameterIndex;
int argIndex = 0;
switch(pInfo->argIndex.type)
{
case MFParamType_Int:
argIndex = pLine->GetInt(lineArg++);
break;
case MFParamType_Enum:
argIndex = pLine->GetEnum(lineArg++, pInfo->argIndex.pEnumKeys);
break;
default:
argIndex = pInfo->argIndex.defaultValue;
break;
}
switch(pInfo->argIndexHigh.type)
{
case MFParamType_Int:
argIndex |= pLine->GetInt(lineArg++) << 16;
break;
case MFParamType_Enum:
argIndex |= pLine->GetEnum(lineArg++, pInfo->argIndexHigh.pEnumKeys) << 16;
break;
default:
argIndex |= pInfo->argIndexHigh.defaultValue << 16;
break;
}
if(pInfo->numValues == 1)
{
switch(pInfo->pValues[0].type)
{
case MFParamType_Constant:
{
MFMaterial_SetParameterI(pMat, param, argIndex, pInfo->pValues[0].defaultValue);
break;
}
case MFParamType_String:
{
const char *pString = pLine->GetString(lineArg);
MFMaterial_SetParameterS(pMat, param, argIndex, pString);
break;
}
case MFParamType_Float:
{
float value = pLine->GetFloat(lineArg);
MFMaterial_SetParameterF(pMat, param, argIndex, value);
break;
}
case MFParamType_Int:
{
int value = pLine->GetStringCount() > lineArg ? pLine->GetInt(lineArg) : pInfo->pValues[0].defaultValue;
MFMaterial_SetParameterI(pMat, param, argIndex, value);
break;
}
case MFParamType_Enum:
{
int value;
if(pLine->GetStringCount() > lineArg)
value = pLine->GetEnum(lineArg, pInfo->pValues[0].pEnumKeys);
else
value = pInfo->pValues[0].defaultValue;
MFMaterial_SetParameterI(pMat, param, argIndex, value);
break;
}
case MFParamType_Bool:
{
bool value = pLine->GetStringCount() > lineArg ? pLine->GetBool(lineArg) : !!pInfo->pValues[0].defaultValue;
MFMaterial_SetParameterI(pMat, param, argIndex, value ? 1 : 0);
break;
}
case MFParamType_Colour:
{
MFVector vector = pLine->GetColour(lineArg);
MFMaterial_SetParameterV(pMat, param, argIndex, vector);
break;
}
case MFParamType_Vector3:
{
MFVector vector = pLine->GetVector3(lineArg);
MFMaterial_SetParameterV(pMat, param, argIndex, vector);
break;
}
case MFParamType_Vector4:
{
MFVector vector = pLine->GetVector4(lineArg);
MFMaterial_SetParameterV(pMat, param, argIndex, vector);
break;
}
case MFParamType_Matrix:
{
MFDebug_Assert(false, "Cant read a matrix from an ini file... yet...");
break;
}
default:
MFDebug_Assert(false, "Unknown parameter type..");
}
}
else if(pInfo->numValues > 1)
{
// produce a struct representing the args
MFALIGN_BEGIN(16)
char argBuffer[256]
MFALIGN_END(16);
int offset = 0;
for(int a=0; a<pInfo->numValues; a++)
{
switch(pInfo->pValues[a].type)
{
case MFParamType_Constant:
{
offset = MFALIGN(offset, sizeof(int));
(int&)argBuffer[offset] = pInfo->pValues[a].defaultValue;
offset += sizeof(int);
break;
}
case MFParamType_String:
{
offset = MFALIGN(offset, sizeof(const char *));
(const char *&)argBuffer[offset] = pLine->GetString(lineArg++);
offset += sizeof(const char *);
break;
}
case MFParamType_Float:
{
offset = MFALIGN(offset, sizeof(float));
(float&)argBuffer[offset] = pLine->GetFloat(lineArg++);
offset += sizeof(float);
break;
}
case MFParamType_Int:
{
offset = MFALIGN(offset, sizeof(int));
(int&)argBuffer[offset] = pLine->GetInt(lineArg++);
offset += sizeof(int);
break;
}
case MFParamType_Enum:
{
offset = MFALIGN(offset, sizeof(int));
(int&)argBuffer[offset] = pLine->GetEnum(lineArg++, pInfo->pValues[a].pEnumKeys);
offset += sizeof(int);
break;
}
case MFParamType_Bool:
{
offset = MFALIGN(offset, sizeof(bool));
(bool&)argBuffer[offset] = pLine->GetBool(lineArg++);
offset += sizeof(bool);
break;
}
case MFParamType_Colour:
case MFParamType_Vector3:
case MFParamType_Vector4:
case MFParamType_Matrix:
{
MFDebug_Assert(false, "Cant read type into structure... yet...");
break;
}
default:
MFDebug_Assert(false, "Unknown parameter type..");
}
}
MFMaterial_SetParameter(pMat, param, argIndex, (uintp)argBuffer);
}
}
pLine = pLine->Next();
}
}
