StaticFileの非同期読み込みを実装中。メモリ管理などの解説ドキュメントを追加

Dev/asd_cpp/core/Core/asd.Core_Imp.cpp

@@ -280,7 +280,8 @@ namespace asd
 		m_mouse = Mouse_Imp::Create(m_window);
 		m_joystickContainer = JoystickContainer_Imp::Create(m_window);
 
-		m_file = File_Imp::Create();
+		synchronizer = std::make_shared<Synchronizer>();
+		m_file = File_Imp::Create(synchronizer);
 		m_graphics = Graphics_Imp::Create(m_window, option.GraphicsDevice, m_logger, m_file, go);
 
 		if (m_graphics == nullptr) return false;
@@ -302,8 +303,6 @@ namespace asd
 		layerRenderer = new LayerRenderer(m_graphics);
 		layerRenderer->SetWindowSize(m_windowSize);
 
-		synchronizer = std::make_shared<Synchronizer>();
-
 		{
 			asd::Vector2DF lpos[4];
 			lpos[0].X = 0;
@@ -362,7 +361,8 @@ namespace asd
 		}
 #endif
 
-		m_file = File_Imp::Create();
+		synchronizer = std::make_shared<Synchronizer>();
+		m_file = File_Imp::Create(synchronizer);
 		m_logger = Log_Imp::Create(ToAString("Log.html").c_str(), ToAString(L"").c_str());
 
 		GraphicsOption go;
@@ -388,8 +388,6 @@ namespace asd
 		layerRenderer = new LayerRenderer(m_graphics);
 		layerRenderer->SetWindowSize(m_windowSize);
 
