MF_API bool MFAsset_ConvertAssetFromFile(const char *pFilename, void **ppOutput, size_t *pSize, MFPlatform platform, size_t extraBytes)
{
// should this request be forewarded to the file server, or should we do it locally?
//... todo
size_t size;
if(!MFIntAsset_ConvertAssetFromFile(pFilename, ppOutput, &size, platform, extraBytes) || !*ppOutput)
return false;
if(pSize)
*pSize = size;
const char *pExt = MFString_GetFileExtension(pFilename);
const char *pCacheExt = NULL;
if(!MFString_CaseCmp(pExt, ".mfx"))
pCacheExt = ".bfx";
else if(!MFString_CaseCmp(pExt, ".fnt"))
pCacheExt = ".fft";
else if(!MFAsset_IsSoundFile(pExt))
pCacheExt = ".snd";
else if(!MFAsset_IsImageFile(pExt))
pCacheExt = ".tex";
else if(!MFAsset_IsGeometryFile(pExt))
pCacheExt = ".mdl";
else if(!MFAsset_IsShaderFile(pExt))
pCacheExt = ".fsh";
MFFile *pFile = MFFileSystem_Open(MFStr("cache:%s%s", pFilename, pCacheExt), MFOF_Write | MFOF_Binary);
if(pFile)
{
MFFile_Write(pFile, *ppOutput, size, false);
MFFile_Close(pFile);
}
return true;
}
char* ReadMaterialChunk(char *pFilePtr, char *pToken)
{
if(!MFString_CaseCmp(pToken, "*MATERIAL_COUNT"))
{
int count;
pFilePtr = GetInt(pFilePtr, &count);
pModel->GetMaterialChunk()->materials.resize(count);
MFDebug_Log(4, MFStr("Found %d materials.", count));
}
else if(!MFString_CaseCmp(pToken, "*MATERIAL"))
{
int matID;
pFilePtr = GetInt(pFilePtr, &matID);
pMaterial = &pModel->GetMaterialChunk()->materials[matID];
pFilePtr = ProcessBlock(pFilePtr, "*MATERIAL", ReadMaterial);
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
int MFRenderer_GetCurrentRendererPlugin()
{
if(!MFString_CaseCmp("D3D9", gpCurrentRenderPlugin->pDriverName))
return MF_DRIVER_D3D9;
else if(!MFString_CaseCmp("D3D11", gpCurrentRenderPlugin->pDriverName))
return MF_DRIVER_D3D11;
else if(!MFString_CaseCmp("OpenGL", gpCurrentRenderPlugin->pDriverName))
return MF_DRIVER_OPENGL;
return -1;
}
void HKWidgetListbox::SetProperty(const char *pProperty, const char *pValue)
{
if(!MFString_CaseCmp(pProperty, "orientation"))
SetOrientation((Orientation)HKWidget_GetEnumValue(pValue, sOrientationKeys));
else if(!MFString_CaseCmp(pProperty, "hoverSelect"))
flags |= HKWidget_GetBoolFromString(pValue) ? HoverSelect : 0;
else if(!MFString_CaseCmp(pProperty, "onSelChanged"))
HKWidget_BindWidgetEvent(OnSelChanged, pValue);
else
HKWidgetLayout::SetProperty(pProperty, pValue);
}
void HKWidgetPrefab::SetProperty(const char *pProperty, const char *pValue)
{
if(!MFString_CaseCmp(pProperty, "prefab"))
LoadPrefab(pValue);
else
HKWidget::SetProperty(pProperty, pValue);
}
MFString HKWidgetLabel::GetProperty(const char *pProperty)
{
if(!MFString_CaseCmp(pProperty, "text"))
return GetText();
else if(!MFString_CaseCmp(pProperty, "text_font"))
{
if(bOwnFont)
return font;
else
// return MFFont_GetFontName(pFont);
return NULL;
}
else if(!MFString_CaseCmp(pProperty, "text_align"))
return HKWidget_GetEnumFromValue(GetTextJustification(), sJustifyKeys);
return HKWidget::GetProperty(pProperty);
}
void HKWidgetLayoutLinear::SetProperty(const char *pProperty, const char *pValue)
{
if(!MFString_CaseCmp(pProperty, "orientation"))
SetOrientation((Orientation)HKWidget_GetEnumValue(pValue, sOrientationKeys));
else
HKWidgetLayout::SetProperty(pProperty, pValue);
}
void GotoSection(int cancel, const char *pString)
{
if(cancel || !*pString) return;
const char *pTest = pString;
while(*pTest && (MFIsNumeric(*pTest) || *pTest == '.'))
++pTest;
int res = gEditor.pSong->GetRes();
if(pTest > pString)
{
if(!*pTest)
{
OffsetToMeasureAndBeat((int)((float)atof(pString) * res), &gEditor.measure, &gEditor.beat);
return;
}
if(!MFString_CaseCmp(pTest, "s"))
{
float time = (float)atof(pString);
OffsetToMeasureAndBeat(gEditor.pSong->CalculateTickAtTime((int64)(time*1000000.0f)), &gEditor.measure, &gEditor.beat);
return;
}
else if(!MFString_CaseCmp(pTest, "ms"))
{
float time = (float)atof(pString);
OffsetToMeasureAndBeat(gEditor.pSong->CalculateTickAtTime((int64)(time*1000.0f)), &gEditor.measure, &gEditor.beat);
return;
}
}
// find section by name
size_t len = MFString_Length(pString);
GHEvent *pSE = gEditor.pSong->events.First();
while(pSE)
{
if(!MFString_CaseCmpN(pSE->GetString(), "section ", 8) && !MFString_CaseCmpN(&pSE->GetString()[8], pString, len))
{
OffsetToMeasureAndBeat(pSE->tick, &gEditor.measure, &gEditor.beat);
return;
}
pSE = pSE->Next();
}
}
bool HKWidgetRenderer::SetProperty(const char *pProperty, const char *pValue, HKWidget *pWidget)
{
if(!MFString_CaseCmp(pProperty, "background_image"))
{
if(pImage)
MFMaterial_Destroy(pImage);
pImage = MFMaterial_Create(pValue);
if(pImage)
{
int texW, texH;
MFTexture *pTex = MFMaterial_GetParameterT(pImage, MFMatStandard_Texture, MFMatStandard_Tex_DifuseMap);
MFTexture_GetTextureDimensions(pTex, &texW, &texH);
texWidth = (float)texW;
texHeight = (float)texH;
if(pWidget && (pWidget->bAutoWidth || pWidget->bAutoHeight))
{
if(pWidget->bAutoWidth && pWidget->bAutoHeight)
pWidget->Resize(MakeVector(texWidth, texHeight));
else if(pWidget->bAutoWidth)
pWidget->UpdateWidth(texWidth);
else
pWidget->UpdateHeight(texHeight);
}
}
return true;
}
else if(!MFString_CaseCmp(pProperty, "background_align"))
{
imageAlignment = (HKWidget::Justification)HKWidget_GetEnumValue(pValue, HKWidget::sJustifyKeys);
return true;
}
else if(!MFString_CaseCmp(pProperty, "background_colour"))
{
colour = HKWidget_GetColourFromString(pValue);
return true;
}
else if(!MFString_CaseCmp(pProperty, "background_padding"))
{
padding = HKWidget_GetVectorFromString(pValue);
return true;
}
else if(!MFString_CaseCmp(pProperty, "background_9-cell-margin"))
{
margin9Cell = MFString_AsciiToFloat(pValue);
return true;
}
else if(!MFString_CaseCmp(pProperty, "border_width"))
{
border = HKWidget_GetVectorFromString(pValue);
return true;
}
else if(!MFString_CaseCmp(pProperty, "border_colour"))
{
borderColour = HKWidget_GetColourFromString(pValue);
return true;
}
return false;
}
int MFCallstack_SortPred(const void *pF1, const void *pF2)
{
MFCallstack_Function *pFunc1 = *(MFCallstack_Function**)pF1;
MFCallstack_Function *pFunc2 = *(MFCallstack_Function**)pF2;
return MFString_CaseCmp(pFunc1->pFunctionName, pFunc2->pFunctionName);
// return pFunc1->totalTime < pFunc2->totalTime;
// return pFunc1->numCalls < pFunc2->numCalls;
}
MF_API int MFString_Enumerate(const char *pString, const char **ppKeys, size_t numKeys, bool bCaseSensitive)
{
for(size_t i=0; i<numKeys && ppKeys[i]; ++i)
{
if(bCaseSensitive ? !MFString_Compare(pString, ppKeys[i]) : !MFString_CaseCmp(pString, ppKeys[i]))
return (int)i;
}
return -1;
}
int GetJustificationFromString(const char *pString)
{
for(int a=0; a<sizeof(gJustifyStrings) / sizeof(gJustifyStrings[0]); ++a)
{
if(!MFString_CaseCmp(pString, gJustifyStrings[a]))
return a;
}
return 0;
}
MFMount* MFFileSystem_FindVolume(const char *pVolumeName)
{
GET_MODULE_DATA(MFFileSystemState);
for(MFMount *pT = pModuleData->pMountList; pT; pT = pT->pNext)
{
if(!MFString_CaseCmp(pT->volumeInfo.pVolumeName, pVolumeName))
return pT;
}
return NULL;
}
char* ReadFaceList(char *pFilePtr, char *pToken)
{
if(!MFString_CaseCmp(pToken, "*MESH_FACE"))
{
char *pLabel;
int index;
pFilePtr = GetLabel(pFilePtr, &pLabel);
index = atoi(pLabel);
pFilePtr = GetLabel(pFilePtr, &pLabel);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 0].position);
pSub->matSubobjects[0].triangles[index].v[0] = index*3 + 0;
pFilePtr = GetLabel(pFilePtr, &pLabel);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 1].position);
pSub->matSubobjects[0].triangles[index].v[2] = index*3 + 1;
pFilePtr = GetLabel(pFilePtr, &pLabel);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 2].position);
pSub->matSubobjects[0].triangles[index].v[1] = index*3 + 2;
pSub->matSubobjects[0].triangles[index].reserved = 0;
}
if(!MFString_CaseCmp(pToken, "*MESH_SMOOTHING"))
{
}
if(!MFString_CaseCmp(pToken, "*MESH_MTLID"))
{
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
void HKWidgetLabel::SetProperty(const char *pProperty, const char *pValue)
{
if(!MFString_CaseCmp(pProperty, "text"))
SetText(pValue);
else if(!MFString_CaseCmp(pProperty, "text_colour"))
SetTextColour(HKWidget_GetColourFromString(pValue));
else if(!MFString_CaseCmp(pProperty, "text_height"))
SetTextHeight(MFString_AsciiToFloat(pValue));
else if(!MFString_CaseCmp(pProperty, "text_shadowDepth"))
SetShadowDepth(MFString_AsciiToFloat(pValue));
else if(!MFString_CaseCmp(pProperty, "text_font"))
{
if(bOwnFont)
MFFont_Release(pFont);
pFont = MFFont_Create(pValue);
bOwnFont = true;
if(bAutoTextHeight)
textHeight = MFFont_GetFontHeight(pFont);
AdjustSize();
}
else if(!MFString_CaseCmp(pProperty, "text_align"))
SetTextJustification((MFFontJustify)HKWidget_GetEnumValue(pValue, sJustifyKeys));
else
HKWidget::SetProperty(pProperty, pValue);
}
dBEntity *dBScene::FindEntity(const char *pName, int layer)
{
dBEntity **ppI = entities.Begin();
while(*ppI)
{
if(!MFString_CaseCmp((*ppI)->GetName(), pName))
return *ppI;
++ppI;
}
return NULL;
}
// open a file from the mounted filesystem stack
MF_API MFFile* MFFileSystem_Open(const char *pFilename, uint32 openFlags)
{
MFDebug_Log(5, MFStr("Call: MFFileSystem_Open(\"%s\", 0x%x)", pFilename, openFlags));
GET_MODULE_DATA(MFFileSystemState);
MFMount *pMount = pModuleData->pMountList;
const char *pMountpoint = NULL;
// search for a mountpoint
size_t len = MFString_Length(pFilename);
for(size_t a=0; a<len; a++)
{
if(pFilename[a] == ':')
{
pMountpoint = MFStrN(pFilename, a);
pFilename += a+1;
break;
}
if(pFilename[a] == '.')
{
// if we have found a dot, this cant be a mountpoint
// (mountpoints may only be alphanumeric)
break;
}
}
// search for file through the mount list...
while(pMount)
{
int onlyexclusive = pMount->volumeInfo.flags & MFMF_OnlyAllowExclusiveAccess;
if((!pMountpoint && !onlyexclusive) || (pMountpoint && !MFString_CaseCmp(pMountpoint, pMount->volumeInfo.pVolumeName)))
{
// open the file from a mount
MFFile *hFile = pModuleData->ppFileSystemList[pMount->volumeInfo.fileSystem]->callbacks.FSOpen(pMount, pFilename, openFlags);
if(hFile)
return hFile;
}
pMount = pMount->pNext;
}
if(!(openFlags & MFOF_TryOpen))
MFDebug_Warn(4, MFStr("MFFile_Open(\"%s\", 0x%x) - Failed to open file", pFilename, openFlags));
return NULL;
}
char* ReadNormals(char *pFilePtr, char *pToken)
{
static int curFace = 0;
static int curNormal = 0;
if(!MFString_CaseCmp(pToken, "*MESH_FACENORMAL"))
{
pFilePtr = GetInt(pFilePtr, &curFace);
pFilePtr = GetFloat(pFilePtr, &pSub->matSubobjects[0].triangles[curFace].normal.x);
pFilePtr = GetFloat(pFilePtr, &pSub->matSubobjects[0].triangles[curFace].normal.z);
pFilePtr = GetFloat(pFilePtr, &pSub->matSubobjects[0].triangles[curFace].normal.y);
curNormal = curFace*3;
}
if(!MFString_CaseCmp(pToken, "*MESH_VERTEXNORMAL"))
{
int index;
pFilePtr = GetInt(pFilePtr, &index);
pFilePtr = GetFloat(pFilePtr, &pSub->normals[curNormal].x);
pFilePtr = GetFloat(pFilePtr, &pSub->normals[curNormal].z);
pFilePtr = GetFloat(pFilePtr, &pSub->normals[curNormal].y);
pSub->matSubobjects[0].vertices[curNormal].normal = curNormal;
curNormal++;
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
MF_API MFMaterial* MFMaterial_Find(const char *pName)
{
MFCALLSTACK;
MFMaterial **ppIterator = gMaterialList.Begin();
while(*ppIterator)
{
if(!MFString_CaseCmp(pName, (*ppIterator)->pName)) return *ppIterator;
ppIterator++;
}
return NULL;
}
MFMaterialType *MaterialInternal_GetMaterialType(const char *pTypeName)
{
MFCALLSTACK;
MFMaterialType **ppIterator = gMaterialRegistry.Begin();
while(*ppIterator)
{
if(!MFString_CaseCmp(pTypeName, (*ppIterator)->pTypeName)) return *ppIterator;
ppIterator++;
}
return NULL;
}
char* ReadSceneChunk(char *pFilePtr, char *pToken)
{
if(!MFString_CaseCmp(pToken, "*SCENE_FILENAME"))
{
char *pName;
pFilePtr = GetString(pFilePtr, &pName);
if(MFString_Length(pName) > 255)
{
MFDebug_Warn(3, MFStr("Error: More than 256 characters in nodel name, \"%s\"", pName));
return pFilePtr;
}
pModel->name = pName;
MFDebug_Log(4, MFStr("Model: %s", pName));
}
else if(!MFString_CaseCmp(pToken, "*SCENE_FIRSTFRAME"))
{
}
else if(!MFString_CaseCmp(pToken, "*SCENE_LASTFRAME"))
{
}
else if(!MFString_CaseCmp(pToken, "*SCENE_FRAMESPEED"))
{
}
else if(!MFString_CaseCmp(pToken, "*SCENE_TICKSPERFRAME"))
{
}
else if(!MFString_CaseCmp(pToken, "*SCENE_BACKGROUND_STATIC"))
{
}
else if(!MFString_CaseCmp(pToken, "*SCENE_AMBIENT_STATIC"))
{
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
MF_API int MFModel_GetTagIndex(MFModel *pModel, const char *pName)
{
MFModelDataChunk *pChunk = MFModel_GetDataChunk(pModel->pTemplate, MFChunkType_Tags);
if(pChunk)
{
MFModelTag *pTags = (MFModelTag*)pChunk->pData;
for(int a=0; a<pChunk->count; a++)
{
if(!MFString_CaseCmp(pTags[a].pTagName, pName))
return a;
}
}
return -1;
}
int AddToMaterials(const char *pMatName)
{
F3DMaterialChunk *pChunk = pModel->GetMaterialChunk();
for(int a=0; a<pChunk->materials.size(); a++)
{
if(!MFString_CaseCmp(pChunk->materials[a].name, pMatName))
return a;
}
int i = pChunk->materials.size();
F3DMaterial &mat = pChunk->materials.push();
MFString_Copy(mat.name, pMatName);
return i;
}
char* ReadTFaceList(char *pFilePtr, char *pToken)
{
if(!MFString_CaseCmp(pToken, "*MESH_TFACE"))
{
int index;
pFilePtr = GetInt(pFilePtr, &index);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 0].uv[0]);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 1].uv[0]);
pFilePtr = GetInt(pFilePtr, (int*)&pSub->matSubobjects[0].vertices[index*3 + 2].uv[0]);
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
MF_API bool DebugMenu_DestroyMenu(const char *pName, Menu *pSearchMenu)
{
for(int a=0; a<pSearchMenu->numChildren; a++)
{
if(pSearchMenu->pChildren[a]->type == MenuType_Menu)
{
if(!MFString_CaseCmp(pSearchMenu->pChildren[a]->name, pName))
{
DebugMenu_DestroyMenuTree((Menu*)pSearchMenu->pChildren[a]);
return true;
}
if(DebugMenu_DestroyMenu(pName, (Menu*)pSearchMenu->pChildren[a]))
return true;
}
}
return false;
}
MF_API Menu* DebugMenu_GetMenuByName(const char *name, Menu *pSearchMenu)
{
Menu *pResult = NULL;
for(int a=0; a<pSearchMenu->numChildren; a++)
{
if(pSearchMenu->pChildren[a]->type == MenuType_Menu)
{
if(!MFString_CaseCmp(pSearchMenu->pChildren[a]->name , name))
return (Menu*)pSearchMenu->pChildren[a];
pResult = DebugMenu_GetMenuByName(name, (Menu*)pSearchMenu->pChildren[a]);
if(pResult) return pResult;
}
}
return NULL;
}
char* ReadVertList(char *pFilePtr, char *pToken)
{
if(!MFString_CaseCmp(pToken, "*MESH_VERTEX"))
{
int index;
pFilePtr = GetInt(pFilePtr, &index);
pFilePtr = GetFloat(pFilePtr, &pSub->positions[index].x);
pFilePtr = GetFloat(pFilePtr, &pSub->positions[index].z);
pFilePtr = GetFloat(pFilePtr, &pSub->positions[index].y);
}
else
{
MFDebug_Warn(3, MFStr("Unknown token: %s", pToken));
}
return pFilePtr;
}
MFTOCEntry *MFFileSystem_GetTocEntry(const char *pFilename, MFTOCEntry *pEntry, int numEntries)
{
MFCALLSTACK;
const char *pSearchString = pFilename;
size_t nameLen = MFString_Length(pFilename);
bool isDirectory = false;
for(size_t a=0; a<nameLen; a++)
{
if(pFilename[a] == '/')
{
isDirectory = true;
pSearchString = MFStrN(pFilename, a);
pFilename += a+1;
break;
}
}
for(int a=0; a<numEntries; a++)
{
if(!MFString_CaseCmp(pSearchString, pEntry[a].pName))
{
if(isDirectory)
{
if(pEntry[a].info.attributes & MFFA_Directory)
{
return MFFileSystem_GetTocEntry(pFilename, pEntry[a].pChildren, pEntry[a].numChildren);
}
}
else
{
if(!(pEntry[a].info.attributes & MFFA_Directory))
{
return &pEntry[a];
}
}
}
}
return NULL;
}
const char* GetMaterialName(const char *pSkin, const char *pSubobjectName)
{
if(pSkin)
{
char *pTok = MFString_Chr(pSkin, ',');
while(pTok)
{
char *pT = pTok-1;
for(; pT > pSkin && pT[-1] != '\n'; --pT) { }
// get subobject name
char *pTokTemp = pTok - (uintp)pT;
const char *pSubName = MFStrN(pT, (int&)pTokTemp);
++pTok;
if(!MFString_CaseCmp(pSubName, pSubobjectName))
{
for(pT = pTok; *pT != 0 && *pT != '\r' && *pT != '\n'; ++pT) { }
// get texture name
pTokTemp = pT - (uintp)pTok;
char *pMaterialName = (char*)MFStrN(pTok, (int&)pTokTemp);
for(pT = pMaterialName+MFString_Length(pMaterialName); pT > pMaterialName && pT[-1] != '/' && pT[-1] != '\\' && pT[-1] != '\n' && pT[-1] != '\r'; --pT) { }
pT[MFString_Length(pT) - 4] = 0;
return pT;
}
pTok = MFString_Chr(pTok, ',');
}
}
return NULL;
}
MFString HKWidgetLayoutLinear::GetProperty(const char *pProperty)
{
if(!MFString_CaseCmp(pProperty, "orientation"))
return HKWidget_GetEnumFromValue(GetOrientation(), sOrientationKeys);
return HKWidgetLayout::GetProperty(pProperty);
}
