Share<IAudio> AudioFactory::CreateFromFile(const FileIdRef& fileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<IAudio> buffer;
if (shareType != ResourceShareType::None)
{
buffer = Find(fileId);
RETURN_SELF_IF_NOT_NULL(buffer);
}
switch (FileInfo::ExtractType(fileId.Name))
{
#ifdef MEDUSA_OGG
case FileType::ogg:
buffer = OggAudio::CreateFromFile(fileId);
break;
#endif
case FileType::wav:
buffer = WavAudio::CreateFromFile(fileId);
break;
default:
return nullptr;
break;
}
RETURN_NULL_IF_NULL(buffer);
Add(buffer, shareType);
return buffer;
}
Share<Camera> CameraFactory::CreateFromModel(StringRef name, StringRef modelName, const Size2F& winSize, bool isResizeable /*= true*/, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<Camera> camera;
if (shareType != ResourceShareType::None)
{
camera = Find(name);
RETURN_SELF_IF_NOT_NULL(camera);
}
if (camera == nullptr)
{
auto model = ModelFactory::Instance().Create(modelName).CastPtr<BaseSceneModel>();
if (model != nullptr)
{
camera = model->CreateCamera(name, winSize);
Add(camera, shareType);
if (isResizeable)
{
mResizeableCameras.Add(camera);
}
}
}
return camera;
}
IEffect* EffectFactory::CreateFromFile( const FileIdRef& fileId ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
switch(FileInfo::ExtractType(fileId.Name))
{
case FileType::pfx:
effect=PFXEffect::CreateFromFile(fileId.Name); //TODO:
break;
default:
return nullptr;
}
RETURN_NULL_IF_NULL(effect);
if (effect->Initialize())
{
Add(effect, shareType);
return effect;
}
SAFE_DELETE(effect);
return nullptr;
}
Share<IAudio> AudioFactory::CreateFromRaw(const FileIdRef& fileId, AudioFileType audioFileType, const MemoryData& data, uint sampleCount, uint channelCount, uint samplerRate, uint bitsPerSample, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<IAudio> buffer;
if (shareType != ResourceShareType::None)
{
buffer = Find(fileId);
RETURN_SELF_IF_NOT_NULL(buffer);
}
switch (audioFileType)
{
#ifdef MEDUSA_OGG
case AudioFileType::ogg:
buffer = new OggAudio(data, fileId);
break;
#endif
case AudioFileType::wav:
buffer = new WavAudio(data, fileId);
break;
default:
return nullptr;
}
buffer->SetSampleCount(sampleCount);
buffer->SetChannelCount(sampleCount);
buffer->SetSampleRate(samplerRate);
buffer->SetBitsPerSample(bitsPerSample);
Add(buffer, shareType);
return buffer;
}
INode* NodeFactory::Create(const StringRef& className, const FileIdRef& editorFile, const FileIdRef& scriptFile, const IEventArg& e /*= IEventArg::Empty*/, NodeCreateFlags flags /*= LayerCreateFlags::All*/)
{
INode* node = nullptr;
if (editorFile.IsValid())
{
node = NodeEditorFactory::Instance().Create(className, editorFile, scriptFile, e, flags);
RETURN_SELF_IF_NOT_NULL(node);
}
if (className.IsEmpty())
{
Log::AssertFailed("Cannot create layer without name");
return nullptr;
}
else
{
node = BaseType::Create(className, StringRef::Empty, e); //create layer only use name
}
if (node == nullptr)
{
Log::AssertFailedFormat("Cannot create layer by name:{}", className);
return nullptr;
}
#ifdef MEDUSA_SCRIPT
node->TryAddScriptFile(scriptFile);
#endif
node->Initialize();
return node;
}
Share<IModel> ModelFactory::Create( const FileIdRef& fileId,ModelLoadingOptions loadingOptions/*=ModelLoadingOptions::None*/ ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<IModel> model;
if (shareType != ResourceShareType::None)
{
model = Find(fileId);
RETURN_SELF_IF_NOT_NULL(model);
}
switch(FileInfo::ExtractType(fileId.Name))
{
case FileType::pod:
{
model=PODModel::CreateFromFile(fileId,loadingOptions);
Add(model, shareType);
return model;
}
break;
default:
break;
}
return nullptr;
}
IMaterial* MaterialFactory::Create(const FileIdRef& fileId, ITexture* texture, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IMaterial* result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
result = new IMaterial(texture, fileId);
Add(result, shareType);
return result;
}
IMaterial* MaterialFactory::CreateEmpty(const FileIdRef& fileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IMaterial* result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
result = new IMaterial(nullptr,nullptr,GraphicsDrawMode::Triangles,fileId);
Add(result, shareType);
return result;
}
IMaterial* MaterialFactory::CreateCustom(const FileIdRef& fileId, ITexture* texture, IEffect* effect, GraphicsDrawMode drawMode, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IMaterial* result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
result = new IMaterial(texture,effect,drawMode,fileId);
Add(result, shareType);
return result;
}
const BaseSirenCustomType* SirenMachine::FindCustomType(const StringRef& name) const
{
//for each assembly
for (auto& assembly : mAssemblies)
{
auto* val = assembly.Value->FindCustomType(name);
RETURN_SELF_IF_NOT_NULL(val);
}
return nullptr;
}
IMaterial* MaterialFactory::CreateSingleTexture(ITexture* texture, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
RETURN_NULL_IF_NULL(texture);
IMaterial* result = Find(texture->GetFileId());
RETURN_SELF_IF_NOT_NULL(result);
IEffect* effect = EffectFactory::Instance().CreateSinglePassDefault(RenderPassNames::Texture);
result = new IMaterial(texture, effect, GraphicsDrawMode::Triangles, texture->GetFileId());
Add(result, shareType);
return result;
}
IMaterial* MaterialFactory::CreateShape(const FileIdRef& fileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IMaterial* result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
IEffect* effect = EffectFactory::Instance().CreateSinglePassDefault(RenderPassNames::Shape);
result = new IMaterial(nullptr, effect, GraphicsDrawMode::Triangles, fileId);
Add(result, shareType);
return result;
}
IMaterial* MaterialFactory::Create(const FileIdRef& fileId, const FileMapOrderItem& orderItem, StringRef samplerName /*= StringRef::Empty*/, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IMaterial* result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
ITexture* texture = nullptr;
texture = TextureFactory::Instance().CreateFromOrderItem(fileId, orderItem, samplerName);
RETURN_NULL_IF_NULL(texture);
return Create(fileId, texture, shareType);
}
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;
}
IEffect* EffectFactory::CreateMultiplePasses( const FileIdRef& fileId,const List<FileIdRef>& renderPasses ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
List<IRenderPass*> passes;
FOR_EACH_COLLECTION(i,renderPasses)
{
const FileIdRef& passFileId=*i;
IRenderPass* pass=RenderPassFactory::Instance().CreateRenderPass(passFileId);
passes.Add(pass);
}
effect=CreateMultiplePasses(fileId,passes,shareType);
RETURN_SELF_IF_NOT_NULL(effect);
SAFE_DELETE_COLLECTION(passes);
return nullptr;
}
Share<IShader> ShaderFactory::CreateShader( const FileIdRef& fileId,const List<HeapString>* defines/*=nullptr*/,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<IShader> result = nullptr;
if (shareType != ResourceShareType::None)
{
result = Find(fileId);
RETURN_SELF_IF_NOT_NULL(result);
}
result=ShaderCreater::Instance().Create(fileId.Name,fileId);
if (result==nullptr)
{
switch(FileInfo::ExtractType(fileId.Name))
{
case FileType::fsh:
result=new BasePixelShader(fileId);
break;
case FileType::vsh:
result=new BaseVertexShader(fileId);
break;
default:
MEDUSA_ASSERT_FAILED("Unsupported shader file type");
return nullptr;
}
}
MemoryData data= FileSystem::Instance().ReadAllData(fileId);
if (data.IsNull())
{
Log::FormatError("Cannot find:{}-{}", fileId.Name, fileId.Order);
return nullptr;
}
StringRef str(data.Cast<char>());
if(result->Initialize(str,defines))
{
Add(result, shareType);
return result;
}
else
{
result = nullptr;
}
return nullptr;
}
Share<WStringListDataSource> DataSourceFactory::CreateWStringList(const FileIdRef& fileId, const List<WHeapString>& strItems, bool isSingleLine /*= true*/, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<WStringListDataSource> result;
if (shareType != ResourceShareType::None)
{
auto item= Find(fileId);
result = item.CastPtr<WStringListDataSource>();
RETURN_SELF_IF_NOT_NULL(result);
}
result = new WStringListDataSource(strItems,fileId);
Add(result, shareType);
return result;
}
Share<FileIdListDataSource> DataSourceFactory::CreateFileIdList(const FileIdRef& fileId, const List<FileId>& items, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<FileIdListDataSource> result;
if (shareType != ResourceShareType::None)
{
auto item = Find(fileId);
result = item.CastPtr<FileIdListDataSource>();
RETURN_SELF_IF_NOT_NULL(result);
}
result = new FileIdListDataSource(items, fileId);
Add(result, shareType);
return result;
}
SirenAssembly* SirenMachine::LoadAssembly(const FileIdRef& fileId)
{
auto* ass = FindAssembly(fileId.Name);
RETURN_SELF_IF_NOT_NULL(ass);
ass = new SirenAssembly();
if (ass->LoadFromFileSystem(fileId))
{
mAssemblies.Add(ass->Name(), ass);
return ass;
}
SAFE_DELETE(ass);
return ass;
}
SirenAssembly* SirenMachine::LoadAssembly(const FileIdRef& fileId, const MemoryData& data)
{
auto* ass = FindAssembly(Path::GetFileName(fileId.Name));
RETURN_SELF_IF_NOT_NULL(ass);
ass = new SirenAssembly();
if (ass->LoadFromData(fileId, data))
{
mAssemblies.Add(ass->Name(), ass);
return ass;
}
SAFE_DELETE(ass);
return ass;
}
IEffect* EffectFactory::CreateSinglePass(const FileIdRef& fileId,IRenderPass* renderPass,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
effect= CreateEmpty(fileId,shareType);
RETURN_NULL_IF_NULL(effect);
effect->GetGroupByIndex(0)->GetTechniqueByIndex(0)->AddPass(renderPass);
return effect;
}
IEffect* EffectFactory::CreateSinglePass( const FileIdRef& fileId,const FileIdRef& passFileId ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
IRenderPass* pass=RenderPassFactory::Instance().CreateRenderPass(fileId);
if (pass!=nullptr)
{
return CreateSinglePass(fileId,pass,shareType);
}
return nullptr;
}
IEffect* EffectFactory::CreateMultiplePasses( const FileIdRef& fileId,List<IRenderPass*>& renderPasses ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
effect= CreateEmpty(fileId,shareType);
RETURN_NULL_IF_NULL(effect);
EffectTechnique* technique=effect->GetGroupByIndex(0)->GetTechniqueByIndex(0);
FOR_EACH_COLLECTION(i,renderPasses)
{
technique->AddPass(*i);
}
Share<QuadModel> ModelFactory::CreateQuad( const FileIdRef& fileId ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
Share<QuadModel> model = nullptr;
if (shareType != ResourceShareType::None)
{
model = Find(fileId).CastPtr<QuadModel>();
RETURN_SELF_IF_NOT_NULL(model);
}
auto material= MaterialFactory::Instance().CreateSingleTexture(fileId);
model=new QuadModel(fileId,material,Rect2I(Point2I::Zero,material->FirstTexture()->Size()));
model->Initialize();
Add(model, shareType);
return model;
}
SpineSkeletonModel* SkeletonModelFactory::CreateSpineFromJson(const FileIdRef& skeletonfileId, const FileIdRef& atlasFileId, bool isPreCalculated/*=false*/, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
{
ISkeletonModel* val = Find(skeletonfileId);
RETURN_SELF_IF_NOT_NULL((SpineSkeletonModel*)val);
}
SpineSkeletonModel* model = SpineSkeletonModel::CreateFromJsonFile(skeletonfileId, atlasFileId);
RETURN_NULL_IF_NULL(model);
if (isPreCalculated)
{
model->PreCalculate(Application::Instance().FPS());
}
Add(model, shareType);
return model;
}
IEffect* EffectFactory::CreateEmpty( const FileIdRef& fileId ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
IEffect* effect = nullptr;
if (shareType != ResourceShareType::None)
{
effect = Find(fileId);
RETURN_SELF_IF_NOT_NULL(effect);
}
effect=new IEffect(fileId);
if(effect->Initialize())
{
effect->CreateDefaultGroup()->CreateDefaultTechnique();
Add(effect, shareType);
return effect;
}
SAFE_DELETE(effect);
return nullptr;
}
Share<TiledTileset> TiledTilesetFactory::Create(const FileIdRef& fileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
if (shareType != ResourceShareType::None)
{
auto val = Find(fileId);
RETURN_SELF_IF_NOT_NULL(val);
}
Share<TiledTileset> model = new TiledTileset(fileId);
RETURN_NULL_IF_NULL(model);
if (model->LoadFromFileSystem(fileId))
{
Add(model, shareType);
}
else
{
model = nullptr;
}
return model;
}
const Share<ITexture>& TextureAtlasPage::LoadTexture()
{
RETURN_SELF_IF_NOT_NULL(mTexture);
mTexture = TextureFactory::Instance().CreateFromFile(mTextureFileId.ToRef());
if (mTexture == nullptr)
{
Log::AssertFailedFormat("Cannot load texture:{}-{}", mTextureFileId.Name.c_str(), (uint)mTextureFileId.Order);
return mTexture;
}
mTexture->SetMagFilter(mMagFilter);
mTexture->SetMinFilter(mMinFilter);
mTexture->SetWrapS(mWrapS);
mTexture->SetWrapT(mWrapT);
mPageSize = mTexture->Size();
for (auto region : mRegions)
{
region->UpdateMesh(mPageSize);
}
return mTexture;
}
TmxTiledMap* TiledMapFactory::Create(const FileIdRef& fileId, ResourceShareType shareType /*= ResourceShareType::Share*/)
{
if (shareType != ResourceShareType::None)
{
TmxTiledMap* val = (TmxTiledMap*)Find(fileId);
RETURN_SELF_IF_NOT_NULL((TmxTiledMap*)val);
}
TmxTiledMap* model = new TmxTiledMap(fileId);
RETURN_NULL_IF_NULL(model);
if (model->LoadFromFileSystem(fileId))
{
Add(model, shareType);
}
else
{
delete model;
model = nullptr;
}
return model;
}
CustomRenderTarget* RenderTargetFactory::CreateCustom( const FileIdRef& fileId,bool setCurrent/*=true*/ ,ResourceShareType shareType /*= ResourceShareType::Share*/)
{
CustomRenderTarget* renderTarget = nullptr;
if (shareType != ResourceShareType::None)
{
renderTarget = (CustomRenderTarget*)Find(fileId);
RETURN_SELF_IF_NOT_NULL(renderTarget);
}
if (renderTarget==nullptr)
{
renderTarget=new CustomRenderTarget(fileId);
Add(renderTarget, shareType);
}
if (setCurrent)
{
mCurrent=renderTarget;
}
return renderTarget;
}