-		synchronizer = std::make_shared<Synchronizer>();
-
 		{
 			asd::Vector2DF lpos[4];
 			lpos[0].X = 0;

Dev/asd_cpp/core/Graphics/Resource/asd.Texture2D_Imp.h

@@ -7,6 +7,7 @@
 
 #include "asd.Texture2D.h"
 #include "../asd.DeviceObject.h"
+#include "../../Utils/IAsyncResource.h"
 
 //----------------------------------------------------------------------------------
 //
@@ -18,6 +19,7 @@ namespace asd {
 	class Texture2D_Imp
 		: public Texture2D
 		, public DeviceObject
+		, public IAsyncResource
 	{
 	protected:
 		/**
@@ -40,6 +42,7 @@ namespace asd {
 		Vector2DI	m_size;
 
 		TextureFormat		m_format;
+		LoadState			m_loadState;
 
 		Texture2D_Imp(Graphics* graphics);
 		virtual ~Texture2D_Imp();
@@ -48,6 +51,7 @@ namespace asd {
 
 		Vector2DI GetSize() const { return m_size; }
 		TextureFormat GetFormat() const override { return m_format; }
+		LoadState GetLoadStateInternal() const override { return m_loadState; }
 
 	// リロード
 #if !SWIG

Dev/asd_cpp/core/IO/StaticFile/AsyncStaticFileFactory.cpp

@@ -0,0 +1,27 @@
+#include "AsyncStaticFileFactory.h"
+#include "../asd.StaticFile_Imp.h"
+
+namespace asd
+{
+	AsyncStaticFileFactory::AsyncStaticFileFactory(File_Imp * file, Synchronizer::Ptr sync)
+		: file(file)
+		, sync(sync)
+	{
+	}
+
+	StaticFile_Imp * AsyncStaticFileFactory::LoadFromBaseFile(
+		BaseFile::Ptr & baseFile,
+		const astring & cacheKey)
+	{
+		return new StaticFile_Imp(file, sync, cacheKey, baseFile);
+	}
+
+	StaticFile_Imp * AsyncStaticFileFactory::LoadFromPackedFile(
+		const astring & cacheKey,
+		const BaseFile::Ptr & packedFile,
+		PackFileInternalHeader & internalHeader,
+		std::shared_ptr<Decryptor> decryptor)
+	{
+		return new StaticFile_Imp(file, sync, cacheKey, packedFile, internalHeader, decryptor);
+	}
+}

Dev/asd_cpp/core/IO/StaticFile/AsyncStaticFileFactory.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "StaticFileFactoryBase.h"
+#include "../../Utils/asd.Synchronizer.h"
+
+namespace asd
+{
+	class AsyncStaticFileFactory
+		: public StaticFileFactoryBase
+	{
+	private:
+		File_Imp* file;
+		Synchronizer::Ptr sync;
+
+	public:
+		AsyncStaticFileFactory(File_Imp* file, Synchronizer::Ptr sync);
+		virtual ~AsyncStaticFileFactory(){}
+
+		virtual StaticFile_Imp* LoadFromBaseFile(BaseFile::Ptr& baseFile,
+			const astring& cacheKey);
+		virtual StaticFile_Imp* LoadFromPackedFile(const astring& cacheKey,
+			const BaseFile::Ptr& packedFile,
+			PackFileInternalHeader& internalHeader,
+			std::shared_ptr<Decryptor> decryptor);
+	};
+}

Dev/asd_cpp/core/IO/StaticFile/BlockingStaticFileFactory.cpp

@@ -0,0 +1,25 @@
+#include "BlockingStaticFileFactory.h"
+#include "../asd.StaticFile_Imp.h"
+#include "../asd.File_Imp.h"
+
+namespace asd
+{
+	BlockingStaticFileFactory::BlockingStaticFileFactory(File_Imp * file)
+		: file(file)
+	{
+	}
+
+	BlockingStaticFileFactory::~BlockingStaticFileFactory()
+	{
+	}
+
+	StaticFile_Imp * BlockingStaticFileFactory::LoadFromBaseFile(BaseFile::Ptr & baseFile, const astring & cacheKey)
+	{
+		return new StaticFile_Imp(file, cacheKey, baseFile);
+	}
+
+	StaticFile_Imp * BlockingStaticFileFactory::LoadFromPackedFile(const astring & cacheKey, const BaseFile::Ptr & packedFile, PackFileInternalHeader & internalHeader, std::shared_ptr<Decryptor> decryptor)
+	{
+		return new StaticFile_Imp(file, cacheKey, packedFile, internalHeader, decryptor);
+	}
+}

Dev/asd_cpp/core/IO/StaticFile/BlockingStaticFileFactory.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "StaticFileFactoryBase.h"
+#include "../../Utils/asd.Synchronizer.h"
+
+namespace asd
+{
+	class BlockingStaticFileFactory
+		: public StaticFileFactoryBase
+	{
+	private:
+		File_Imp* file;
+
+	public:
+		typedef std::shared_ptr<BlockingStaticFileFactory> Ptr;
+
+		BlockingStaticFileFactory(File_Imp* file);
+		virtual ~BlockingStaticFileFactory();
+
+		virtual StaticFile_Imp* LoadFromBaseFile(BaseFile::Ptr& baseFile,
+			const astring& cacheKey) override;
+		virtual StaticFile_Imp* LoadFromPackedFile(const astring& cacheKey,
+			const BaseFile::Ptr& packedFile,
+			PackFileInternalHeader& internalHeader,
+			std::shared_ptr<Decryptor> decryptor) override;
+	};
+}

Dev/asd_cpp/core/IO/StaticFile/StaticFileFactoryBase.cpp

@@ -0,0 +1 @@
+

Dev/asd_cpp/core/IO/StaticFile/StaticFileFactoryBase.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "../../asd.Core.Base.h"
+
+#include "../asd.FileRoot.h"
+#include "../asd.File.h"
+#include <memory>
+
+namespace asd
+{
+	class StaticFileFactoryBase
+	{
+	public:
+		typedef std::shared_ptr<StaticFileFactoryBase> Ptr;
+
+		virtual ~StaticFileFactoryBase(){}
+
+		virtual StaticFile_Imp* LoadFromBaseFile(BaseFile::Ptr& baseFile, const astring& cacheKey) = 0;
+		virtual StaticFile_Imp* LoadFromPackedFile(const astring& cacheKey, const BaseFile::Ptr& packedFile,
+			PackFileInternalHeader& internalHeader, std::shared_ptr<Decryptor> decryptor) = 0;
+	};
+}

Dev/asd_cpp/core/IO/StaticFile/StaticFileLoader.cpp

@@ -0,0 +1,112 @@
+#include "StaticFileLoader.h"
+#include "../asd.StaticFile_Imp.h"
+#include "../asd.File_Imp.h"
+
+namespace asd
+{
+	StaticFileLoader::StaticFileLoader(File_Imp* file, StaticFileFactoryBase::Ptr factory)
+		: file(file)
+		, factory(factory)
+	{
+	}
+
+	StaticFileLoader::~StaticFileLoader()
+	{
+	}
+
+	StaticFile* StaticFileLoader::LoadFromAbsolutePath(const char16_t * path)
+	{
+		std::lock_guard<std::recursive_mutex> lock(mtx_);
+
+		auto cacheKey = astring(path);
+		auto cache = LoadFromCache(cacheKey);
+		if (cache != nullptr)
+		{
+			return cache;
+		}
+
+		auto file = CreateSharedPtr(new BaseFile(path));
+		if (file->IsValid())
+		{
+			auto staticFile = factory->LoadFromBaseFile(file, cacheKey);
+			staticFiles[cacheKey] = staticFile;
+			return staticFile;
+		}
+
+		return nullptr;
+	}
+
+	StaticFile* StaticFileLoader::LoadFromPackedRoot(const char16_t * path, astring packedPath,
+		FileRoot::Ptr root)
+	{
+		std::lock_guard<std::recursive_mutex> lock(mtx_);
+
+		auto cacheKey = astring(path);
+		auto cache = LoadFromCache(path);
+		if (cache != nullptr)
+		{
+			return cache;
+		}
+
+		auto packFile = root->GetPackFile();
+
+		if (packFile->HaveFile(packedPath))
+		{
+			const auto& internalHeader = packFile->GetInternalHeader(packedPath);
+
+			StaticFile_Imp* staticFile = nullptr;
+
+			{
+				staticFile = factory->LoadFromPackedFile(astring(packedPath), packFile->RawFile(),
+					*internalHeader, root->decryptor);
+				staticFiles[cacheKey] = staticFile;
+				return staticFile;
+			}
+		}
+	}
+
+	StaticFile* StaticFileLoader::LoadFromNonPackedRoot(const char16_t * path, FileRoot::Ptr root)
+	{
+		std::lock_guard<std::recursive_mutex> lock(mtx_);
+
+		auto combinedPath = FileHelper::CombineRootPath(root->m_path, path);
+
+		auto cacheKey = astring(path);
+		auto cache = LoadFromCache(path);
+		if (cache != nullptr)
+		{
+			return cache;
+		}
+
+		StaticFile_Imp* staticFile = nullptr;
+
+		auto file = CreateSharedPtr(new BaseFile(combinedPath));
+		if (file->IsValid())
+		{
+			auto staticFile = factory->LoadFromBaseFile(file, astring(combinedPath));
+			staticFiles[cacheKey] = staticFile;
+			return staticFile;
+		}
+
+		return nullptr;
+	}
+
+	void StaticFileLoader::UnregisterStaticFile(const astring & key)
+	{
+		std::lock_guard<std::recursive_mutex> lock(mtx_);
+
+		staticFiles.erase(key);
+	}
+
+	StaticFile* StaticFileLoader::LoadFromCache(astring cacheKey)
+	{
+		auto it = staticFiles.find(cacheKey);
+		if (it != staticFiles.end())
+		{
+			auto ret = it->second;
+			SafeAddRef(ret);
+			return ret;
+		}
+		return nullptr;
+	}
+}

Dev/asd_cpp/core/IO/StaticFile/StaticFileLoader.h

@@ -0,0 +1,38 @@
+#pragma once
+#include "../../asd.Core.Base.h"
+
+#include "../asd.FileRoot.h"
+#include "../asd.File.h"
+#include "../asd.PackFile.h"
+#include "../asd.FileHelper.h"
+#include "StaticFileFactoryBase.h"
+#include <unordered_map>
+#include <mutex>
+
+namespace asd
+{
+	class StaticFileLoader
+	{
+	private:
+		std::unordered_map<astring, StaticFile_Imp*> staticFiles;
+		File_Imp* file;
+		StaticFileFactoryBase::Ptr factory;
+		std::recursive_mutex		mtx_;
+
+		StaticFile* LoadFromCache(astring cacheKey);
+
+	public:
+		typedef std::shared_ptr<StaticFileLoader> Ptr;
+
+		StaticFileLoader(File_Imp* file, StaticFileFactoryBase::Ptr factory);
+		virtual ~StaticFileLoader();
+
+		StaticFile* LoadFromAbsolutePath(const char16_t* path);
+		StaticFile* LoadFromPackedRoot(const char16_t* path, astring packedPath, FileRoot::Ptr root);
+		StaticFile* LoadFromNonPackedRoot(const char16_t* path, FileRoot::Ptr root);
+
+#ifndef SWIG
+		void UnregisterStaticFile(const astring& key);
+#endif
+	};
+}

Dev/asd_cpp/core/IO/asd.BaseFile.h

@@ -6,6 +6,7 @@
 #include "asd.Decryptor.h"
 
 #include <fstream>
+#include <memory>
 
 namespace asd
 {
@@ -29,6 +30,8 @@ namespace asd
 		astring m_filePath;
 
 	public:
+		typedef std::shared_ptr<BaseFile> Ptr;
+
 		BaseFile(const astring& path);
 		BaseFile(const achar* path);
 

Dev/asd_cpp/core/IO/asd.File.h

@@ -32,6 +32,13 @@ namespace asd
 		*/
 		virtual StaticFile* CreateStaticFile(const char16_t* path) = 0;
 
+		/**
+		@brief	一括読込のファイルを非同期に生成する。
+		@param	path	ファイルパス
+		@return	ファイル
+		*/
+		virtual StaticFile* CreateStaticFileAsync(const char16_t* path) = 0;
+
 		/**
 		@brief	逐次読込のファイルを生成する。
 		@param	path	ファイルパス

Dev/asd_cpp/core/IO/asd.FileRoot.h

@@ -15,6 +15,8 @@ namespace asd
 	private:
 
 	public:
+		typedef std::shared_ptr<FileRoot> Ptr;
+
 		astring m_path;
 		std::shared_ptr<Decryptor> decryptor;