How is the world space radius of a sphere collider / capsule collider calculated?

Unity Engine
1

I can’t find a reference on this - how is the “world space” sphere collider radius determined based on the scaling aspect of the object (and its parents)?

I’d guess the “correct” approach would be to calculate the SVD of the local to world matrix, and take the maximum from the diagonal matrix. But that doesn’t seem to be happening, as the attached example shows - you can replicate it by (all in x,y,z order as in the editor, using a standard sphere primitive):

Parent game object:
position (0, 0 ,0 ), rotation (0, 0, 0), scale (1, 1, 3),
Child sphere object:
position (0, 5 ,5 ), rotation (45, 0, 0), scale (1, 2, 1).

After some testing it seems like maybe the radius is just determined by taking the maximum of the lengths of the first 3 columns of the local to world matrix, but I’d appreciate a confirmation on this.

7573048--937951--tst.jpg

2

Without checking in detail, you’re probably right. It would be nice if the colliders also got distorted to match the uneven scale or skew that you have applied to the object, but I completely understand why they didn’t do that. It’s a LOT heavier computation to compute each possible intersection of primitives (ray vs sphere, sphere vs capsule, capsule vs box, etc.) if those primitives can be arbitrarily scaled with independent axes.

3

That’s not exactly what I meant - I don’t have an issue with the collider not being flattened, what I “mind” is that the mesh goes outside the sphere collider. I would expect the sphere’s radius would be adjusted in such a way, so that the mesh fits inside it, i.e. the sphere acting as a “bounding sphere”. But that’s not what happens.

I don’t really care what happens, this is fine too, but I’m working on an asset where I need to replicate the shape of the collider, so I would like to know how the radius is decided.

The “reasonable” method, of adjusting the sphere radius, so that the mesh fits inside it would be done using an SVD decomposition, and I’d know how to do that, but I don’t know how the radius is determined in Unity. Might just be maximum of length of columns of the local to world matrix like I mentioned, but I don’t know.

4

I’m not a 3D physics dev but here’s a pseudo-cope snippet from the SphereCollider native code. This is passed directly into the PhysX geometry (physx: PxSphereGeometry sSphere) radius:

float SphereCollider::GetScaledRadius() const
{
    Vector3f scale = GetComponent<Transform>().GetWorldScaleLossy();
    float absoluteRadius = Abs(std::max(std::max(Abs(scale.x), Abs(scale.y)), Abs(scale.z)) * m_Radius);
    return std::max(absoluteRadius, 0.00001F);
}

I’m sure you can do the translation from above into C#. The scale though is Transform.lossyScale.

5

Thanks a ton, yes it seems it uses lossyScale. Could I please ask for similar pseudo-code for capsule and box?

6

Box is the same where the box size is scaled by the lossy scale and Abs used to give a positive size.

Capsule is more complex. Rough code is:

{
    const float kMinSize = 0.00001F;

    const Vector3f scale = Vector3f scale = GetComponent<Transform>().GetWorldScaleLossy();

    // m_Direction is enum { X-Axis = 0, Y-Axis = 1, Z-Axis = 2 }
    const float absoluteHeight = std::max(Abs(m_Height * scale[m_Direction]), kMinSize);
    const float scale1 = scale[(m_Direction + 1) % 3];
    const float scale2 = scale[(m_Direction + 2) % 3];
    const float absoluteRadius = std::max(Abs(scale1), Abs(scale2)) * m_Radius;

    float height = absoluteHeight - absoluteRadius * 2.0F;
    height = std::max(height, kMinSize);
    float radius = std::max(absoluteRadius, kMinSize);

    Vector2f extents = Vector2f(radius, height);
    PxCapsuleGeometry sCapsule(extents.x, extents.y * 0.5f);
}

NOTE: The code above isn’t a copy of the code, it’s an approximation of it but it’s essentially correct.

7

Thanks a ton, you’ve saved me loads of time, I’ve tested it and everything works fine.

1 Like