@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/DecoratedShape.cpp

@@ -0,0 +1,87 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Collision/Shape/DecoratedShape.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(DecoratedShapeSettings)
+{
+	JPH_ADD_BASE_CLASS(DecoratedShapeSettings, ShapeSettings)
+
+	JPH_ADD_ATTRIBUTE(DecoratedShapeSettings, mInnerShape)
+}
+
+DecoratedShape::DecoratedShape(EShapeSubType inSubType, const DecoratedShapeSettings &inSettings, ShapeResult &outResult) :
+	Shape(EShapeType::Decorated, inSubType, inSettings, outResult)
+{
+	// Check that there's a shape
+	if (inSettings.mInnerShape == nullptr && inSettings.mInnerShapePtr == nullptr)
+	{
+		outResult.SetError("Inner shape is null!");
+		return;
+	}
+
+	if (inSettings.mInnerShapePtr != nullptr)
+	{
+		// Use provided shape
+		mInnerShape = inSettings.mInnerShapePtr;
+	}
+	else
+	{
+		// Create child shape
+		ShapeResult child_result = inSettings.mInnerShape->Create();
+		if (!child_result.IsValid())
+		{
+			outResult = child_result;
+			return;
+		}
+		mInnerShape = child_result.Get();
+	}
+}
+
+const PhysicsMaterial *DecoratedShape::GetMaterial(const SubShapeID &inSubShapeID) const
+{
+	return mInnerShape->GetMaterial(inSubShapeID);
+}
+
+void DecoratedShape::GetSupportingFace(const SubShapeID &inSubShapeID, Vec3Arg inDirection, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform, SupportingFace &outVertices) const
+{
+	mInnerShape->GetSupportingFace(inSubShapeID, inDirection, inScale, inCenterOfMassTransform, outVertices);
+}
+
+uint64 DecoratedShape::GetSubShapeUserData(const SubShapeID &inSubShapeID) const
+{
+	return mInnerShape->GetSubShapeUserData(inSubShapeID);
+}
+
+void DecoratedShape::SaveSubShapeState(ShapeList &outSubShapes) const
+{
+	outSubShapes.clear();
+	outSubShapes.push_back(mInnerShape);
+}
+
+void DecoratedShape::RestoreSubShapeState(const ShapeRefC *inSubShapes, uint inNumShapes)
+{
+	JPH_ASSERT(inNumShapes == 1);
+	mInnerShape = inSubShapes[0];
+}
+
+Shape::Stats DecoratedShape::GetStatsRecursive(VisitedShapes &ioVisitedShapes) const
+{
+	// Get own stats
+	Stats stats = Shape::GetStatsRecursive(ioVisitedShapes);
+
+	// Add child stats
+	Stats child_stats = mInnerShape->GetStatsRecursive(ioVisitedShapes);
+	stats.mSizeBytes += child_stats.mSizeBytes;
+	stats.mNumTriangles += child_stats.mNumTriangles;
+
+	return stats;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/DecoratedShape.h

@@ -0,0 +1,80 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that constructs a DecoratedShape
+class JPH_EXPORT DecoratedShapeSettings : public ShapeSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, DecoratedShapeSettings)
+
+public:
+	/// Default constructor for deserialization
+									DecoratedShapeSettings() = default;
+
+	/// Constructor that decorates another shape
+	explicit						DecoratedShapeSettings(const ShapeSettings *inShape)	: mInnerShape(inShape) { }
+	explicit						DecoratedShapeSettings(const Shape *inShape)			: mInnerShapePtr(inShape) { }
+
+	RefConst<ShapeSettings>			mInnerShape;											///< Sub shape (either this or mShapePtr needs to be filled up)
+	RefConst<Shape>					mInnerShapePtr;											///< Sub shape (either this or mShape needs to be filled up)
+};
+
+/// Base class for shapes that decorate another shape with extra functionality (e.g. scale, translation etc.)
+class JPH_EXPORT DecoratedShape : public Shape
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	explicit						DecoratedShape(EShapeSubType inSubType) : Shape(EShapeType::Decorated, inSubType) { }
+									DecoratedShape(EShapeSubType inSubType, const Shape *inInnerShape) : Shape(EShapeType::Decorated, inSubType), mInnerShape(inInnerShape) { }
+									DecoratedShape(EShapeSubType inSubType, const DecoratedShapeSettings &inSettings, ShapeResult &outResult);
+
+	/// Access to the decorated inner shape
+	const Shape *					GetInnerShape() const									{ return mInnerShape; }
+
+	// See Shape::MustBeStatic
+	virtual bool					MustBeStatic() const override							{ return mInnerShape->MustBeStatic(); }
+
+	// See Shape::GetCenterOfMass
+	virtual Vec3					GetCenterOfMass() const override						{ return mInnerShape->GetCenterOfMass(); }
+
+	// See Shape::GetSubShapeIDBitsRecursive
+	virtual uint					GetSubShapeIDBitsRecursive() const override				{ return mInnerShape->GetSubShapeIDBitsRecursive(); }
+
+	// See Shape::GetLeafShape
+	virtual const Shape *			GetLeafShape(const SubShapeID &inSubShapeID, SubShapeID &outRemainder) const override { return mInnerShape->GetLeafShape(inSubShapeID, outRemainder); }
+
+	// See Shape::GetMaterial
+	virtual const PhysicsMaterial *	GetMaterial(const SubShapeID &inSubShapeID) const override;
+
+	// See Shape::GetSupportingFace
+	virtual void					GetSupportingFace(const SubShapeID &inSubShapeID, Vec3Arg inDirection, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform, SupportingFace &outVertices) const override;
+
+	// See Shape::GetSubShapeUserData
+	virtual uint64					GetSubShapeUserData(const SubShapeID &inSubShapeID) const override;
+
+	// See Shape
+	virtual void					SaveSubShapeState(ShapeList &outSubShapes) const override;
+	virtual void					RestoreSubShapeState(const ShapeRefC *inSubShapes, uint inNumShapes) override;
+
+	// See Shape::GetStatsRecursive
+	virtual Stats					GetStatsRecursive(VisitedShapes &ioVisitedShapes) const override;
+
+	// See Shape::IsValidScale
+	virtual bool					IsValidScale(Vec3Arg inScale) const override			{ return mInnerShape->IsValidScale(inScale); }
+
+	// See Shape::MakeScaleValid
+	virtual Vec3					MakeScaleValid(Vec3Arg inScale) const override			{ return mInnerShape->MakeScaleValid(inScale); }
+
+protected:
+	RefConst<Shape>					mInnerShape;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/EmptyShape.cpp

