@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Renderer/DebugRendererRecorder.cpp

@@ -0,0 +1,158 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#ifdef JPH_DEBUG_RENDERER
+
+#include <Jolt/Renderer/DebugRendererRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+void DebugRendererRecorder::DrawLine(RVec3Arg inFrom, RVec3Arg inTo, ColorArg inColor)
+{
+	lock_guard lock(mMutex);
+
+	mCurrentFrame.mLines.push_back({ inFrom, inTo, inColor });
+}
+
+void DebugRendererRecorder::DrawTriangle(RVec3Arg inV1, RVec3Arg inV2, RVec3Arg inV3, ColorArg inColor, ECastShadow inCastShadow)
+{
+	lock_guard lock(mMutex);
+
+	mCurrentFrame.mTriangles.push_back({ inV1, inV2, inV3, inColor, inCastShadow });
+}
+
+DebugRenderer::Batch DebugRendererRecorder::CreateTriangleBatch(const Triangle *inTriangles, int inTriangleCount)
+{
+	if (inTriangles == nullptr || inTriangleCount == 0)
+		return new BatchImpl(0);
+
+	lock_guard lock(mMutex);
+
+	mStream.Write(ECommand::CreateBatch);
+
+	uint32 batch_id = mNextBatchID++;
+	JPH_ASSERT(batch_id != 0);
+	mStream.Write(batch_id);
+	mStream.Write((uint32)inTriangleCount);
+	mStream.WriteBytes(inTriangles, inTriangleCount * sizeof(Triangle));
+
+	return new BatchImpl(batch_id);
+}
+
+DebugRenderer::Batch DebugRendererRecorder::CreateTriangleBatch(const Vertex *inVertices, int inVertexCount, const uint32 *inIndices, int inIndexCount)
+{
+	if (inVertices == nullptr || inVertexCount == 0 || inIndices == nullptr || inIndexCount == 0)
+		return new BatchImpl(0);
+
+	lock_guard lock(mMutex);
+
+	mStream.Write(ECommand::CreateBatchIndexed);
+
+	uint32 batch_id = mNextBatchID++;
+	JPH_ASSERT(batch_id != 0);
+	mStream.Write(batch_id);
+	mStream.Write((uint32)inVertexCount);
+	mStream.WriteBytes(inVertices, inVertexCount * sizeof(Vertex));
+	mStream.Write((uint32)inIndexCount);
+	mStream.WriteBytes(inIndices, inIndexCount * sizeof(uint32));
+
+	return new BatchImpl(batch_id);
+}
+
+void DebugRendererRecorder::DrawGeometry(RMat44Arg inModelMatrix, const AABox &inWorldSpaceBounds, float inLODScaleSq, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode)
+{
+	lock_guard lock(mMutex);
+
+	// See if this geometry was used before
+	uint32 &geometry_id = mGeometries[inGeometry];
+	if (geometry_id == 0)
+	{
+		mStream.Write(ECommand::CreateGeometry);
+
+		// Create a new ID
+		geometry_id = mNextGeometryID++;
+		JPH_ASSERT(geometry_id != 0);
+		mStream.Write(geometry_id);
+
+		// Save bounds
+		mStream.Write(inGeometry->mBounds.mMin);
+		mStream.Write(inGeometry->mBounds.mMax);
+
+		// Save the LODs
+		mStream.Write((uint32)inGeometry->mLODs.size());
+		for (const LOD & lod : inGeometry->mLODs)
+		{
+			mStream.Write(lod.mDistance);
+			mStream.Write(static_cast<const BatchImpl *>(lod.mTriangleBatch.GetPtr())->mID);
+		}
+	}
+
+	mCurrentFrame.mGeometries.push_back({ inModelMatrix, inModelColor, geometry_id, inCullMode, inCastShadow, inDrawMode });
+}
+
+void DebugRendererRecorder::DrawText3D(RVec3Arg inPosition, const string_view &inString, ColorArg inColor, float inHeight)
+{
+	lock_guard lock(mMutex);
+
+	mCurrentFrame.mTexts.push_back({ inPosition, inString, inColor, inHeight });
+}
+
+void DebugRendererRecorder::EndFrame()
+{
+	lock_guard lock(mMutex);
+
+	mStream.Write(ECommand::EndFrame);
+
+	// Write all lines
+	mStream.Write((uint32)mCurrentFrame.mLines.size());
+	for (const LineBlob &line : mCurrentFrame.mLines)
+	{
+		mStream.Write(line.mFrom);
+		mStream.Write(line.mTo);
+		mStream.Write(line.mColor);
+	}
+	mCurrentFrame.mLines.clear();
+
+	// Write all triangles
+	mStream.Write((uint32)mCurrentFrame.mTriangles.size());
+	for (const TriangleBlob &triangle : mCurrentFrame.mTriangles)
+	{
+		mStream.Write(triangle.mV1);
+		mStream.Write(triangle.mV2);
+		mStream.Write(triangle.mV3);
+		mStream.Write(triangle.mColor);
+		mStream.Write(triangle.mCastShadow);
+	}
+	mCurrentFrame.mTriangles.clear();
+
+	// Write all texts
+	mStream.Write((uint32)mCurrentFrame.mTexts.size());
+	for (const TextBlob &text : mCurrentFrame.mTexts)
+	{
+		mStream.Write(text.mPosition);
+		mStream.Write(text.mString);
+		mStream.Write(text.mColor);
+		mStream.Write(text.mHeight);
+	}
+	mCurrentFrame.mTexts.clear();
+
+	// Write all geometries
+	mStream.Write((uint32)mCurrentFrame.mGeometries.size());
+	for (const GeometryBlob &geom : mCurrentFrame.mGeometries)
+	{
+		mStream.Write(geom.mModelMatrix);
+		mStream.Write(geom.mModelColor);
+		mStream.Write(geom.mGeometryID);
+		mStream.Write(geom.mCullMode);
+		mStream.Write(geom.mCastShadow);
+		mStream.Write(geom.mDrawMode);
+	}
+	mCurrentFrame.mGeometries.clear();
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_DEBUG_RENDERER

package/native/third_party/JoltPhysics/Jolt/Renderer/DebugRendererRecorder.h

@@ -0,0 +1,130 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifndef JPH_DEBUG_RENDERER
+	#error This file should only be included when JPH_DEBUG_RENDERER is defined
+#endif // !JPH_DEBUG_RENDERER
+
+#include <Jolt/Renderer/DebugRenderer.h>
+#include <Jolt/Core/StreamOut.h>
+#include <Jolt/Core/Mutex.h>
+#include <Jolt/Core/UnorderedMap.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Implementation of DebugRenderer that records the API invocations to be played back later
+class JPH_DEBUG_RENDERER_EXPORT DebugRendererRecorder final : public DebugRenderer
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+										DebugRendererRecorder(StreamOut &inStream) : mStream(inStream) { Initialize(); }
+
+	/// Implementation of DebugRenderer interface
+	virtual void						DrawLine(RVec3Arg inFrom, RVec3Arg inTo, ColorArg inColor) override;
+	virtual void						DrawTriangle(RVec3Arg inV1, RVec3Arg inV2, RVec3Arg inV3, ColorArg inColor, ECastShadow inCastShadow) override;
+	virtual Batch						CreateTriangleBatch(const Triangle *inTriangles, int inTriangleCount) override;
+	virtual Batch						CreateTriangleBatch(const Vertex *inVertices, int inVertexCount, const uint32 *inIndices, int inIndexCount) override;
+	virtual void						DrawGeometry(RMat44Arg inModelMatrix, const AABox &inWorldSpaceBounds, float inLODScaleSq, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode) override;
+	virtual void						DrawText3D(RVec3Arg inPosition, const string_view &inString, ColorArg inColor, float inHeight) override;
+
+	/// Mark the end of a frame
+	void								EndFrame();
+
+	/// Control commands written into the stream
+	enum class ECommand : uint8
+	{
+		CreateBatch,
+		CreateBatchIndexed,
+		CreateGeometry,
+		EndFrame
+	};
+
+	/// Holds a single line segment
+	struct LineBlob
+	{
+		RVec3							mFrom;
+		RVec3							mTo;
+		Color							mColor;
+	};
+
+	/// Holds a single triangle
+	struct TriangleBlob
+	{
+		RVec3							mV1;
+		RVec3							mV2;
+		RVec3							mV3;
+		Color							mColor;
+		ECastShadow						mCastShadow;
+	};
+
+	/// Holds a single text entry
+	struct TextBlob
+	{
+										TextBlob() = default;
+										TextBlob(RVec3Arg inPosition, const string_view &inString, ColorArg inColor, float inHeight) : mPosition(inPosition), mString(inString), mColor(inColor), mHeight(inHeight) { }
+
+		RVec3							mPosition;
+		String							mString;
+		Color							mColor;
+		float							mHeight;
+	};
+
+	/// Holds a single geometry draw call
+	struct GeometryBlob
+	{
+		RMat44							mModelMatrix;
+		Color							mModelColor;
+		uint32							mGeometryID;
+		ECullMode						mCullMode;
+		ECastShadow						mCastShadow;
+		EDrawMode						mDrawMode;
+	};
+
+	/// All information for a single frame
+	struct Frame
+	{
+		Array<LineBlob>					mLines;
+		Array<TriangleBlob>				mTriangles;
+		Array<TextBlob>					mTexts;
+		Array<GeometryBlob>				mGeometries;
+	};
+
+private:
+	/// Implementation specific batch object
+	class BatchImpl : public RefTargetVirtual
+	{
+	public:
+		JPH_OVERRIDE_NEW_DELETE
+
+										BatchImpl(uint32 inID)		: mID(inID) {  }
+
+		virtual void					AddRef() override			{ ++mRefCount; }
+		virtual void					Release() override			{ if (--mRefCount == 0) delete this; }
+
+		atomic<uint32>					mRefCount = 0;
+		uint32							mID;
+	};
+
+	/// Lock that prevents concurrent access to the internal structures
+	Mutex								mMutex;
+
+	/// Stream that recorded data will be sent to
+	StreamOut &							mStream;
+
+	/// Next available ID
+	uint32								mNextBatchID = 1;
+	uint32								mNextGeometryID = 1;
+
+	/// Cached geometries and their IDs
+	UnorderedMap<GeometryRef, uint32>	mGeometries;
+
+	/// Data that is being accumulated for the current frame
+	Frame								mCurrentFrame;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Renderer/DebugRendererSimple.cpp

@@ -0,0 +1,80 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#ifdef JPH_DEBUG_RENDERER
+
+#include <Jolt/Renderer/DebugRendererSimple.h>
+
+JPH_NAMESPACE_BEGIN
+
+DebugRendererSimple::DebugRendererSimple()
+{
+	Initialize();
+}
+
+DebugRenderer::Batch DebugRendererSimple::CreateTriangleBatch(const Triangle *inTriangles, int inTriangleCount)
+{
+	BatchImpl *batch = new BatchImpl;
+	if (inTriangles == nullptr || inTriangleCount == 0)
+		return batch;
+
+	batch->mTriangles.assign(inTriangles, inTriangles + inTriangleCount);
+	return batch;
+}
+
+DebugRenderer::Batch DebugRendererSimple::CreateTriangleBatch(const Vertex *inVertices, int inVertexCount, const uint32 *inIndices, int inIndexCount)
+{
+	BatchImpl *batch = new BatchImpl;
+	if (inVertices == nullptr || inVertexCount == 0 || inIndices == nullptr || inIndexCount == 0)
+		return batch;
+
+	// Convert indexed triangle list to triangle list
+	batch->mTriangles.resize(inIndexCount / 3);
+	for (size_t t = 0; t < batch->mTriangles.size(); ++t)
+	{
+		Triangle &triangle = batch->mTriangles[t];
+		triangle.mV[0] = inVertices[inIndices[t * 3 + 0]];
+		triangle.mV[1] = inVertices[inIndices[t * 3 + 1]];
+		triangle.mV[2] = inVertices[inIndices[t * 3 + 2]];
+	}
+
+	return batch;
+}
+
+void DebugRendererSimple::DrawGeometry(RMat44Arg inModelMatrix, const AABox &inWorldSpaceBounds, float inLODScaleSq, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode)
+{
+	// Figure out which LOD to use
+	const LOD *lod = inGeometry->mLODs.data();
+	if (mCameraPosSet)
+		lod = &inGeometry->GetLOD(Vec3(mCameraPos), inWorldSpaceBounds, inLODScaleSq);
+
+	// Draw the batch
+	const BatchImpl *batch = static_cast<const BatchImpl *>(lod->mTriangleBatch.GetPtr());
+	for (const Triangle &triangle : batch->mTriangles)
+	{
+		RVec3 v0 = inModelMatrix * Vec3(triangle.mV[0].mPosition);
+		RVec3 v1 = inModelMatrix * Vec3(triangle.mV[1].mPosition);
+		RVec3 v2 = inModelMatrix * Vec3(triangle.mV[2].mPosition);
+		Color color = inModelColor * triangle.mV[0].mColor;
+
+		switch (inDrawMode)
+		{
+		case EDrawMode::Wireframe:
+			DrawLine(v0, v1, color);
+			DrawLine(v1, v2, color);
+			DrawLine(v2, v0, color);
+			break;
+
+		case EDrawMode::Solid:
+			DrawTriangle(v0, v1, v2, color, inCastShadow);
+			break;
+		}
+	}
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_DEBUG_RENDERER

package/native/third_party/JoltPhysics/Jolt/Renderer/DebugRendererSimple.h

@@ -0,0 +1,88 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifndef JPH_DEBUG_RENDERER
+	#error This file should only be included when JPH_DEBUG_RENDERER is defined
+#endif // !JPH_DEBUG_RENDERER
+
+#include <Jolt/Renderer/DebugRenderer.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Inherit from this class to simplify implementing a debug renderer, start with this implementation:
+///
+///		class MyDebugRenderer : public JPH::DebugRendererSimple
+///		{
+///		public:
+///			virtual void DrawLine(JPH::RVec3Arg inFrom, JPH::RVec3Arg inTo, JPH::ColorArg inColor) override
+///			{
+///				// Implement
+///			}
+///
+///			virtual void DrawTriangle(JPH::RVec3Arg inV1, JPH::RVec3Arg inV2, JPH::RVec3Arg inV3, JPH::ColorArg inColor, ECastShadow inCastShadow) override
+///			{
+///				// Implement
+///			}
+///
+///			virtual void DrawText3D(JPH::RVec3Arg inPosition, const string_view &inString, JPH::ColorArg inColor, float inHeight) override
+///			{
+///				// Implement
+///			}
+///		};
+///
+/// Note that this class is meant to be a quick start for implementing a debug renderer, it is not the most efficient way to implement a debug renderer.
+class JPH_DEBUG_RENDERER_EXPORT DebugRendererSimple : public DebugRenderer
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+								DebugRendererSimple();
+
+	/// Should be called every frame by the application to provide the camera position.
+	/// This is used to determine the correct LOD for rendering.
+	void						SetCameraPos(RVec3Arg inCameraPos)
+	{
+		mCameraPos = inCameraPos;
+		mCameraPosSet = true;
+	}
+
+	/// Fallback implementation that uses DrawLine to draw a triangle (override this if you have a version that renders solid triangles)
+	virtual void				DrawTriangle(RVec3Arg inV1, RVec3Arg inV2, RVec3Arg inV3, ColorArg inColor, ECastShadow inCastShadow) override
+	{
+		DrawLine(inV1, inV2, inColor);
+		DrawLine(inV2, inV3, inColor);
+		DrawLine(inV3, inV1, inColor);
+	}
+
+protected:
+	/// Implementation of DebugRenderer interface
+	virtual Batch				CreateTriangleBatch(const Triangle *inTriangles, int inTriangleCount) override;
+	virtual Batch				CreateTriangleBatch(const Vertex *inVertices, int inVertexCount, const uint32 *inIndices, int inIndexCount) override;
+	virtual void				DrawGeometry(RMat44Arg inModelMatrix, const AABox &inWorldSpaceBounds, float inLODScaleSq, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode, ECastShadow inCastShadow, EDrawMode inDrawMode) override;
+
+private:
+	/// Implementation specific batch object
+	class BatchImpl : public RefTargetVirtual
+	{
+	public:
+		JPH_OVERRIDE_NEW_DELETE
+
+		virtual void			AddRef() override			{ ++mRefCount; }
+		virtual void			Release() override			{ if (--mRefCount == 0) delete this; }
+
+		Array<Triangle>			mTriangles;
+
+	private:
+		atomic<uint32>			mRefCount = 0;
+	};
+
+	/// Last provided camera position
+	RVec3						mCameraPos;
+	bool						mCameraPosSet = false;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Skeleton/SkeletalAnimation.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>
+
+#include <Jolt/Skeleton/SkeletalAnimation.h>
+#include <Jolt/Skeleton/SkeletonPose.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(SkeletalAnimation::JointState)
+{
+	JPH_ADD_ATTRIBUTE(JointState, mRotation)
+	JPH_ADD_ATTRIBUTE(JointState, mTranslation)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(SkeletalAnimation::Keyframe)
+{
+	JPH_ADD_BASE_CLASS(Keyframe, JointState)
+
+	JPH_ADD_ATTRIBUTE(Keyframe, mTime)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(SkeletalAnimation::AnimatedJoint)
+{
+	JPH_ADD_ATTRIBUTE(AnimatedJoint, mJointName)
+	JPH_ADD_ATTRIBUTE(AnimatedJoint, mKeyframes)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(SkeletalAnimation)
+{
+	JPH_ADD_ATTRIBUTE(SkeletalAnimation, mAnimatedJoints)
+	JPH_ADD_ATTRIBUTE(SkeletalAnimation, mIsLooping)
+}
+
+
+void SkeletalAnimation::JointState::FromMatrix(Mat44Arg inMatrix)
+{
+	mRotation = inMatrix.GetQuaternion();
+	mTranslation = inMatrix.GetTranslation();
+}
+
+float SkeletalAnimation::GetDuration() const
+{
+	if (!mAnimatedJoints.empty() && !mAnimatedJoints[0].mKeyframes.empty())
+		return mAnimatedJoints[0].mKeyframes.back().mTime;
+	else
+		return 0.0f;
+}
+
+void SkeletalAnimation::ScaleJoints(float inScale)
+{
+	for (SkeletalAnimation::AnimatedJoint &j : mAnimatedJoints)
+		for (SkeletalAnimation::Keyframe &k : j.mKeyframes)
+			k.mTranslation *= inScale;
+}
+
+void SkeletalAnimation::Sample(float inTime, SkeletonPose &ioPose) const
+{
+	// Correct time when animation is looping
+	JPH_ASSERT(inTime >= 0.0f);
+	float duration = GetDuration();
+	float time = duration > 0.0f && mIsLooping? fmod(inTime, duration) : inTime;
+
+	for (const AnimatedJoint &aj : mAnimatedJoints)
+	{
+		// Do binary search for keyframe
+		int high = (int)aj.mKeyframes.size(), low = -1;
+		while (high - low > 1)
+		{
+			int probe = (high + low) / 2;
+			if (aj.mKeyframes[probe].mTime < time)
+				low = probe;
+			else
+				high = probe;
+		}
+
+		JointState &state = ioPose.GetJoint(ioPose.GetSkeleton()->GetJointIndex(aj.mJointName));
+
+		if (low == -1)
+		{
+			// Before first key, return first key
+			state = static_cast<const JointState &>(aj.mKeyframes.front());
+		}
+		else if (high == (int)aj.mKeyframes.size())
+		{
+			// Beyond last key, return last key
+			state = static_cast<const JointState &>(aj.mKeyframes.back());
+		}
+		else
+		{
+			// Interpolate
+			const Keyframe &s1 = aj.mKeyframes[low];
+			const Keyframe &s2 = aj.mKeyframes[low + 1];
+
+			float fraction = (time - s1.mTime) / (s2.mTime - s1.mTime);
+			JPH_ASSERT(fraction >= 0.0f && fraction <= 1.0f);
+
+			state.mTranslation = (1.0f - fraction) * s1.mTranslation + fraction * s2.mTranslation;
+			JPH_ASSERT(s1.mRotation.IsNormalized());
+			JPH_ASSERT(s2.mRotation.IsNormalized());
+			state.mRotation = s1.mRotation.SLERP(s2.mRotation, fraction);
+			JPH_ASSERT(state.mRotation.IsNormalized());
+		}
+	}
+}
+
+void SkeletalAnimation::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write((uint32)mAnimatedJoints.size());
+	for (const AnimatedJoint &j : mAnimatedJoints)
+	{
+		// Write Joint name and number of keyframes
+		inStream.Write(j.mJointName);
+		inStream.Write((uint32)j.mKeyframes.size());
+		for (const Keyframe &k : j.mKeyframes)
+		{
+			inStream.Write(k.mTime);
+			inStream.Write(k.mRotation);
+			inStream.Write(k.mTranslation);
+		}
+	}
+
+	// Save additional parameters
+	inStream.Write(mIsLooping);
+}
+
+SkeletalAnimation::AnimationResult SkeletalAnimation::sRestoreFromBinaryState(StreamIn &inStream)
+{
+	AnimationResult result;
+
+	Ref<SkeletalAnimation> animation = new SkeletalAnimation;
+
+	// Restore animated joints
+	uint32 len = 0;
+	inStream.Read(len);
+	animation->mAnimatedJoints.resize(len);
+	for (AnimatedJoint &j : animation->mAnimatedJoints)
+	{
+		// Read joint name
+		inStream.Read(j.mJointName);
+
+		// Read keyframes
+		len = 0;
+		inStream.Read(len);
+		j.mKeyframes.resize(len);
+		for (Keyframe &k : j.mKeyframes)
+		{
+			inStream.Read(k.mTime);
+			inStream.Read(k.mRotation);
+			inStream.Read(k.mTranslation);
+		}
+	}
+
+	// Read additional parameters
+	inStream.Read(animation->mIsLooping);
+	result.Set(animation);
+	return result;
+}
+
+JPH_NAMESPACE_END