com.hikky.vketcloudsdk 3.2.4

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/HRM/CHRMTextureCompressor.h.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: e02a2b21294eb6b469b76d0179cd3489
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/HRM.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 64867c50cf720aa49bc9e7b0c3ddc8ad
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/JSON/CJSON.cpp

@@ -0,0 +1,391 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CJSON.cpp
+
+#include "../../Specific/Debug/LMsg.h"
+#include "CJSON.h"
+#include "CJSONData.h"
+
+namespace json {
+
+CJSON::CJSON() :
+	m_pText(nullptr),
+	m_pEnd(nullptr)
+{
+}
+
+CJSON::~CJSON()
+{
+	Release();
+}
+
+bool CJSON::Analyse(const unsigned char* pData, unsigned int Size)
+{
+	Release();
+
+	m_pText = reinterpret_cast<const char*>(pData);
+	m_pEnd = m_pText + Size;
+
+	if (!CheckToken("{", m_PreText)) return false;
+
+	if (!AnalyseBlock(m_Data, m_PostText)) return false;
+
+	if (m_pText < m_pEnd) {
+		m_PostText += std::string(m_pText, m_pEnd);
+	}
+
+	return true;
+}
+
+void CJSON::Release()
+{
+	m_Data = std::make_shared<CJSONData>();
+
+	m_PreText.clear();
+	m_PostText.clear();
+}
+
+void CJSON::Add(std::shared_ptr<CJSONData>& JSONData)
+{
+	m_Data->Add(JSONData);
+}
+
+const std::shared_ptr<CJSONData>& CJSON::GetData() const
+{
+	return m_Data;
+}
+
+bool CJSON::Save(std::string& Text) const
+{
+	Text += m_PreText;
+
+	Text += m_Data->GetText();
+
+	Text += m_PostText;
+
+	return true;
+}
+
+bool CJSON::AnalyseBlock(std::shared_ptr<CJSONData>& Data, std::string& PostText)
+{
+	// ��u���b�N���ǂ����̃`�F�b�N
+	{
+		std::string ReadToken;
+		if (CheckToken("}", ReadToken)) {
+			PostText += ReadToken;
+			return true;
+		}
+	}
+
+	//
+	for (;;) {
+		CJSONToken Token;
+		if (!GetToken(Token)) return false;
+
+		// �u���b�N���̗v�f�̍ŏ��͕K���_�u���N�H�[�e�[�V�����ň͂܂ꂽ���O�ł���
+		if (!IsDQText(Token.GetText())) return false;
+
+		const std::string BlockName = EraseDQ(Token.GetText());
+
+		//
+		{
+			std::string ReadToken;
+			if (!CheckToken(":", ReadToken)) return false;
+
+			Token.AddPostSpaceText(ReadToken);
+		}
+
+		// �E��
+		CJSONToken RightToken;
+		if (!GetToken(RightToken)) return false;
+
+		if (IsDQText(RightToken.GetText())) {
+			auto JSONData = std::make_shared<CJSONData>(EJSONDataType::StringValue, BlockName, EraseDQ(RightToken.GetText()), Token, RightToken);
+
+			Data->Add(JSONData);
+
+			//
+			std::string ReadToken;
+			if (CheckToken(",", ReadToken)) {
+				JSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("}", ReadToken)) {
+				Data->AddPostText(ReadToken);
+				break;
+			}
+		}
+		else if (RightToken.GetText() == "{") {
+			Token.AddPostSpaceText(RightToken.GetTotalText());
+
+			auto JSONData = std::make_shared<CJSONData>(EJSONDataType::Block, BlockName, Token);
+
+			Data->Add(JSONData);
+
+			std::string ReadToken;
+			if (!AnalyseBlock(JSONData, ReadToken)) return false;
+
+			JSONData->AddPostText(ReadToken);
+
+			//
+			if (CheckToken(",", ReadToken)) {
+				JSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("}", ReadToken)) {
+				Data->AddPostText(ReadToken);
+				break;
+			}
+		}
+		else if (RightToken.GetText() == "[") {
+			// �z��
+			Token.AddPostSpaceText(RightToken.GetTotalText());
+
+			auto JSONData = std::make_shared<CJSONData>(EJSONDataType::Array, BlockName, Token);
+			Data->Add(JSONData);
+
+			if (!AnalyseArray(Data->GetLast())) return false;
+
+			//
+			std::string ReadToken;
+			if (CheckToken(",", ReadToken)) {
+				JSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("}", ReadToken)) {
+				Data->AddPostText(ReadToken);
+				break;
+			}
+		}
+		else {
+			// �����܂��͎��ʎq
+			if (RightToken.GetText().empty()) return false;
+
+			EJSONDataType DataType;
+
+			if (IsNum(RightToken.GetText()[0]) || (RightToken.GetText()[0] == '-')) DataType = EJSONDataType::Number;
+			else DataType = EJSONDataType::Identifier;
+
+			auto JSONData = std::make_shared<CJSONData>(DataType, BlockName, RightToken.GetText(), Token, RightToken);
+
+			Data->Add(JSONData);
+
+			//
+			std::string ReadToken;
+			if (CheckToken(",", ReadToken)) {
+				JSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("}", ReadToken)) {
+				Data->AddPostText(ReadToken);
+				break;
+			}
+		}
+	}
+
+	return true;
+}
+
+bool CJSON::AnalyseArray(std::shared_ptr<CJSONData>& Data)
+{
+	// ��z�񂩂ǂ����̃`�F�b�N
+	{
+		std::string ReadToken;
+		if (CheckToken("]", ReadToken)) {
+			Data->AddPostText(ReadToken);
+			return true;
+		}
+	}
+
+	//
+	for (;;) {
+		CJSONToken Token;
+		if (!GetToken(Token)) return false;
+
+//			debug::Output("[%s]\n", Token.c_str());
+
+		if (Token.GetText() == "{") {
+			auto BlockJSONData = std::make_shared<CJSONData>(EJSONDataType::Block, "", Token);
+			Data->AddArray(BlockJSONData);
+
+			std::string ReadToken;
+			if (!AnalyseBlock(Data->GetLastArray(), ReadToken)) return false;
+
+			BlockJSONData->AddPostText(ReadToken);
+
+			//
+			if (CheckToken(",", ReadToken)) {
+				BlockJSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("]", ReadToken)) {
+				BlockJSONData->AddPostText(ReadToken);
+				break;
+			}
+		}
+		else {
+			// �����܂��͎��ʎq
+			EJSONDataType DataType;
+
+			if (IsNum(Token.GetText()[0]) || (Token.GetText()[0] == '-')) DataType = EJSONDataType::Number;
+			else DataType = EJSONDataType::Identifier;
+
+			auto BlockJSONData = std::make_shared<CJSONData>(DataType, "", Token.GetText(), CJSONToken(), Token);
+
+			Data->AddArray(BlockJSONData);
+
+			//
+			std::string ReadToken;
+			if (CheckToken(",", ReadToken)) {
+				BlockJSONData->AddPostText(ReadToken);
+				continue;
+			}
+
+			if (CheckToken("]", ReadToken)) {
+				BlockJSONData->AddPostText(ReadToken);
+				break;
+			}
+		}
+	}
+
+	return true;
+}
+
+void CJSON::SkipSpaceChar(std::string& SpaceText)
+{
+	while (!IsEnd()) {
+		if (*m_pText == ' ' ||
+			*m_pText == '\r' ||
+			*m_pText == '\t' ||
+			*m_pText == '\n')
+		{
+			SpaceText.push_back(*m_pText);
+			++m_pText;
+			continue;
+		}
+
+		return;
+	}
+}
+
+bool CJSON::CheckToken(const std::string& Token, std::string& ReadToken)
+{
+	const char* pPrev = m_pText;
+
+	CJSONToken NextToken;
+	if (!GetToken(NextToken)) {
+		m_pText = pPrev;
+		return false;
+	}
+
+	if (NextToken.GetText() != Token) {
+		m_pText = pPrev;
+		return false;
+	}
+
+	//
+	ReadToken = NextToken.GetTotalText();
+
+	return true;
+}
+
+bool CJSON::GetToken(CJSONToken& Token)
+{
+	std::string PreSpaceText;
+	SkipSpaceChar(PreSpaceText);
+
+	if (IsEnd()) return false;
+
+	const char* pBegin = m_pText;
+
+	// �P�����g�[�N��
+	switch (*m_pText) {
+	case '{':
+	case '}':
+	case '[':
+	case ']':
+	case ':':
+	case ',':
+		++m_pText;
+		Token = CJSONToken(PreSpaceText, std::string(pBegin, m_pText), "");
+		return true;
+	}
+
+	// �_�u���N�H�[�e�[�V����
+	if (*m_pText == '\"') {
+		++m_pText;
+
+		while (!IsEnd()) {
+			if (*m_pText == '\"') {
+				++m_pText;
+				Token = CJSONToken(PreSpaceText, std::string(pBegin, m_pText), "");
+				return true;
+			}
+
+			++m_pText;
+		}
+
+		return false;
+	}
+
+	// �A���t�@�x�b�g
+	if (IsAlpha(*m_pText)) {
+		while (!IsEnd()) {
+			++m_pText;
+
+			if (!IsAlpha(*m_pText)) break;
+		}
+
+		Token = CJSONToken(PreSpaceText, std::string(pBegin, m_pText), "");
+		return true;
+	}
+
+	// ����
+	if (IsNum(*m_pText) || (*m_pText == '-')) {
+		while (!IsEnd()) {
+			++m_pText;
+
+			if (!IsNum(*m_pText) && (*m_pText != '.') && (*m_pText != '+') && (*m_pText != '-') && (*m_pText != 'e') && (*m_pText != 'E')) break;
+		}
+
+		Token = CJSONToken(PreSpaceText, std::string(pBegin, m_pText), "");
+		return true;
+	}
+
+	return true;
+}
+
+bool CJSON::IsEnd() const
+{
+	return (m_pText >= m_pEnd);
+}
+
+bool CJSON::IsDQText(const std::string& Token)
+{
+	if (Token.length() < 2) return false;
+	if (Token[0] != '\"' && Token[Token.length() - 1] != '\"') return false;
+
+	return true;
+}
+
+std::string CJSON::EraseDQ(const std::string& Token)
+{
+	return Token.substr(1, Token.length() - 2);
+}
+
+bool CJSON::IsAlpha(char c)
+{
+	return (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')));
+}
+
+bool CJSON::IsNum(char c)
+{
+	return ((c >= '0') && (c <= '9'));
+}
+
+}
+

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/JSON/CJSON.cpp.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 7582a6f6666c8bb47be9985ace7efb76
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/JSON/CJSON.h

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CJSON.h
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "CJSONData.h"
+#include "CJSONToken.h"
+
+namespace json {
+
+class CJSON {
+	const char*		m_pText;
+	const char*		m_pEnd;
+
+	std::shared_ptr<CJSONData>		m_Data;
+
+	std::string		m_PreText;
+	std::string		m_PostText;
+
+private:
+	bool	AnalyseBlock(std::shared_ptr<CJSONData>& Data, std::string& PostText);
+	bool	AnalyseArray(std::shared_ptr<CJSONData>& Data);
+
+	void	SkipSpaceChar(std::string& SpaceText);
+
+	bool	CheckToken(const std::string& Token, std::string& ReadToken);
+
+	bool	GetToken(CJSONToken& Token);
+
+	bool	IsEnd() const;
+
+	static bool			IsDQText(const std::string& Token);
+	static std::string	EraseDQ(const std::string& Token);
+
+	static bool		IsAlpha(char c);
+	static bool		IsNum(char c);
+
+public:
+	CJSON();
+	virtual ~CJSON();
+
+	bool	Analyse(const unsigned char* pData, unsigned int Size);
+	void	Release();
+
+	void	Add(std::shared_ptr<CJSONData>& JSONData);
+
+	const std::shared_ptr<CJSONData>&	GetData() const;
+
+	bool	Save(std::string& Text) const;
+};
+
+}
+

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/JSON/CJSON.h.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: b586d07bc36cdf44d989a739c3713c86
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/PackageResources/tools/HRMExporter/HRMExporter/Source/Independent/JSON/CJSONData.cpp

@@ -0,0 +1,177 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CJSONData.cpp
+
+#include "../../Independent/FormatString/FormatString.h"
+#include "CJSONData.h"
+
+namespace json {
+
+CJSONData::CJSONData() :
+	m_Type(EJSONDataType::Block)
+{
+}
+
+CJSONData::CJSONData(EJSONDataType Type, const std::string& Name, const CJSONToken& NameToken) :
+	m_Type(Type),
+	m_Name(Name),
+	m_NameToken(NameToken)
+{
+}
+
+CJSONData::CJSONData(EJSONDataType Type, const std::string& Name, const std::string& Value, const CJSONToken& NameToken, const CJSONToken& ValueToken) :
+	m_Type(Type),
+	m_Name(Name),
+	m_Value(Value),
+	m_NameToken(NameToken),
+	m_ValueToken(ValueToken)
+{
+}
+
+void CJSONData::Add(const std::shared_ptr<CJSONData>& Data)
+{
+	m_DataList.push_back(Data);
+}
+
+void CJSONData::AddArray(const std::shared_ptr<CJSONData>& Data)
+{
+	m_ArrayList.push_back(Data);
+}
+
+std::shared_ptr<CJSONData>& CJSONData::GetLast()
+{
+	return m_DataList[m_DataList.size() - 1];
+}
+
+std::shared_ptr<CJSONData>& CJSONData::GetLastArray()
+{
+	return m_ArrayList[m_ArrayList.size() - 1];
+}
+
+EJSONDataType CJSONData::GetType() const
+{
+	return m_Type;
+}
+
+const std::string& CJSONData::GetName() const
+{
+	return m_Name;
+}
+
+const std::string& CJSONData::GetValue() const
+{
+	return m_Value;
+}
+
+void CJSONData::SetValue(const std::string& Value)
+{
+	m_Value = Value;
+	m_ValueToken = CJSONToken(m_ValueToken.GetPreSpaceText(), Value, m_ValueToken.GetPostSpaceText());
+}
+
+bool CJSONData::GetValueInt(int& Value) const
+{
+	return formatstring::ScanInt(m_Value, Value);
+}
+
+bool CJSONData::GetValueFloat(float& Value) const
+{
+	return formatstring::ScanFloat(m_Value, Value);
+}
+
+const std::vector<std::shared_ptr<CJSONData>>& CJSONData::GetDataList() const
+{
+	return m_DataList;
+}
+
+const std::vector<std::shared_ptr<CJSONData>>& CJSONData::GetArrayList() const
+{
+	return m_ArrayList;
+}
+
+CJSONData* CJSONData::Find(EJSONDataType Type, const std::string& Name)
+{
+	for (auto& Data : m_DataList) {
+		if (Data->GetType() != Type) continue;
+		if (Data->GetName() != Name) continue;
+
+		return Data.get();
+	}
+
+	return nullptr;
+}
+
+const CJSONData* CJSONData::Find(EJSONDataType Type, const std::string& Name) const
+{
+	for (const auto& Data : m_DataList) {
+		if (Data->GetType() != Type) continue;
+		if (Data->GetName() != Name) continue;
+
+		return Data.get();
+	}
+
+	return nullptr;
+}
+
+bool CJSONData::FindValueInt(const std::string& Name, int& Value) const
+{
+	const auto Data = Find(EJSONDataType::Number, Name);
+	if (!Data) return false;
+
+	return Data->GetValueInt(Value);
+}
+
+bool CJSONData::FindValueFloat(const std::string& Name, float& Value) const
+{
+	const auto Data = Find(EJSONDataType::Number, Name);
+	if (!Data) return false;
+
+	return Data->GetValueFloat(Value);
+}
+
+bool CJSONData::FindValueString(const std::string& Name, std::string& Value) const
+{
+	const auto Data = Find(EJSONDataType::StringValue, Name);
+	if (!Data) return false;
+
+	Value = Data->GetValue();
+
+	return true;
+}
+
+bool CJSONData::FindValueBool(const std::string& Name, bool& Value) const
+{
+	const auto Data = Find(EJSONDataType::Identifier, Name);
+	if (!Data) return false;
+
+	Value = (Data->GetValue() == "true");
+
+	return true;
+}
+
+void CJSONData::AddPostText(const std::string& Text)
+{
+	m_PostText += Text;
+}
+
+std::string CJSONData::GetText() const
+{
+	std::string Text;
+
+	Text += m_NameToken.GetTotalText();
+	Text += m_ValueToken.GetTotalText();
+
+	for (const auto& Data : m_DataList) {
+		Text += Data->GetText();
+	}
+
+	for (const auto& Array : m_ArrayList) {
+		Text += Array->GetText();
+	}
+
+	Text += m_PostText;
+
+	return Text;
+}
+
+}
+