@bloomengine/engine 0.3.1

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

@@ -0,0 +1,252 @@
+// 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/ObjectStreamBinaryIn.h>
+
+JPH_NAMESPACE_BEGIN
+
+ObjectStreamBinaryIn::ObjectStreamBinaryIn(istream &inStream) :
+	ObjectStreamIn(inStream)
+{
+}
+
+bool ObjectStreamBinaryIn::ReadDataType(EOSDataType &outType)
+{
+	uint32 type;
+	mStream.read((char *)&type, sizeof(type));
+	if (mStream.fail()) return false;
+	outType = (EOSDataType)type;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadName(String &outName)
+{
+	return ReadPrimitiveData(outName);
+}
+
+bool ObjectStreamBinaryIn::ReadIdentifier(Identifier &outIdentifier)
+{
+	Identifier id;
+	mStream.read((char *)&id, sizeof(id));
+	if (mStream.fail()) return false;
+	outIdentifier = id;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadCount(uint32 &outCount)
+{
+	uint32 count;
+	mStream.read((char *)&count, sizeof(count));
+	if (mStream.fail()) return false;
+	outCount = count;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(uint8 &outPrimitive)
+{
+	uint8 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(uint16 &outPrimitive)
+{
+	uint16 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(int &outPrimitive)
+{
+	int primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(uint32 &outPrimitive)
+{
+	uint32 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(uint64 &outPrimitive)
+{
+	uint64 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(float &outPrimitive)
+{
+	float primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(double &outPrimitive)
+{
+	double primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(bool &outPrimitive)
+{
+	bool primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(String &outPrimitive)
+{
+	// Read length or ID of string
+	uint32 len;
+	if (!ReadPrimitiveData(len))
+		return false;
+
+	// Check empty string
+	if (len == 0)
+	{
+		outPrimitive.clear();
+		return true;
+	}
+
+	// Check if it is an ID in the string table
+	if (len & 0x80000000)
+	{
+		StringTable::iterator i = mStringTable.find(len);
+		if (i == mStringTable.end())
+			return false;
+		outPrimitive = i->second;
+		return true;
+	}
+
+	// Read the string
+	char *data = (char *)JPH_STACK_ALLOC(len + 1);
+	mStream.read(data, len);
+	if (mStream.fail()) return false;
+	data[len] = 0;
+	outPrimitive = data;
+
+	// Insert string in table
+	mStringTable.try_emplace(mNextStringID, outPrimitive);
+	mNextStringID++;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Float3 &outPrimitive)
+{
+	Float3 primitive;
+	mStream.read((char *)&primitive, sizeof(Float3));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Float4 &outPrimitive)
+{
+	Float4 primitive;
+	mStream.read((char *)&primitive, sizeof(Float4));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Double3 &outPrimitive)
+{
+	Double3 primitive;
+	mStream.read((char *)&primitive, sizeof(Double3));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Vec3 &outPrimitive)
+{
+	Float3 primitive;
+	mStream.read((char *)&primitive, sizeof(Float3));
+	if (mStream.fail()) return false;
+	outPrimitive = Vec3(primitive); // Use Float3 constructor so that we initialize W too
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(DVec3 &outPrimitive)
+{
+	Double3 primitive;
+	mStream.read((char *)&primitive, sizeof(Double3));
+	if (mStream.fail()) return false;
+	outPrimitive = DVec3(primitive); // Use Float3 constructor so that we initialize W too
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Vec4 &outPrimitive)
+{
+	Vec4 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(UVec4 &outPrimitive)
+{
+	UVec4 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Quat &outPrimitive)
+{
+	Quat primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::ReadPrimitiveData(Mat44 &outPrimitive)
+{
+	Mat44 primitive;
+	mStream.read((char *)&primitive, sizeof(primitive));
+	if (mStream.fail()) return false;
+	outPrimitive = primitive;
+	return true;
+}
+
+bool ObjectStreamBinaryIn::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;
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,57 @@
+// 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 binary input stream.
+class JPH_EXPORT ObjectStreamBinaryIn : public ObjectStreamIn
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	explicit					ObjectStreamBinaryIn(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:
+	using StringTable = UnorderedMap<uint32, String>;
+
+	StringTable					mStringTable;
+	uint32						mNextStringID = 0x80000000;
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,165 @@
+// 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/ObjectStreamBinaryOut.h>
+#include <Jolt/Core/StringTools.h>
+
+JPH_NAMESPACE_BEGIN
+
+ObjectStreamBinaryOut::ObjectStreamBinaryOut(ostream &inStream) :
+	ObjectStreamOut(inStream)
+{
+	String header;
+	header = StringFormat("BOS%2d.%02d", ObjectStream::sVersion, ObjectStream::sRevision);
+	mStream.write(header.c_str(), header.size());
+}
+
+void ObjectStreamBinaryOut::WriteDataType(EOSDataType inType)
+{
+	mStream.write((const char *)&inType, sizeof(inType));
+}
+
+void ObjectStreamBinaryOut::WriteName(const char *inName)
+{
+	WritePrimitiveData(String(inName));
+}
+
+void ObjectStreamBinaryOut::WriteIdentifier(Identifier inIdentifier)
+{
+	mStream.write((const char *)&inIdentifier, sizeof(inIdentifier));
+}
+
+void ObjectStreamBinaryOut::WriteCount(uint32 inCount)
+{
+	mStream.write((const char *)&inCount, sizeof(inCount));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const uint8 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const uint16 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const int &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const uint32 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const uint64 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const float &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const double &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const bool &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const String &inPrimitive)
+{
+	// Empty strings are trivial
+	if (inPrimitive.empty())
+	{
+		WritePrimitiveData((uint32)0);
+		return;
+	}
+
+	// Check if we've already written this string
+	StringTable::iterator i = mStringTable.find(inPrimitive);
+	if (i != mStringTable.end())
+	{
+		WritePrimitiveData(i->second);
+		return;
+	}
+
+	// Insert string in table
+	mStringTable.try_emplace(inPrimitive, mNextStringID);
+	mNextStringID++;
+
+	// Write string
+	uint32 len = min((uint32)inPrimitive.size(), (uint32)0x7fffffff);
+	WritePrimitiveData(len);
+	mStream.write(inPrimitive.c_str(), len);
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Float3 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(Float3));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Float4 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(Float4));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Double3 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(Double3));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Vec3 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, 3 * sizeof(float));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const DVec3 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, 3 * sizeof(double));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Vec4 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const UVec4 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Quat &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const Mat44 &inPrimitive)
+{
+	mStream.write((const char *)&inPrimitive, sizeof(inPrimitive));
+}
+
+void ObjectStreamBinaryOut::WritePrimitiveData(const DMat44 &inPrimitive)
+{
+	WritePrimitiveData(inPrimitive.GetColumn4(0));
+	WritePrimitiveData(inPrimitive.GetColumn4(1));
+	WritePrimitiveData(inPrimitive.GetColumn4(2));
+	WritePrimitiveData(inPrimitive.GetTranslation());
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM
+

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

@@ -0,0 +1,57 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/ObjectStreamOut.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+/// Implementation of ObjectStream binary output stream.
+class JPH_EXPORT ObjectStreamBinaryOut : public ObjectStreamOut
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor and destructor
+	explicit					ObjectStreamBinaryOut(ostream &inStream);
+
+	///@name Output type specific operations
+	virtual void				WriteDataType(EOSDataType inType) override;
+	virtual void				WriteName(const char *inName) override;
+	virtual void				WriteIdentifier(Identifier inIdentifier) override;
+	virtual void				WriteCount(uint32 inCount) override;
+
+	virtual void				WritePrimitiveData(const uint8 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint16 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const int &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint32 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint64 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const float &inPrimitive) override;
+	virtual void				WritePrimitiveData(const double &inPrimitive) override;
+	virtual void				WritePrimitiveData(const bool &inPrimitive) override;
+	virtual void				WritePrimitiveData(const String &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Float3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Float4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Double3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Vec3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const DVec3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Vec4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const UVec4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Quat &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const DMat44 &inPrimitive) override;
+
+private:
+	using StringTable = UnorderedMap<String, uint32>;
+
+	StringTable					mStringTable;
+	uint32						mNextStringID = 0x80000000;
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM