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); }