@@ -0,0 +1,64 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Collision/Shape/EmptyShape.h>
+#include <Jolt/Physics/Collision/CollisionDispatch.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+#ifdef JPH_DEBUG_RENDERER
+	#include <Jolt/Renderer/DebugRenderer.h>
+#endif // JPH_DEBUG_RENDERER
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(EmptyShapeSettings)
+{
+	JPH_ADD_BASE_CLASS(EmptyShapeSettings, ShapeSettings)
+
+	JPH_ADD_ATTRIBUTE(EmptyShapeSettings, mCenterOfMass)
+}
+
+ShapeSettings::ShapeResult EmptyShapeSettings::Create() const
+{
+	if (mCachedResult.IsEmpty())
+		Ref<Shape> shape = new EmptyShape(*this, mCachedResult);
+	return mCachedResult;
+}
+
+MassProperties EmptyShape::GetMassProperties() const
+{
+	MassProperties mass_properties;
+	mass_properties.mMass = 1.0f;
+	mass_properties.mInertia = Mat44::sIdentity();
+	return mass_properties;
+}
+
+#ifdef JPH_DEBUG_RENDERER
+void EmptyShape::Draw(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, Vec3Arg inScale, ColorArg inColor, [[maybe_unused]] bool inUseMaterialColors, [[maybe_unused]] bool inDrawWireframe) const
+{
+	inRenderer->DrawMarker(inCenterOfMassTransform.GetTranslation(), inColor, abs(inScale.GetX()) * 0.1f);
+}
+#endif // JPH_DEBUG_RENDERER
+
+void EmptyShape::sRegister()
+{
+	ShapeFunctions &f = ShapeFunctions::sGet(EShapeSubType::Empty);
+	f.mConstruct = []() -> Shape * { return new EmptyShape; };
+	f.mColor = Color::sBlack;
+
+	auto collide_empty = []([[maybe_unused]] const Shape *inShape1, [[maybe_unused]] const Shape *inShape2, [[maybe_unused]] Vec3Arg inScale1, [[maybe_unused]] Vec3Arg inScale2, [[maybe_unused]] Mat44Arg inCenterOfMassTransform1, [[maybe_unused]] Mat44Arg inCenterOfMassTransform2, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator1, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator2, [[maybe_unused]] const CollideShapeSettings &inCollideShapeSettings, [[maybe_unused]] CollideShapeCollector &ioCollector, [[maybe_unused]] const ShapeFilter &inShapeFilter) { /* Do Nothing */ };
+	auto cast_empty = []([[maybe_unused]] const ShapeCast &inShapeCast, [[maybe_unused]] const ShapeCastSettings &inShapeCastSettings, [[maybe_unused]] const Shape *inShape, [[maybe_unused]] Vec3Arg inScale, [[maybe_unused]] const ShapeFilter &inShapeFilter, [[maybe_unused]] Mat44Arg inCenterOfMassTransform2, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator1, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator2, [[maybe_unused]] CastShapeCollector &ioCollector) { /* Do nothing */ };
+
+	for (const EShapeSubType s : sAllSubShapeTypes)
+	{
+		CollisionDispatch::sRegisterCollideShape(EShapeSubType::Empty, s, collide_empty);
+		CollisionDispatch::sRegisterCollideShape(s, EShapeSubType::Empty, collide_empty);
+
+		CollisionDispatch::sRegisterCastShape(EShapeSubType::Empty, s, cast_empty);
+		CollisionDispatch::sRegisterCastShape(s, EShapeSubType::Empty, cast_empty);
+	}
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/EmptyShape.h

@@ -0,0 +1,75 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+#include <Jolt/Physics/Collision/PhysicsMaterial.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Class that constructs an EmptyShape
+class JPH_EXPORT EmptyShapeSettings final : public ShapeSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, EmptyShapeSettings)
+
+public:
+							EmptyShapeSettings() = default;
+	explicit				EmptyShapeSettings(Vec3Arg inCenterOfMass) : mCenterOfMass(inCenterOfMass) { }
+
+	ShapeResult				Create() const override;
+
+	Vec3					mCenterOfMass = Vec3::sZero();									///< Determines the center of mass for this shape
+};
+
+/// An empty shape that has no volume and collides with nothing.
+///
+/// Possible use cases:
+/// - As a placeholder for a shape that will be created later. E.g. if you first need to create a body and only then know what shape it will have.
+/// - If you need a kinematic body to attach a constraint to, but you don't want the body to collide with anything.
+///
+/// Note that, if possible, you should also put your body in an ObjectLayer that doesn't collide with anything.
+/// This ensures that collisions will be filtered out at broad phase level instead of at narrow phase level, this is more efficient.
+class JPH_EXPORT EmptyShape final : public Shape
+{
+public:
+	// Constructor
+							EmptyShape() : Shape(EShapeType::Empty, EShapeSubType::Empty) { }
+	explicit				EmptyShape(Vec3Arg inCenterOfMass) : Shape(EShapeType::Empty, EShapeSubType::Empty), mCenterOfMass(inCenterOfMass) { }
+							EmptyShape(const EmptyShapeSettings &inSettings, ShapeResult &outResult) : Shape(EShapeType::Empty, EShapeSubType::Empty, inSettings, outResult), mCenterOfMass(inSettings.mCenterOfMass) { outResult.Set(this); }
+
+	// See: Shape
+	Vec3					GetCenterOfMass() const override								{ return mCenterOfMass; }
+	AABox					GetLocalBounds() const override									{ return { Vec3::sZero(), Vec3::sZero() }; }
+	uint					GetSubShapeIDBitsRecursive() const override						{ return 0; }
+	float					GetInnerRadius() const override									{ return 0.0f; }
+	MassProperties			GetMassProperties() const override;
+	const PhysicsMaterial *	GetMaterial([[maybe_unused]] const SubShapeID &inSubShapeID) const override { return PhysicsMaterial::sDefault; }
+	virtual Vec3			GetSurfaceNormal(const SubShapeID &inSubShapeID, Vec3Arg inLocalSurfacePosition) const override { return Vec3::sZero(); }
+	virtual void			GetSubmergedVolume(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, const Plane &inSurface, float &outTotalVolume, float &outSubmergedVolume, Vec3 &outCenterOfBuoyancy
+#ifdef JPH_DEBUG_RENDERER // Not using JPH_IF_DEBUG_RENDERER for Doxygen
+		, RVec3Arg inBaseOffset
+#endif
+		) const override																	{ outTotalVolume = 0.0f; outSubmergedVolume = 0.0f; outCenterOfBuoyancy = Vec3::sZero(); }
+#ifdef JPH_DEBUG_RENDERER
+	virtual void			Draw([[maybe_unused]] DebugRenderer *inRenderer, [[maybe_unused]] RMat44Arg inCenterOfMassTransform, [[maybe_unused]] Vec3Arg inScale, [[maybe_unused]] ColorArg inColor, [[maybe_unused]] bool inUseMaterialColors, [[maybe_unused]] bool inDrawWireframe) const override;
+#endif // JPH_DEBUG_RENDERER
+	virtual bool			CastRay([[maybe_unused]] const RayCast &inRay, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator, [[maybe_unused]] RayCastResult &ioHit) const override { return false; }
+	virtual void			CastRay([[maybe_unused]] const RayCast &inRay, [[maybe_unused]] const RayCastSettings &inRayCastSettings, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator, [[maybe_unused]] CastRayCollector &ioCollector, [[maybe_unused]] const ShapeFilter &inShapeFilter = { }) const override { /* Do nothing */ }
+	virtual void			CollidePoint([[maybe_unused]] Vec3Arg inPoint, [[maybe_unused]] const SubShapeIDCreator &inSubShapeIDCreator, [[maybe_unused]] CollidePointCollector &ioCollector, [[maybe_unused]] const ShapeFilter &inShapeFilter = { }) const override { /* Do nothing */ }
+	virtual void			CollideSoftBodyVertices([[maybe_unused]] Mat44Arg inCenterOfMassTransform, [[maybe_unused]] Vec3Arg inScale, [[maybe_unused]] const CollideSoftBodyVertexIterator &inVertices, [[maybe_unused]] uint inNumVertices, [[maybe_unused]] int inCollidingShapeIndex) const override { /* Do nothing */ }
+	virtual void			GetTrianglesStart([[maybe_unused]] GetTrianglesContext &ioContext, [[maybe_unused]] const AABox &inBox, [[maybe_unused]] Vec3Arg inPositionCOM, [[maybe_unused]] QuatArg inRotation, [[maybe_unused]] Vec3Arg inScale) const override { /* Do nothing */ }
+	virtual int				GetTrianglesNext([[maybe_unused]] GetTrianglesContext &ioContext, [[maybe_unused]] int inMaxTrianglesRequested, [[maybe_unused]] Float3 *outTriangleVertices, [[maybe_unused]] const PhysicsMaterial **outMaterials = nullptr) const override { return 0; }
+	Stats					GetStats() const override										{ return { sizeof(*this), 0 }; }
+	float					GetVolume() const override										{ return 0.0f; }
+	bool					IsValidScale([[maybe_unused]] Vec3Arg inScale) const override	{ return true; }
+
+	// Register shape functions with the registry
+	static void				sRegister();
+
+private:
+	Vec3					mCenterOfMass = Vec3::sZero();
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/GetTrianglesContext.h

@@ -0,0 +1,248 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+
+JPH_NAMESPACE_BEGIN
+
+class PhysicsMaterial;
+
+/// Implementation of GetTrianglesStart/Next that uses a fixed list of vertices for the triangles. These are transformed into world space when getting the triangles.
+class GetTrianglesContextVertexList
+{
+public:
+	/// Constructor, to be called in GetTrianglesStart
+					GetTrianglesContextVertexList(Vec3Arg inPositionCOM, QuatArg inRotation, Vec3Arg inScale, Mat44Arg inLocalTransform, const Vec3 *inTriangleVertices, size_t inNumTriangleVertices, const PhysicsMaterial *inMaterial) :
+		mLocalToWorld(Mat44::sRotationTranslation(inRotation, inPositionCOM) * Mat44::sScale(inScale) * inLocalTransform),
+		mTriangleVertices(inTriangleVertices),
+		mNumTriangleVertices(inNumTriangleVertices),
+		mMaterial(inMaterial),
+		mIsInsideOut(ScaleHelpers::IsInsideOut(inScale))
+	{
+		static_assert(sizeof(GetTrianglesContextVertexList) <= sizeof(Shape::GetTrianglesContext), "GetTrianglesContext too small");
+		JPH_ASSERT(IsAligned(this, alignof(GetTrianglesContextVertexList)));
+		JPH_ASSERT(inNumTriangleVertices % 3 == 0);
+	}
+
+	/// @see Shape::GetTrianglesNext
+	int				GetTrianglesNext(int inMaxTrianglesRequested, Float3 *outTriangleVertices, const PhysicsMaterial **outMaterials)
+	{
+		JPH_ASSERT(inMaxTrianglesRequested >= Shape::cGetTrianglesMinTrianglesRequested);
+
+		int total_num_vertices = min(inMaxTrianglesRequested * 3, int(mNumTriangleVertices - mCurrentVertex));
+
+		if (mIsInsideOut)
+		{
+			// Store triangles flipped
+			for (const Vec3 *v = mTriangleVertices + mCurrentVertex, *v_end = v + total_num_vertices; v < v_end; v += 3)
+			{
+				(mLocalToWorld * v[0]).StoreFloat3(outTriangleVertices++);
+				(mLocalToWorld * v[2]).StoreFloat3(outTriangleVertices++);
+				(mLocalToWorld * v[1]).StoreFloat3(outTriangleVertices++);
+			}
+		}
+		else
+		{
+			// Store triangles
+			for (const Vec3 *v = mTriangleVertices + mCurrentVertex, *v_end = v + total_num_vertices; v < v_end; v += 3)
+			{
+				(mLocalToWorld * v[0]).StoreFloat3(outTriangleVertices++);
+				(mLocalToWorld * v[1]).StoreFloat3(outTriangleVertices++);
+				(mLocalToWorld * v[2]).StoreFloat3(outTriangleVertices++);
+			}
+		}
+
+		// Update the current vertex to point to the next vertex to get
+		mCurrentVertex += total_num_vertices;
+		int total_num_triangles = total_num_vertices / 3;
+
+		// Store materials
+		if (outMaterials != nullptr)
+			for (const PhysicsMaterial **m = outMaterials, **m_end = outMaterials + total_num_triangles; m < m_end; ++m)
+				*m = mMaterial;
+
+		return total_num_triangles;
+	}
+
+	/// Helper function that creates a vertex list of a half unit sphere (top part)
+	template <class A>
+	static void		sCreateHalfUnitSphereTop(A &ioVertices, int inDetailLevel)
+	{
+		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisX(),  Vec3::sAxisY(),  Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisY(), -Vec3::sAxisX(),  Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisY(),  Vec3::sAxisX(), -Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisX(),  Vec3::sAxisY(), -Vec3::sAxisZ(), inDetailLevel);
+	}
+
+	/// Helper function that creates a vertex list of a half unit sphere (bottom part)
+	template <class A>
+	static void		sCreateHalfUnitSphereBottom(A &ioVertices, int inDetailLevel)
+	{
+		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisX(), -Vec3::sAxisY(),  Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisY(),  Vec3::sAxisX(),  Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisX(), -Vec3::sAxisY(), -Vec3::sAxisZ(), inDetailLevel);
+		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisY(), -Vec3::sAxisX(), -Vec3::sAxisZ(), inDetailLevel);
+	}
+
+	/// Helper function that creates an open cylinder of half height 1 and radius 1
+	template <class A>
+	static void		sCreateUnitOpenCylinder(A &ioVertices, int inDetailLevel)
+	{
+		const Vec3 bottom_offset(0.0f, -2.0f, 0.0f);
+		int num_verts = 4 * (1 << inDetailLevel);
+		for (int i = 0; i < num_verts; ++i)
+		{
+			float angle1 = 2.0f * JPH_PI * (float(i) / num_verts);
+			float angle2 = 2.0f * JPH_PI * (float(i + 1) / num_verts);
+
+			Vec3 t1(Sin(angle1), 1.0f, Cos(angle1));
+			Vec3 t2(Sin(angle2), 1.0f, Cos(angle2));
+			Vec3 b1 = t1 + bottom_offset;
+			Vec3 b2 = t2 + bottom_offset;
+
+			ioVertices.push_back(t1);
+			ioVertices.push_back(b1);
+			ioVertices.push_back(t2);
+
+			ioVertices.push_back(t2);
+			ioVertices.push_back(b1);
+			ioVertices.push_back(b2);
+		}
+	}
+
+private:
+	/// Recursive helper function for creating a sphere
+	template <class A>
+	static void		sCreateUnitSphereHelper(A &ioVertices, Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, int inLevel)
+	{
+		Vec3 center1 = (inV1 + inV2).Normalized();
+		Vec3 center2 = (inV2 + inV3).Normalized();
+		Vec3 center3 = (inV3 + inV1).Normalized();
+
+		if (inLevel > 0)
+		{
+			int new_level = inLevel - 1;
+			sCreateUnitSphereHelper(ioVertices, inV1, center1, center3, new_level);
+			sCreateUnitSphereHelper(ioVertices, center1, center2, center3, new_level);
+			sCreateUnitSphereHelper(ioVertices, center1, inV2, center2, new_level);
+			sCreateUnitSphereHelper(ioVertices, center3, center2, inV3, new_level);
+		}
+		else
+		{
+			ioVertices.push_back(inV1);
+			ioVertices.push_back(inV2);
+			ioVertices.push_back(inV3);
+		}
+	}
+
+	Mat44					mLocalToWorld;
+	const Vec3 *			mTriangleVertices;
+	size_t					mNumTriangleVertices;
+	size_t					mCurrentVertex = 0;
+	const PhysicsMaterial *	mMaterial;
+	bool					mIsInsideOut;
+};
+
+/// Implementation of GetTrianglesStart/Next that uses a multiple fixed lists of vertices for the triangles. These are transformed into world space when getting the triangles.
+class GetTrianglesContextMultiVertexList
+{
+public:
+	/// Constructor, to be called in GetTrianglesStart
+					GetTrianglesContextMultiVertexList(bool inIsInsideOut, const PhysicsMaterial *inMaterial) :
+		mMaterial(inMaterial),
+		mIsInsideOut(inIsInsideOut)
+	{
+		static_assert(sizeof(GetTrianglesContextMultiVertexList) <= sizeof(Shape::GetTrianglesContext), "GetTrianglesContext too small");
+		JPH_ASSERT(IsAligned(this, alignof(GetTrianglesContextMultiVertexList)));
+	}
+
+	/// Add a mesh part and its transform
+	void			AddPart(Mat44Arg inLocalToWorld, const Vec3 *inTriangleVertices, size_t inNumTriangleVertices)
+	{
+		JPH_ASSERT(inNumTriangleVertices % 3 == 0);
+
+		mParts.push_back({ inLocalToWorld, inTriangleVertices, inNumTriangleVertices });
+	}
+
+	/// @see Shape::GetTrianglesNext
+	int				GetTrianglesNext(int inMaxTrianglesRequested, Float3 *outTriangleVertices, const PhysicsMaterial **outMaterials)
+	{
+		JPH_ASSERT(inMaxTrianglesRequested >= Shape::cGetTrianglesMinTrianglesRequested);
+
+		int total_num_vertices = 0;
+		int max_vertices_requested = inMaxTrianglesRequested * 3;
+
+		// Loop over parts
+		for (; mCurrentPart < mParts.size(); ++mCurrentPart)
+		{
+			const Part &part = mParts[mCurrentPart];
+
+			// Calculate how many vertices to take from this part
+			int part_num_vertices = min(max_vertices_requested, int(part.mNumTriangleVertices - mCurrentVertex));
+			if (part_num_vertices == 0)
+				break;
+
+			max_vertices_requested -= part_num_vertices;
+			total_num_vertices += part_num_vertices;
+
+			if (mIsInsideOut)
+			{
+				// Store triangles flipped
+				for (const Vec3 *v = part.mTriangleVertices + mCurrentVertex, *v_end = v + part_num_vertices; v < v_end; v += 3)
+				{
+					(part.mLocalToWorld * v[0]).StoreFloat3(outTriangleVertices++);
+					(part.mLocalToWorld * v[2]).StoreFloat3(outTriangleVertices++);
+					(part.mLocalToWorld * v[1]).StoreFloat3(outTriangleVertices++);
+				}
+			}
+			else
+			{
+				// Store triangles
+				for (const Vec3 *v = part.mTriangleVertices + mCurrentVertex, *v_end = v + part_num_vertices; v < v_end; v += 3)
+				{
+					(part.mLocalToWorld * v[0]).StoreFloat3(outTriangleVertices++);
+					(part.mLocalToWorld * v[1]).StoreFloat3(outTriangleVertices++);
+					(part.mLocalToWorld * v[2]).StoreFloat3(outTriangleVertices++);
+				}
+			}
+
+			// Update the current vertex to point to the next vertex to get
+			mCurrentVertex += part_num_vertices;
+
+			// Check if we completed this part
+			if (mCurrentVertex < part.mNumTriangleVertices)
+				break;
+
+			// Reset current vertex for the next part
+			mCurrentVertex = 0;
+		}
+
+		int total_num_triangles = total_num_vertices / 3;
+
+		// Store materials
+		if (outMaterials != nullptr)
+			for (const PhysicsMaterial **m = outMaterials, **m_end = outMaterials + total_num_triangles; m < m_end; ++m)
+				*m = mMaterial;
+
+		return total_num_triangles;
+	}
+
+private:
+	struct Part
+	{
+		Mat44				mLocalToWorld;
+		const Vec3 *		mTriangleVertices;
+		size_t				mNumTriangleVertices;
+	};
+
+	StaticArray<Part, 3>	mParts;
+	uint					mCurrentPart = 0;
+	size_t					mCurrentVertex = 0;
+	const PhysicsMaterial *	mMaterial;
+	bool					mIsInsideOut;
+};
+
+JPH_NAMESPACE_END