VFS_BOOL CArchive::IterateDir( const VFS_String& strDirName, VFS_DirIterationProc pIterationProc, VFS_BOOL bRecursive, void* pParam ) const { // Get the dir for the name. VFS_DWORD dwDirIndex; VFS_String strDir = WithoutTrailingSeparator( ToLower( strDirName ), VFS_TRUE ); if( strDir != VFS_TEXT( "" ) ) { ArchiveDirMap::const_iterator iter = m_Header.DirHash.find( ToLower( strDir ) ); if( iter == m_Header.DirHash.end() ) { SetLastError( VFS_ERROR_NOT_FOUND ); return VFS_FALSE; } dwDirIndex = ( *iter ).second; } else dwDirIndex = DIR_INDEX_ROOT; // Iterate for all Dirs in the Dir and call IterateDir() on these (if in Recursive Mode). VFS_DWORD dwIndex; for( dwIndex = 0; dwIndex < m_Header.Dirs.size(); dwIndex++ ) { if( m_Header.Dirs[ dwIndex ].dwParentDirIndex != dwDirIndex ) continue; VFS_EntityInfo Info; Info.bArchived = VFS_TRUE; Info.eType = VFS_DIR; Info.lSize = 0; Info.strPath = GetFileNameWithoutExtension() + VFS_PATH_SEPARATOR + m_Header.Dirs[ dwIndex ].strName; if( !VFS_Util_GetName( Info.strPath, Info.strName ) ) return VFS_FALSE; if( !pIterationProc( Info, pParam ) ) return VFS_TRUE; if( bRecursive && !IterateDir( m_Header.Dirs[ dwIndex ].strName, pIterationProc, bRecursive, pParam ) ) return VFS_FALSE; } // Iterate for all Files in the Dir. for( dwIndex = 0; dwIndex < m_Header.Files.size(); dwIndex++ ) { if( m_Header.Files[ dwIndex ].dwDirIndex != dwDirIndex ) continue; VFS_EntityInfo Info; Info.bArchived = VFS_TRUE; Info.eType = VFS_FILE; Info.lSize = m_Header.Files[ dwIndex ].dwUncompressedSize; Info.strPath = GetFileNameWithoutExtension() + VFS_PATH_SEPARATOR + m_Header.Files[ dwIndex ].strName; if( !VFS_Util_GetName( Info.strPath, Info.strName ) ) return VFS_FALSE; if( !pIterationProc( Info, pParam ) ) return VFS_TRUE; } return VFS_TRUE; }
void Model::CreateFromXFile(ID3D11Device* device, LPCWSTR fileName, const WCHAR* normalMapSuffix, bool generateNormals, bool generateTangentFrame, Mesh::IndexType idxType) { _ASSERT(FileExists(fileName)); IDirect3DDevice9Ptr d3d9Device = CreateD3D9Device(); // Load the D3DX mesh ID3DXMesh* d3dxMesh = NULL; ID3DXBuffer* adjacencyBuffer = NULL; ID3DXBuffer* materialsBuffer = NULL; DWORD numMaterials = 0; UINT options = D3DXMESH_MANAGED; if (idxType == Mesh::Index32Bit) options |= D3DXMESH_32BIT; DXCall(D3DXLoadMeshFromXW(fileName, options, d3d9Device, &adjacencyBuffer, &materialsBuffer, NULL, &numMaterials, &d3dxMesh)); IUnknownReleaser<ID3DXMesh> meshReleaser(d3dxMesh); IUnknownReleaser<ID3DXBuffer> adjReleaser(adjacencyBuffer); IUnknownReleaser<ID3DXBuffer> matReleaser(materialsBuffer); DWORD* initalAdjacency = reinterpret_cast<DWORD*>(adjacencyBuffer->GetBufferPointer()); D3DXMATERIAL* materials = reinterpret_cast<D3DXMATERIAL*>(materialsBuffer->GetBufferPointer()); // Get the directory the mesh was loaded from wstring fileDirectory = GetDirectoryFromFileName(fileName); // Convert materials for (UINT i = 0; i < numMaterials; ++i) { MeshMaterial material; D3DXMATERIAL& srcMaterial = materials[i]; material.AmbientAlbedo = XMFLOAT3(reinterpret_cast<float*>(&srcMaterial.MatD3D.Ambient)); material.DiffuseAlbedo = XMFLOAT3(reinterpret_cast<float*>(&srcMaterial.MatD3D.Diffuse)); material.SpecularAlbedo = XMFLOAT3(reinterpret_cast<float*>(&srcMaterial.MatD3D.Specular)); material.Emissive = XMFLOAT3(reinterpret_cast<float*>(&srcMaterial.MatD3D.Emissive)); material.SpecularPower = srcMaterial.MatD3D.Power; material.Alpha = srcMaterial.MatD3D.Diffuse.a; material.DiffuseMapName = AnsiToWString(srcMaterial.pTextureFilename); // Add the normal map prefix if (normalMapSuffix && material.DiffuseMapName.length() > 0) { wstring base = GetFileNameWithoutExtension(material.DiffuseMapName.c_str()); wstring extension = GetFileExtension(material.DiffuseMapName.c_str()); material.NormalMapName = base + normalMapSuffix + L"." + extension; } LoadMaterialResources(material, fileDirectory, device); } // Make a single mesh Mesh mesh; mesh.CreateFromD3DXMesh(fileDirectory, device, d3d9Device, d3dxMesh, generateNormals, generateTangentFrame, initalAdjacency, idxType); meshes.push_back(mesh); }
ImageGlyph::ImageGlyph(const std::string& file, AlloyContext* context, bool mipmap) : Glyph(GetFileNameWithoutExtension(file), GlyphType::Image, 0, 0), file( file) { handle = nvgCreateImage(context->nvgContext, file.c_str(), (mipmap) ? NVG_IMAGE_GENERATE_MIPMAPS : 0); int w, h; nvgImageSize(context->nvgContext, handle, &w, &h); width = (pixel) w; height = (pixel) h; }
void BackgroundUtil::GetBackgroundEffects( const RString &_sName, vector<RString> &vsPathsOut, vector<RString> &vsNamesOut ) { RString sName = _sName; if( sName == "" ) sName = "*"; vsPathsOut.clear(); GetDirListing( BACKGROUND_EFFECTS_DIR+sName+".lua", vsPathsOut, false, true ); vsNamesOut.clear(); FOREACH_CONST( RString, vsPathsOut, s ) vsNamesOut.push_back( GetFileNameWithoutExtension(*s) ); StripCvsAndSvn( vsPathsOut, vsNamesOut ); }
bool LoadMeshData(const char* i_binaryMeshFile) { uint32_t vertexElementCount = 0; VertexElement* pVertexElement = nullptr; uint32_t vertexOffset = 0; uint32_t vertexCount = 0; uint32_t indexOffset = 0; uint32_t indexCount = 0; uint32_t subMeshOffset = 0; uint32_t subMeshCount = 0; uint8_t* pBuffer = LoadMeshInfo(i_binaryMeshFile, vertexElementCount, pVertexElement, vertexOffset, vertexCount, indexOffset, indexCount, subMeshOffset, subMeshCount); AOSMeshData* pAOSMeshData = new AOSMeshData(); sVertex* pVertices = (sVertex*)(pBuffer + vertexOffset); for (uint32_t vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex) { sVertex& vertex = pVertices[vertexIndex]; pAOSMeshData->_vertices.push_back(vertex); } uint32_t* pIndices = (uint32_t*)(pBuffer + indexOffset); for (uint32_t index = 0; index < indexCount; index += 3) { uint32_t& indexValue0 = pIndices[index + 0]; uint32_t& indexValue1 = pIndices[index + 1]; uint32_t& indexValue2 = pIndices[index + 2]; pAOSMeshData->_indices.push_back(indexValue0); #if defined( EAEENGINE_PLATFORM_D3D9 ) pAOSMeshData->_indices.push_back(indexValue2); pAOSMeshData->_indices.push_back(indexValue1); #elif defined( EAEENGINE_PLATFORM_GL ) pAOSMeshData->_indices.push_back(indexValue1); pAOSMeshData->_indices.push_back(indexValue2); #endif } sSubMesh* pSubMeshes = (sSubMesh*)(pBuffer + subMeshOffset); for (uint32_t subMeshIndex = 0; subMeshIndex < subMeshCount; ++subMeshIndex) { sSubMesh* pSubMesh = pSubMeshes + subMeshIndex; pAOSMeshData->_subMeshes.push_back(*pSubMesh); } std::string mesh_path(i_binaryMeshFile); std::string key = GetFileNameWithoutExtension(mesh_path.c_str()); SAFE_DELETE_ARRAY(pBuffer); bool result = AOSMeshDataManager::GetInstance()->AddAOSMeshData(key.c_str(), pAOSMeshData); return result; }
void LanguagesDlg::OnSelchangeListThemes() { // TODO: Add your control notification handler code here m_listLanguages.ResetContent(); RString sTheme = GetCurrentString( m_listThemes ); if( !sTheme.empty() ) { RString sLanguagesDir = SpecialFiles::THEMES_DIR + sTheme + "/" + SpecialFiles::LANGUAGES_SUBDIR; vector<RString> vs; GetDirListing( sLanguagesDir+"*.ini", vs, false ); FOREACH_CONST( RString, vs, s ) { RString sIsoCode = GetFileNameWithoutExtension(*s); RString sLanguage = SMPackageUtil::GetLanguageDisplayString(sIsoCode); m_listLanguages.AddString( ConvertUTF8ToACP(sLanguage) ); }
AnsiString PathUtil::GetSafeLogFileName() { AnsiString logFileName = GetUserDirectory(); #ifdef __WIN32__ char moduleName[MAX_PATH]; ::GetModuleFileName(NULL, moduleName, MAX_PATH); AnsiString fileName = GetFileNameWithoutExtension(moduleName) + ".log"; fileName = Combine("/Wintermute Engine/Logs/", fileName); logFileName = Combine(logFileName, fileName); #else // !PORTME logFileName = Combine(logFileName, "/Wintermute Engine/wme.log"); #endif CreateDirectory(GetDirectoryName(logFileName)); return logFileName; }
/////////////////////////////////////TextureManager/////////////////////////////////// TextureInfo* TextureManager::LoadTexture(const char* pTexturePath) { std::string key = GetFileNameWithoutExtension(pTexturePath); for (std::map<const char*, TextureInfo>::const_iterator iter = _textures.begin(); iter != _textures.end(); ++iter) { if (strcmp(iter->first, key.c_str()) == 0) { return (TextureInfo*)&iter->second; } } TextureInfo textureInfo = {0.0f, 0.0f, 0}; bool result = LoadDDSTextureStatic(pTexturePath, textureInfo); _textures.insert(std::pair<const char*, TextureInfo>(_strdup(key.c_str()), textureInfo)); for (std::map<const char*, TextureInfo>::const_iterator iter = _textures.begin(); iter != _textures.end(); ++iter) { if (strcmp(iter->first, key.c_str()) == 0) { return (TextureInfo*)&iter->second; } } return nullptr; }
void LoadMaterial(const char* i_pBinaryMaterialFile) { // First, Load and set the material buffer uint32_t o_lengthOfWholerMaterialBuffer = 0; uint32_t o_lengthOfEffectPath = 0; uint8_t* pBuffer = LoadMaterialInfo(i_pBinaryMaterialFile, o_lengthOfWholerMaterialBuffer, o_lengthOfEffectPath); if (o_lengthOfWholerMaterialBuffer == 0) { SAFE_DELETE(pBuffer); return; } // Second, let's copy the buffer for real material uint8_t* pOutBuffer = new uint8_t[o_lengthOfWholerMaterialBuffer - o_lengthOfEffectPath]; SetMem(pOutBuffer, o_lengthOfWholerMaterialBuffer - o_lengthOfEffectPath, 0); CopyMem(pBuffer, pOutBuffer, o_lengthOfWholerMaterialBuffer - o_lengthOfEffectPath); MaterialDesc* pTtemp = (MaterialDesc*)pOutBuffer; assert(pTtemp->_sizeOfMaterialBuffer == o_lengthOfWholerMaterialBuffer); // Third, add this MaterialDesc buffer to the Material Map. std::string mat_path(i_pBinaryMaterialFile); std::string key = GetFileNameWithoutExtension(mat_path.c_str()); MaterialManager::GetInstance()->AddMaterialDesc(key.c_str(), pOutBuffer); SAFE_DELETE(pBuffer); }
// 获取随机文件名(全路径) tstring CPath::GetRandomFileName(LPCTSTR lpszPath, LPCTSTR lpszFileName) { tstring strPath, strFileName, strExtFileName, strFullPath; TCHAR szBuf[MAX_PATH] = {0}; if (!IsDirectoryExist(lpszPath)) strPath = GetCurDir(); else strPath = lpszPath; strFileName = GetFileNameWithoutExtension(lpszFileName); strExtFileName = GetExtension(lpszFileName); for (int i = 2; i < 10000; i++) { if (strExtFileName.empty()) { strFullPath = strPath; strFullPath += strFileName; wsprintf(szBuf, _T("%d"), i); strFullPath += szBuf; } else { strFullPath = strPath; strFullPath += strFileName; wsprintf(szBuf, _T("%d."), i); strFullPath += szBuf; strFullPath += strExtFileName; } if (!IsFileExist(strFullPath.c_str())) return strFullPath; } return _T(""); }
String Path::ChangeExtension(RCString path, RCString ext) { return Combine(GetDirectoryName(path), GetFileNameWithoutExtension(path) + ext); }
// Extraction. VFS_BOOL CArchive::Extract( const VFS_String& strTargetDir ) const { if( !VFS_Dir_Exists( strTargetDir ) ) if( !VFS_Dir_Create( strTargetDir, VFS_TRUE ) ) return VFS_FALSE; VFS_EntityInfo Info; if( !VFS_Dir_GetInfo( strTargetDir, Info ) ) return VFS_FALSE; VFS_String strTarget = WithoutTrailingSeparator( Info.strPath, VFS_TRUE ) + VFS_PATH_SEPARATOR; // Activate ourselves. if( !const_cast< CArchive* >( this )->Activate() ) return VFS_FALSE; // Extract all Dirs. VFS_DWORD dwIndex; for( dwIndex = 0; dwIndex < m_Header.Dirs.size(); dwIndex++ ) { VFS_String strDirName = strTarget + m_Header.Dirs[ dwIndex ].strName; if( !VFS_Dir_Exists( strDirName ) ) if( !VFS_Dir_Create( strDirName, VFS_TRUE ) ) return VFS_FALSE; } // Extract all Files. for( dwIndex = 0; dwIndex < m_Header.Files.size(); dwIndex++ ) { VFS_String strFileName = strTarget + m_Header.Files[ dwIndex ].strName; // Read in the File. if( !VFS_File_Seek( m_hFile, m_Header.Files[ dwIndex ].dwDataOffset, VFS_SET ) ) return VFS_FALSE; g_FromBuffer.resize( m_Header.Files[ dwIndex ].dwCompressedSize ); if( !VFS_File_Read( m_hFile, &*g_FromBuffer.begin(), m_Header.Files[ dwIndex ].dwCompressedSize ) ) return VFS_FALSE; // Apply the Filters. VFS_EntityInfo Info; Info.bArchived = VFS_TRUE; Info.eType = VFS_FILE; Info.lSize = m_Header.Files[ dwIndex ].dwCompressedSize; Info.strPath = GetFileNameWithoutExtension() + VFS_PATH_SEPARATOR + m_Header.Files[ dwIndex ].strName; VFS_Util_GetName( Info.strPath, Info.strName ); for( VFS_DWORD dwFilter = 0; dwFilter != m_Header.Filters.size(); dwFilter++ ) { g_FromPos = 0; if( !m_Header.Filters[ dwFilter ]->Decode( Reader, Writer, Info ) ) { VFS_ErrorCode eError = VFS_GetLastError(); if( eError == VFS_ERROR_NONE ) eError = VFS_ERROR_GENERIC; SetLastError( eError ); return VFS_FALSE; } g_FromBuffer = g_ToBuffer; g_ToBuffer.clear(); } // Create the Target File. VFS_Handle hFile = VFS_File_Create( strFileName, VFS_WRITE ); if( hFile == VFS_INVALID_HANDLE_VALUE ) return VFS_FALSE; // Write the Data. if( !VFS_File_Write( hFile, &*g_FromBuffer.begin(), ( VFS_DWORD )g_FromBuffer.size() ) ) return VFS_FALSE; // Close the Target File. if( !VFS_File_Close( hFile ) ) return VFS_FALSE; } return VFS_TRUE; }