@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/ObjectStream/ObjectStreamTextIn.cpp

@@ -0,0 +1,418 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+#include <Jolt/ObjectStream/ObjectStreamTextIn.h>
+
+JPH_NAMESPACE_BEGIN
+
+ObjectStreamTextIn::ObjectStreamTextIn(istream &inStream) :
+	ObjectStreamIn(inStream)
+{
+}
+
+bool ObjectStreamTextIn::ReadDataType(EOSDataType &outType)
+{
+	String token;
+	if (ReadWord(token))
+	{
+		transform(token.begin(), token.end(), token.begin(), [](char inValue) { return (char)tolower(inValue); });
+		if (token == "declare")
+			outType = EOSDataType::Declare;
+		else if (token == "object")
+			outType = EOSDataType::Object;
+		else if (token == "instance")
+			outType = EOSDataType::Instance;
+		else if (token == "pointer")
+			outType = EOSDataType::Pointer;
+		else if (token == "array")
+			outType = EOSDataType::Array;
+		else if (token == "uint8")
+			outType = EOSDataType::T_uint8;
+		else if (token == "uint16")
+			outType = EOSDataType::T_uint16;
+		else if (token == "int")
+			outType = EOSDataType::T_int;
+		else if (token == "uint32")
+			outType = EOSDataType::T_uint32;
+		else if (token == "uint64")
+			outType = EOSDataType::T_uint64;
+		else if (token == "float")
+			outType = EOSDataType::T_float;
+		else if (token == "double")
+			outType = EOSDataType::T_double;
+		else if (token == "bool")
+			outType = EOSDataType::T_bool;
+		else if (token == "string")
+			outType = EOSDataType::T_String;
+		else if (token == "float3")
+			outType = EOSDataType::T_Float3;
+		else if (token == "float4")
+			outType = EOSDataType::T_Float4;
+		else if (token == "double3")
+			outType = EOSDataType::T_Double3;
+		else if (token == "vec3")
+			outType = EOSDataType::T_Vec3;
+		else if (token == "dvec3")
+			outType = EOSDataType::T_DVec3;
+		else if (token == "vec4")
+			outType = EOSDataType::T_Vec4;
+		else if (token == "uvec4")
+			outType = EOSDataType::T_UVec4;
+		else if (token == "quat")
+			outType = EOSDataType::T_Quat;
+		else if (token == "mat44")
+			outType = EOSDataType::T_Mat44;
+		else if (token == "dmat44")
+			outType = EOSDataType::T_DMat44;
+		else
+		{
+			Trace("ObjectStreamTextIn: Found unknown data type.");
+			return false;
+		}
+		return true;
+	}
+	return false;
+}
+
+bool ObjectStreamTextIn::ReadName(String &outName)
+{
+	return ReadWord(outName);
+}
+
+bool ObjectStreamTextIn::ReadIdentifier(Identifier &outIdentifier)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	outIdentifier = (uint32)std::strtoul(token.c_str(), nullptr, 16);
+	if (errno == ERANGE)
+	{
+		outIdentifier = sNullIdentifier;
+		return false;
+	}
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadCount(uint32 &outCount)
+{
+	return ReadPrimitiveData(outCount);
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(uint8 &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	uint32 temporary;
+	IStringStream stream(token);
+	stream >> temporary;
+	if (!stream.fail())
+	{
+		outPrimitive = (uint8)temporary;
+		return true;
+	}
+	return false;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(uint16 &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	uint32 temporary;
+	IStringStream stream(token);
+	stream >> temporary;
+	if (!stream.fail())
+	{
+		outPrimitive = (uint16)temporary;
+		return true;
+	}
+	return false;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(int &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	IStringStream stream(token);
+	stream >> outPrimitive;
+	return !stream.fail();
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(uint32 &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	IStringStream stream(token);
+	stream >> outPrimitive;
+	return !stream.fail();
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(uint64 &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	IStringStream stream(token);
+	stream >> outPrimitive;
+	return !stream.fail();
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(float &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	IStringStream stream(token);
+	stream >> outPrimitive;
+	return !stream.fail();
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(double &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	IStringStream stream(token);
+	stream >> outPrimitive;
+	return !stream.fail();
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(bool &outPrimitive)
+{
+	String token;
+	if (!ReadWord(token))
+		return false;
+	transform(token.begin(), token.end(), token.begin(), [](char inValue) { return (char)tolower(inValue); });
+	outPrimitive = token == "true";
+	return outPrimitive || token == "false";
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(String &outPrimitive)
+{
+	outPrimitive.clear();
+
+	char c;
+
+	// Skip whitespace
+	for (;;)
+	{
+		if (!ReadChar(c))
+			return false;
+
+		if (!isspace(c))
+			break;
+	}
+
+	// Check if it is a opening quote
+	if (c != '\"')
+		return false;
+
+	// Read string and interpret special characters
+	String result;
+	bool escaped = false;
+	for (;;)
+	{
+		if (!ReadChar(c))
+			break;
+
+		switch (c)
+		{
+		case '\n':
+		case '\t':
+			break;
+
+		case '\\':
+			if (escaped)
+			{
+				result += '\\';
+				escaped = false;
+			}
+			else
+				escaped = true;
+			break;
+
+		case 'n':
+			if (escaped)
+			{
+				result += '\n';
+				escaped = false;
+			}
+			else
+				result += 'n';
+			break;
+
+		case 't':
+			if (escaped)
+			{
+				result += '\t';
+				escaped = false;
+			}
+			else
+				result += 't';
+			break;
+
+		case '\"':
+			if (escaped)
+			{
+				result += '\"';
+				escaped = false;
+			}
+			else
+			{
+				// Found closing double quote
+				outPrimitive = result;
+				return true;
+			}
+			break;
+
+		default:
+			if (escaped)
+				escaped = false;
+			else
+				result += c;
+			break;
+		}
+	}
+
+	return false;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Float3 &outPrimitive)
+{
+	float x, y, z;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z))
+		return false;
+	outPrimitive = Float3(x, y, z);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Float4 &outPrimitive)
+{
+	float x, y, z, w;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z) || !ReadPrimitiveData(w))
+		return false;
+	outPrimitive = Float4(x, y, z, w);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Double3 &outPrimitive)
+{
+	double x, y, z;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z))
+		return false;
+	outPrimitive = Double3(x, y, z);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Vec3 &outPrimitive)
+{
+	float x, y, z;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z))
+		return false;
+	outPrimitive = Vec3(x, y, z);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(DVec3 &outPrimitive)
+{
+	double x, y, z;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z))
+		return false;
+	outPrimitive = DVec3(x, y, z);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Vec4 &outPrimitive)
+{
+	float x, y, z, w;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z) || !ReadPrimitiveData(w))
+		return false;
+	outPrimitive = Vec4(x, y, z, w);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(UVec4 &outPrimitive)
+{
+	uint32 x, y, z, w;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z) || !ReadPrimitiveData(w))
+		return false;
+	outPrimitive = UVec4(x, y, z, w);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Quat &outPrimitive)
+{
+	float x, y, z, w;
+	if (!ReadPrimitiveData(x) || !ReadPrimitiveData(y) || !ReadPrimitiveData(z) || !ReadPrimitiveData(w))
+		return false;
+	outPrimitive = Quat(x, y, z, w);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(Mat44 &outPrimitive)
+{
+	Vec4 c0, c1, c2, c3;
+	if (!ReadPrimitiveData(c0) || !ReadPrimitiveData(c1) || !ReadPrimitiveData(c2) || !ReadPrimitiveData(c3))
+		return false;
+	outPrimitive = Mat44(c0, c1, c2, c3);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadPrimitiveData(DMat44 &outPrimitive)
+{
+	Vec4 c0, c1, c2;
+	DVec3 c3;
+	if (!ReadPrimitiveData(c0) || !ReadPrimitiveData(c1) || !ReadPrimitiveData(c2) || !ReadPrimitiveData(c3))
+		return false;
+	outPrimitive = DMat44(c0, c1, c2, c3);
+	return true;
+}
+
+bool ObjectStreamTextIn::ReadChar(char &outChar)
+{
+	mStream.get(outChar);
+	return !mStream.eof();
+}
+
+bool ObjectStreamTextIn::ReadWord(String &outWord)
+{
+	outWord.clear();
+
+	char c;
+
+	// Skip whitespace
+	for (;;)
+	{
+		if (!ReadChar(c))
+			return false;
+
+		if (!isspace(c))
+			break;
+	}
+
+	// Read word
+	for (;;)
+	{
+		outWord += c;
+
+		if (!ReadChar(c))
+			break;
+
+		if (isspace(c))
+			break;
+	}
+
+	return !outWord.empty();
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

package/native/third_party/JoltPhysics/Jolt/ObjectStream/ObjectStreamTextIn.h

@@ -0,0 +1,55 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+/// Implementation of ObjectStream text input stream.
+class JPH_EXPORT ObjectStreamTextIn : public ObjectStreamIn
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	explicit					ObjectStreamTextIn(istream &inStream);
+
+	///@name Input type specific operations
+	virtual bool				ReadDataType(EOSDataType &outType) override;
+	virtual bool				ReadName(String &outName) override;
+	virtual bool				ReadIdentifier(Identifier &outIdentifier) override;
+	virtual bool				ReadCount(uint32 &outCount) override;
+
+	virtual bool				ReadPrimitiveData(uint8 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(uint16 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(int &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(uint32 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(uint64 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(float &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(double &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(bool &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(String &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Float3 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Float4 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Double3 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Vec3 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(DVec3 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Vec4 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(UVec4 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Quat &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(Mat44 &outPrimitive) override;
+	virtual bool				ReadPrimitiveData(DMat44 &outPrimitive) override;
+
+private:
+	bool						ReadChar(char &outChar);
+	bool						ReadWord(String &outWord);
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

package/native/third_party/JoltPhysics/Jolt/ObjectStream/ObjectStreamTextOut.cpp

@@ -0,0 +1,255 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+#include <Jolt/ObjectStream/ObjectStreamTextOut.h>
+#include <Jolt/Core/StringTools.h>
+
+JPH_NAMESPACE_BEGIN
+
+ObjectStreamTextOut::ObjectStreamTextOut(ostream &inStream) :
+	ObjectStreamOut(inStream)
+{
+	WriteWord(StringFormat("TOS%2d.%02d", ObjectStream::sVersion, ObjectStream::sRevision));
+}
+
+void ObjectStreamTextOut::WriteDataType(EOSDataType inType)
+{
+	switch (inType)
+	{
+	case EOSDataType::Declare:		WriteWord("declare ");		break;
+	case EOSDataType::Object:		WriteWord("object ");		break;
+	case EOSDataType::Instance:		WriteWord("instance ");		break;
+	case EOSDataType::Pointer:		WriteWord("pointer ");		break;
+	case EOSDataType::Array:		WriteWord("array ");		break;
+	case EOSDataType::T_uint8:		WriteWord("uint8");			break;
+	case EOSDataType::T_uint16:		WriteWord("uint16");		break;
+	case EOSDataType::T_int:		WriteWord("int");			break;
+	case EOSDataType::T_uint32:		WriteWord("uint32");		break;
+	case EOSDataType::T_uint64:		WriteWord("uint64");		break;
+	case EOSDataType::T_float:		WriteWord("float");			break;
+	case EOSDataType::T_double:		WriteWord("double");		break;
+	case EOSDataType::T_bool:		WriteWord("bool");			break;
+	case EOSDataType::T_String:		WriteWord("string");		break;
+	case EOSDataType::T_Float3:		WriteWord("float3");		break;
+	case EOSDataType::T_Float4:		WriteWord("float4");		break;
+	case EOSDataType::T_Double3:	WriteWord("double3");		break;
+	case EOSDataType::T_Vec3:		WriteWord("vec3");			break;
+	case EOSDataType::T_DVec3:		WriteWord("dvec3");			break;
+	case EOSDataType::T_Vec4:		WriteWord("vec4");			break;
+	case EOSDataType::T_UVec4:		WriteWord("uvec4");			break;
+	case EOSDataType::T_Quat:		WriteWord("quat");			break;
+	case EOSDataType::T_Mat44:		WriteWord("mat44");			break;
+	case EOSDataType::T_DMat44:		WriteWord("dmat44");		break;
+	case EOSDataType::Invalid:
+	default:						JPH_ASSERT(false);			break;
+	}
+}
+
+void ObjectStreamTextOut::WriteName(const char *inName)
+{
+	WriteWord(String(inName) + " ");
+}
+
+void ObjectStreamTextOut::WriteIdentifier(Identifier inIdentifier)
+{
+	WriteWord(StringFormat("%08X", inIdentifier));
+}
+
+void ObjectStreamTextOut::WriteCount(uint32 inCount)
+{
+	WriteWord(std::to_string(inCount));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const uint8 &inPrimitive)
+{
+	WriteWord(std::to_string(inPrimitive));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const uint16 &inPrimitive)
+{
+	WriteWord(std::to_string(inPrimitive));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const int &inPrimitive)
+{
+	WriteWord(std::to_string(inPrimitive));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const uint32 &inPrimitive)
+{
+	WriteWord(std::to_string(inPrimitive));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const uint64 &inPrimitive)
+{
+	WriteWord(std::to_string(inPrimitive));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const float &inPrimitive)
+{
+	std::ostringstream stream;
+	stream.precision(9);
+	stream << inPrimitive;
+	WriteWord(stream.str());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const double &inPrimitive)
+{
+	std::ostringstream stream;
+	stream.precision(17);
+	stream << inPrimitive;
+	WriteWord(stream.str());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const bool &inPrimitive)
+{
+	WriteWord(inPrimitive? "true" : "false");
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Float3 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.x);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.y);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.z);
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Float4 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.x);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.y);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.z);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.w);
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Double3 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.x);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.y);
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.z);
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Vec3 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetX());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetY());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetZ());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const DVec3 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetX());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetY());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetZ());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Vec4 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetX());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetY());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetZ());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetW());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const UVec4 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetX());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetY());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetZ());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetW());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Quat &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetX());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetY());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetZ());
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetW());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const Mat44 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetColumn4(0));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetColumn4(1));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetColumn4(2));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetColumn4(3));
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const DMat44 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetColumn4(0));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetColumn4(1));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetColumn4(2));
+	WriteChar(' ');
+	WritePrimitiveData(inPrimitive.GetTranslation());
+}
+
+void ObjectStreamTextOut::WritePrimitiveData(const String &inPrimitive)
+{
+	String temporary(inPrimitive);
+	StringReplace(temporary, "\\", "\\\\");
+	StringReplace(temporary, "\n", "\\n");
+	StringReplace(temporary, "\t", "\\t");
+	StringReplace(temporary, "\"", "\\\"");
+	WriteWord(String("\"") + temporary + String("\""));
+}
+
+void ObjectStreamTextOut::HintNextItem()
+{
+	WriteWord("\r\n");
+	for (int i = 0; i < mIndentation; ++i)
+		WriteWord("  ");
+}
+
+void ObjectStreamTextOut::HintIndentUp()
+{
+	++mIndentation;
+}
+
+void ObjectStreamTextOut::HintIndentDown()
+{
+	--mIndentation;
+}
+
+void ObjectStreamTextOut::WriteChar(char inChar)
+{
+	mStream.put(inChar);
+}
+
+void ObjectStreamTextOut::WriteWord(const string_view &inWord)
+{
+	mStream << inWord;
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM