const String DevAssetManager::Get_Asset_Name_From_File_Path( const char* filePath ) const
{
String pathOnly( filePath );
pathOnly.StripFilename();
F_NormalizePath( pathOnly );
String fileName( filePath );
fileName.StripPath();
if( !pathOnly.IsEmpty() )
{
if( pathOnly == m_pathToSrcAssets ) {
return fileName;
} else {
// invalid path
return String();
}
}
else
{
return fileName;
}
//// if it starts with path to source art, remove path
//{
// const bool casesensitive = true;
// const INT pos = String::FindText( filePath, m_pathToSrcAssets, casesensitive );
// if( pos != INDEX_NONE )
// {
// return false;
// }
//}
}
bool Shader::LoadFromYaml(const FilePath & pathname)
{
//#if defined(__DAVAENGINE_ANDROID__) || defined (__DAVAENGINE_MACOS__)
// relativeFileName = pathname;
//#endif //#if defined(__DAVAENGINE_ANDROID__)
uint64 shaderLoadTime = SystemTimer::Instance()->AbsoluteMS();
YamlParser * parser = YamlParser::Create(pathname);
if (!parser)
return false;
YamlNode * rootNode = parser->GetRootNode();
if (!rootNode)
{
SafeRelease(rootNode);
return false;
}
const YamlNode * vertexShaderNode = rootNode->Get("vertexShader");
if (!vertexShaderNode)
{
SafeRelease(parser);
return false;
}
const YamlNode * glslVertexNode = vertexShaderNode->Get("glsl");
if (!glslVertexNode)
{
SafeRelease(parser);
return false;
}
const YamlNode * fragmentShaderNode = rootNode->Get("fragmentShader");
if (!fragmentShaderNode)
{
SafeRelease(parser);
return false;
}
const YamlNode * glslFragmentNode = fragmentShaderNode->Get("glsl");
if (!glslFragmentNode)
{
SafeRelease(parser);
return false;
}
FilePath pathOnly(pathname.GetDirectory());
vertexShaderPath = pathOnly + glslVertexNode->AsString();
fragmentShaderPath = pathOnly + glslFragmentNode->AsString();
SafeRelease(parser);
Load(vertexShaderPath, fragmentShaderPath);
shaderLoadTime = SystemTimer::Instance()->AbsoluteMS() - shaderLoadTime;
// Logger::FrameworkDebug("shader loaded:%s load-time: %lld ms", pathname.c_str(), shaderLoadTime);
return true;
}
// EnsurePathExistsForFile
//------------------------------------------------------------------------------
/*static*/ bool Node::EnsurePathExistsForFile( const AString & name )
{
const char * lastSlash = name.FindLast( NATIVE_SLASH );
ASSERT( PathUtils::IsFullPath( name ) ); // should be guaranteed to be a full path
AStackString<> pathOnly( name.Get(), lastSlash );
if ( FileIO::EnsurePathExists( pathOnly ) == false )
{
FLOG_ERROR( "Failed to create path '%s'", pathOnly.Get() );
return false;
}
return true;
}
// ReceiveFileData
//------------------------------------------------------------------------------
bool ToolManifest::ReceiveFileData( uint32_t fileId, const void * data, size_t & dataSize )
{
MutexHolder mh( m_Mutex );
File & f = m_Files[ fileId ];
// gracefully handle multiple receipts of the same data
if ( f.m_Content )
{
ASSERT( f.m_SyncState == File::SYNCHRONIZED );
return true;
}
ASSERT( f.m_SyncState == File::SYNCHRONIZING );
// prepare name for this file
AStackString<> fileName;
GetRemoteFilePath( fileId, fileName );
// prepare destination
AStackString<> pathOnly( fileName.Get(), fileName.FindLast( NATIVE_SLASH ) );
if ( !FileIO::EnsurePathExists( pathOnly ) )
{
return false; // FAILED
}
// write to disk
FileStream fs;
if ( !fs.Open( fileName.Get(), FileStream::WRITE_ONLY ) )
{
return false; // FAILED
}
if ( fs.Write( data, dataSize ) != dataSize )
{
return false; // FAILED
}
fs.Close();
// open read-only
AutoPtr< FileStream > fileStream( FNEW( FileStream ) );
if ( fileStream.Get()->Open( fileName.Get(), FileStream::READ_ONLY ) == false )
{
return false; // FAILED
}
// This file is now synchronized
f.m_FileLock = fileStream.Release(); // NOTE: Keep file open to prevent deletion
f.m_SyncState = File::SYNCHRONIZED;
// is completely synchronized?
const File * const end = m_Files.End();
for ( const File * it = m_Files.Begin(); it != end; ++it )
{
if ( it->m_SyncState != File::SYNCHRONIZED )
{
// still some files to be received
return true; // file stored ok
}
}
// all files received
m_Synchronized = true;
return true; // file stored ok
}
