const FileEntry* FileStorage::FindFile(const StringRef& path, const DirectoryEntry* parent/* = nullptr*/) const
{
if (parent == nullptr)
{
parent = &mRootDir;
}
if (Path::IsPath(path))
{
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
const DirectoryEntry* dir = parent;
for (uint i = 0; i < paths.Count() - 1; ++i)
{
dir = dir->FindDirectory(paths[i]);
RETURN_NULL_IF_NULL(dir);
}
return dir->FindFile(paths.Last());
}
else
{
return parent->FindFile(path);
}
}
FileEntry* FileStorage::FindOrCreateFileEntry(const StringRef& path, DirectoryEntry* parent /*= nullptr*/)
{
if (parent == nullptr)
{
parent = &mRootDir;
}
FileEntry* fileEntry = nullptr;
if (Path::IsPath(path))
{
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
DirectoryEntry* dir = parent;
for (uint i = 0; i < paths.Count() - 1; ++i)
{
dir = dir->FindOrCreateDirectoryEntry(paths[i]);
RETURN_NULL_IF_NULL(dir);
}
fileEntry = dir->FindOrCreateFileEntry(paths.Last());
}
else
{
fileEntry = parent->FindOrCreateFileEntry(path);
}
return fileEntry;
}
TextureAtlasRegion* MedusaTextureAtlas::CreateAtlasRegion(const IStream& stream)
{
HeapString outLine;
List<HeapString> outValues;
std::unique_ptr<TextureAtlasRegion> region(new TextureAtlasRegion());
//read source texture rect
Rect2U sourceRect;
Rect2U textureRect;
outLine.Clear();
RETURN_NULL_IF_FALSE(ReadLineToValues(stream, outLine, outValues));
region->SetName(outValues[0]);
region->SetRotate(StringParser::StringTo<bool>(outValues[1]));
sourceRect.Origin.X = StringParser::StringTo<uint>(outValues[2]);
sourceRect.Origin.Y = StringParser::StringTo<uint>(outValues[3]);
sourceRect.Size.Width = StringParser::StringTo<uint>(outValues[4]);
sourceRect.Size.Height = StringParser::StringTo<uint>(outValues[5]);
textureRect.Origin.X = StringParser::StringTo<uint>(outValues[6]);
textureRect.Origin.Y = StringParser::StringTo<uint>(outValues[7]);
textureRect.Size.Width = StringParser::StringTo<uint>(outValues[8]);
textureRect.Size.Height = StringParser::StringTo<uint>(outValues[9]);
region->SetSourceRect(sourceRect);
region->SetTextureRect(textureRect);
return region.release();
}
DirectoryEntry* FileStorage::FindOrCreateDirectory(const StringRef& path, DirectoryEntry* parent /*= nullptr*/)
{
if (Path::IsPath(path))
{
if (parent == nullptr)
{
parent = &mRootDir;
}
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
DirectoryEntry* dir = nullptr;
for (const auto& str : paths)
{
dir = parent->FindOrCreateDirectory(str);
parent = dir;
}
return dir;
}
else
{
if (parent == nullptr)
{
parent = &mRootDir;
}
DirectoryEntry* dir = parent->FindOrCreateDirectory(path);
return dir;
}
}
WavAudio* WavAudio::CreateFromMemory(const FileIdRef& fileId, MemoryData data)
{
// Initialize the memory data
MemoryStream stream = MemoryStream::OpenRead(data);
WAVHeader header;
RETURN_NULL_IF_FALSE(stream.ReadTo(header));
#ifdef MEDUSA_SAFE_CHECK
if (memcmp("RIFF", header.riff, 4) || memcmp("WAVE", header.wave, 4) || memcmp("fmt ", header.fmt, 4) || memcmp("data", header.data, 4))
{
Log::FormatError("Invalid wav file:{}", fileId.Name);
return nullptr;
}
#endif
auto audioData = stream.ReadData(header.dataSize, DataReadingMode::DirectMove);
WavAudio* audio = new WavAudio(audioData, fileId);
uint frameCount = 8 * header.dataSize / header.bitsPerSample;
audio->SetSampleCount(frameCount);
audio->SetChannelCount(header.channels);
audio->SetSampleRate(header.samplesPerSec);
audio->SetBitsPerSample(header.bitsPerSample);
return audio;
}
INode* ProjectNodeReader::CreateNodeWithJson(INodeEditor& editor, const rapidjson::Value& nodeTree, const StringRef& className /*= StringRef::Empty*/, NodeCreateFlags flags /*= NodeCreateFlags::None*/)
{
const rapidjson::Value& fileDataNode = nodeTree["FileData"];
StringRef filePath = fileDataNode.GetString("Path", nullptr);
filePath = Path::GetFileName(filePath);
RETURN_NULL_IF_FALSE(FileSystem::Instance().AssertExists(filePath));
INode* node = editor.Create("", filePath,IEventArg::Empty,flags);
SetPropsWithJson(node, nodeTree, flags);
return node;
}
INode* ProjectNodeReader::CreateNodeWithFlatBuffers(INodeEditor& editor, const flatbuffers::Table* nodeOptions, const StringRef& className, NodeCreateFlags flags /*= NodeCreateFlags::None*/)
{
auto projectNodeOptions = (flatbuffers::ProjectNodeOptions*)nodeOptions;
StringRef filePath = projectNodeOptions->fileName()->c_str();
filePath = Path::GetFileName(filePath);
RETURN_NULL_IF_FALSE(FileSystem::Instance().AssertExists(filePath));
INode* node = editor.Create("", filePath,IEventArg::Empty, flags);
SetPropsWithFlatBuffers(node, (flatbuffers::Table*)(projectNodeOptions->nodeOptions()), flags);
return node;
}
IMaterial* MaterialFactory::CreateSingleTexture(const FileIdRef& textureFileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
RETURN_NULL_IF_FALSE(textureFileId.IsValid());
IMaterial* result = Find(textureFileId);
RETURN_SELF_IF_NOT_NULL(result);
ITexture* texture = TextureFactory::Instance().CreateFromFile(textureFileId, ShaderSamplerNames::Texture);
IEffect* effect = EffectFactory::Instance().CreateSinglePassDefault(RenderPassNames::Texture);
result = new IMaterial(texture, effect, GraphicsDrawMode::Triangles, textureFileId);
Add(result, shareType);
return result;
}
TextureAtlasPage* MedusaTextureAtlas::OnCreatePage(const FileIdRef& fileId, const IStream& stream)
{
HeapString outLine;
List<HeapString> outValues;
std::unique_ptr<TextureAtlasPage> page(new TextureAtlasPage(0));
page->SetTexcoordUpSide(false);
outLine.Clear();
RETURN_NULL_IF_FALSE(ReadLineToValues(stream, outLine, outValues));
FileId textureFileId = FileId::ParseFrom(outValues[0]);
page->SetTextureFileId(textureFileId);
Size2U pageSize;
pageSize.Width = (uint)outValues[1].ToInt();
pageSize.Height = (uint)outValues[2].ToInt();
page->SetPageSize(pageSize);
//ignore format,use real image format instead
//outValues[3]
//read filter
if (outValues[4] == "NearestNeighbour")
{
page->SetMagFilter(GraphicsTextureMagFilter::Nearest);
page->SetMinFilter(GraphicsTextureMinFilter::Nearest);
}
else// if (outLine == "Linear")
{
page->SetMagFilter(GraphicsTextureMagFilter::Linear);
page->SetMinFilter(GraphicsTextureMinFilter::Linear);
}
page->SetFlipPVR(StringParser::StringTo<bool>(outValues[5]));
page->SetPremultiplyAlpha(StringParser::StringTo<bool>(outValues[6]));
//read regions
TextureAtlasRegion* region = nullptr;
do
{
region = CreateAtlasRegion(stream);
if (region != nullptr)
{
page->AddRegion(region);
}
} while (region != nullptr);
return page.release();
}
DirectoryEntry* FileStorage::FindDirectory(const StringRef& path, DirectoryEntry* parent /*= nullptr*/)
{
if (parent == nullptr)
{
parent = &mRootDir;
}
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
for (const auto& str : paths)
{
parent = parent->FindDirectory(str);
RETURN_NULL_IF_NULL(parent);
}
return parent;
}
