Create ConvexHullShape from previously baked data

[garlfin]

Other than deserializing/serializing an already created ConvexHullShape, is there a way to save the baked data? I couldn't find anything I just ended up writing a custom constructor for it.

[jrouwe]

SaveBinaryState / sRestoreFromBinaryState is indeed the only way to save the baked data.

[garlfin]

Is there any reason for that design choice? It seems a bit weird to force use of the StreamIn and StreamOut classes.

[jrouwe]

I don't want to expose the internal structure of the shape so that I can freely change it if needed. The StreamIn/Out class is nothing more than a way to generate a byte stream. What does your custom constructor look like?

[garlfin]

No error checking cause I'm lazy. BakedConvexHullShapeSettings has the same fields as ConvexHullShape and basically has the same constructor too.

class JPH_EXPORT BakedConvexHullShapeSettings final : public ConvexShapeSettings
{
	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, BakedConvexHullShapeSettings)

public:
	enum class EResult
	{
		Success,											///< Hull building finished successfully
		MaxVerticesReached,									///< Hull building finished successfully, but the desired accuracy was not reached because the max vertices limit was reached
		TooFewPoints,										///< Too few points to create a hull
		TooFewFaces,										///< Too few faces in the created hull (signifies precision errors during building)
		Degenerate,											///< Degenerate hull detected
		InvalidRadius,										///< Radius !<= 0
		ExceededTolerance,									///< Any point is >mHullTolerance units outside of the hull
		TooManyPoints,										///< mPoints.size() > ConvexHullShape::cMaxPointsInHull 
	};

	BakedConvexHullShapeSettings() = default;
	BakedConvexHullShapeSettings(const ConvexHullShapeSettings& inSettings, EResult& outResult);

	Vec3					mCenterOfMass;  ///< Center of mass of this convex hull
	Mat44					mInertia;   ///< Inertia matrix assuming density is 1 (needs to be multiplied by density)
	AABox					mLocalBounds;   ///< Local bounding box for the convex hull
	Array<ConvexHullPoint>	mPoints;    ///< Points on the convex hull surface
	Array<ConvexHullFace>	mFaces; ///< Faces of the convex hull surface
	Array<Plane>			mPlanes;    ///< Planes for the faces (1-on-1 with mFaces array, separate because they need to be 16 byte aligned)
	Array<uint8>			mVertexIdx; ///< A list of vertex indices (indexing in mPoints) for each of the faces
	float					mConvexRadius = 0.0f;   ///< Convex radius
	float					mVolume;    ///< Total volume of the convex hull
	float					mInnerRadius = FLT_MAX; ///< Radius of the biggest sphere that fits entirely in the convex hull

	virtual ShapeResult		Create() const override;
};

ConvexHullShape::ConvexHullShape(const ConvexHullShapeSettings &inSettings, ShapeResult &outResult) :
	ConvexShape(EShapeSubType::ConvexHull, inSettings, outResult)
{
	BakedConvexHullShapeSettings::EResult result;
	BakedConvexHullShapeSettings bakedSettings(inSettings, result);

	mCenterOfMass = bakedSettings.mCenterOfMass;
	mInertia = bakedSettings.mInertia;
	mLocalBounds = bakedSettings.mLocalBounds;
	mPoints = bakedSettings.mPoints;
	mFaces = std::move(bakedSettings.mFaces);
	mPlanes = std::move(bakedSettings.mPlanes);
	mVertexIdx = std::move(bakedSettings.mVertexIdx);
	mConvexRadius = bakedSettings.mConvexRadius;
	mVolume = bakedSettings.mVolume;
	mInnerRadius = bakedSettings.mInnerRadius;
	
	outResult.Set(this);
}

ConvexHullShape::ConvexHullShape(const BakedConvexHullShapeSettings& inSettings, ShapeResult& outResult) :
	ConvexShape(EShapeSubType::ConvexHull, nullptr)
{
	mCenterOfMass = inSettings.mCenterOfMass;
	mInertia = inSettings.mInertia;
	mLocalBounds = inSettings.mLocalBounds;
	mPoints = inSettings.mPoints;
	mFaces = inSettings.mFaces;
	mPlanes = inSettings.mPlanes;
	mVertexIdx = inSettings.mVertexIdx;
	mConvexRadius = inSettings.mConvexRadius;
	mVolume = inSettings.mVolume;
	mInnerRadius = inSettings.mInnerRadius;

	outResult.Set(this);
}

[garlfin]

Instead of storing the actual data, it could store some form of intermediary format that would be fast/easy enough to translate into the final form; rather than the somewhat intensive process of generating the hull from scratch. I'd also consider making an internal structure instead of just copy and pasting the members.

[jrouwe]

And what do you do with BakedConvexHullShapeSettings? This doesn't look like something that can be stored to disc, and I don't really see the point of temporarily storing all the members of a ConvexHullShape in another data structure unless you want to load them later.

In any case, this is not an API that I would want to support. I think the StreamIn/Out classes should be fast enough to save the baked data.

[garlfin]

I just use it to interact with my own engine, its methods, classes, etc. I have my own serialization functions that I would prefer to use.

[jrouwe]

I would suggest to create a StreamIn/Out class that just stores the data in an array of bytes (std::vector<uint8_t> or something similar) and then to use your own serialization functions to store that array.

[garlfin]

That sounds like a much more elegant solution