LegacyJointUtility.cs

using System.Runtime.CompilerServices;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using UnityEngine;
using FloatRange = Unity.Physics.Math.FloatRange;
using LegacyCharacter = UnityEngine.CharacterJoint;
using LegacyConfigurable = UnityEngine.ConfigurableJoint;
using LegacyFixed = UnityEngine.FixedJoint;
using LegacyHinge = UnityEngine.HingeJoint;
using LegacyJoint = UnityEngine.Joint;
using LegacySpring = UnityEngine.SpringJoint;
// ReSharper disable Unity.InefficientPropertyAccess

namespace Modules.PhysicsConversion
{

    /// <summary> This class is based on LegacyJointConversionSystem(UnityPhysicsPackageFolder\Unity.Physics.Hybrid\Conversion\LegacyJointConversionSystem)
    /// and just reconfigured for manual conversion. Basically to get around Inject's limiations. </summary>
    public static class LegacyJointUtility
    {
        public static World DefaultWorld => World.DefaultGameObjectInjectionWorld;
        static Entity CreateJointEntity(GameObjectConversionSystem system, GameObject primaryGameObject, GameObject gameObject, PhysicsJoint joint, Entity entityA, Entity entityB, bool enableCollision = false)
        {

            var entityManager = system.DstEntityManager;
            Entity jointEntity = system.CreateAdditionalEntity(primaryGameObject);

            entityManager.AddComponentData(jointEntity, new PhysicsConstrainedBodyPair(entityA, entityB, enableCollision));
            entityManager.AddComponentData(jointEntity, joint);
            
#if UNITY_EDITOR
            var nameEntityA = system.DstEntityManager.GetName(entityA);
            var nameEntityB = entityB == Entity.Null ? "PhysicsWorld" : system.DstEntityManager.GetName(entityB);
            system.DstEntityManager.SetName(jointEntity, $"Joint {nameEntityA} + {nameEntityB}");
#endif
            
            return jointEntity;
        }
        
        
        private static void AddOrSetComponent<T>(GameObjectConversionSystem system, Entity entity, T value)
            where T : struct, IComponentData
        {
            if (!system.DstEntityManager.HasComponent<T>(entity))
                system.DstEntityManager.AddComponentData(entity, value);
            else if (!TypeManager.IsZeroSized(TypeManager.GetTypeIndex<T>()))
                system.DstEntityManager.SetComponentData(entity, value);
        }


        static PhysicsJoint CreateConfigurableJoint(
            GameObjectConversionSystem system, Entity connectedEntity,
            quaternion jointFrameOrientation,
            LegacyJoint joint, bool3 linearLocks, bool3 linearLimited, SoftJointLimit linearLimit, SoftJointLimitSpring linearSpring, bool3 angularFree, bool3 angularLocks,
            bool3 angularLimited, SoftJointLimit lowAngularXLimit, SoftJointLimit highAngularXLimit, SoftJointLimitSpring angularXLimitSpring, SoftJointLimit angularYLimit,
            SoftJointLimit angularZLimit, SoftJointLimitSpring angularYZLimitSpring)
        {
            //var constraints = new NativeList<Constraint>(Allocator.Temp);
            var constraints = new FixedList128<Constraint>();

            // TODO: investigate mapping PhysX spring and damping to Unity Physics SpringFrequency and SpringDamping
            var springFrequency = Constraint.DefaultSpringFrequency;
            var springDamping = Constraint.DefaultSpringDamping;
            
            if (angularLimited[0])
            {
                constraints.Add(Constraint.Twist(0, math.radians(new FloatRange(-highAngularXLimit.limit, -lowAngularXLimit.limit)), springFrequency, springDamping));
            }

            if (angularLimited[1])
            {
                constraints.Add(Constraint.Twist(1, math.radians(new FloatRange(-angularYLimit.limit, angularYLimit.limit)), springFrequency, springDamping));
            }

            if (angularLimited[2])
            {
                constraints.Add(Constraint.Twist(2, math.radians(new FloatRange(-angularZLimit.limit, angularZLimit.limit)), springFrequency, springDamping));
            }

            if (math.any(linearLimited))
            {
                var distanceRange = new FloatRange(-linearLimit.limit, linearLimit.limit).Sorted();
                constraints.Add(new Constraint
                {
                    ConstrainedAxes = linearLimited,
                    Type            = ConstraintType.Linear,
                    Min             = math.csum((int3)linearLimited) == 1 ? distanceRange.Min : 0f,
                    Max             = distanceRange.Max,
                    SpringFrequency = springFrequency,
                    SpringDamping   = springDamping
                });
            }

            if (math.any(linearLocks))
            {
                constraints.Add(new Constraint
                {
                    ConstrainedAxes = linearLocks,
                    Type = ConstraintType.Linear,
                    Min = 0,
                    Max = 0,
                    SpringFrequency = springFrequency,
                    SpringDamping = springDamping
                });
            }

            if (math.any(angularLocks))
            {
                constraints.Add(new Constraint
                {
                    ConstrainedAxes = angularLocks,
                    Type = ConstraintType.Angular,
                    Min = 0,
                    Max = 0,
                    SpringFrequency = springFrequency,
                    SpringDamping = springDamping
                });
            }

            RigidTransform worldFromBodyA = Math.DecomposeRigidBodyTransform(joint.transform.localToWorldMatrix);
            RigidTransform worldFromBodyB = joint.connectedBody == null 
                ? RigidTransform.identity 
                : Math.DecomposeRigidBodyTransform(joint.connectedBody.transform.localToWorldMatrix);

            var legacyWorldFromJointA = math.mul(
                new RigidTransform(joint.transform.rotation, joint.transform.position), 
                new RigidTransform(jointFrameOrientation, joint.anchor)
            );
            var bodyAFromJoint = new BodyFrame(math.mul(math.inverse(worldFromBodyA), legacyWorldFromJointA));
            
            //var connectedEntity = system.GetPrimaryEntity(joint.connectedBody);
            var isConnectedBodyConverted = joint.connectedBody == null || connectedEntity != Entity.Null;
           
            RigidTransform bFromA = isConnectedBodyConverted ? math.mul(math.inverse(worldFromBodyB), worldFromBodyA) : worldFromBodyA;
            RigidTransform bFromBSource = isConnectedBodyConverted ? RigidTransform.identity : worldFromBodyB;

            var bodyBFromJoint = new BodyFrame
            {
                Axis = math.mul(bFromA.rot, bodyAFromJoint.Axis),
                PerpendicularAxis = math.mul(bFromA.rot, bodyAFromJoint.PerpendicularAxis),
                Position = math.mul(bFromBSource, new float4(joint.connectedAnchor, 1f)).xyz
            };
            
            // deprecated
            //var jointData =  JointData.Create(bodyAFromJoint, bodyBFromJoint, constraints);
            //constraints.Dispose();
            //return jointData;
            var jointData = new PhysicsJoint
            {
                BodyAFromJoint = bodyAFromJoint,
                BodyBFromJoint = bodyBFromJoint
            };
            jointData.SetConstraints(constraints);
            return jointData;
            
        }

        static bool IsMotionFree(ConfigurableJointMotion motion)
        {
            return motion == ConfigurableJointMotion.Free;
        }

        static bool IsMotionLocked(ConfigurableJointMotion motion)
        {
            return motion == ConfigurableJointMotion.Locked;
        }

        static bool IsMotionLimited(ConfigurableJointMotion motion)
        {
            return motion == ConfigurableJointMotion.Limited;
        }
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static quaternion GetJointFrameOrientation(float3 axis, float3 secondaryAxis) =>
            new BodyFrame { Axis = axis, PerpendicularAxis = secondaryAxis }.AsRigidTransform().rot;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static BodyFrame GetFrame(float3 axis, float3 secondaryAxis)
        {
            return new BodyFrame
            {
                Axis = axis, PerpendicularAxis = secondaryAxis
            };
        }
        
        

        public static void ConvertCharacterJoint(
            GameObjectConversionSystem system, 
            GameObject primaryGameObject, 
            LegacyCharacter joint, 
            Entity jointEntity, 
            Entity connectedEntity)
        {
            var linearLocks = new bool3(true);
            var linearLimited = new bool3(false);
            
            var angularFree = new bool3(false);
            var angularLocks = new bool3(false);
            var angularLimited = new bool3(true);
            
            var jointFrameOrientation = GetJointFrameOrientation(joint.axis, joint.swingAxis);
            
            var jointData = CreateConfigurableJoint(system, connectedEntity, jointFrameOrientation, joint, linearLocks, linearLimited, new SoftJointLimit { limit = 0f, bounciness = 0f }, new SoftJointLimitSpring { spring = 0f, damper = 0f }, angularFree, angularLocks, angularLimited,
                joint.lowTwistLimit, joint.highTwistLimit, joint.twistLimitSpring, joint.swing1Limit, joint.swing2Limit, joint.swingLimitSpring);
  
            CreateJointEntity(system, primaryGameObject, joint.gameObject, jointData, jointEntity, joint.connectedBody == null ? Entity.Null : connectedEntity, joint.enableCollision);
        }

        /*public static void ConvertSpringJoint(GameObjectConversionSystem system, LegacySpring joint)
        {
            var constraints = new NativeList<Constraint>(Allocator.Temp);
            constraints.Add(new Constraint {
                ConstrainedAxes = new bool3(true),
                Type = ConstraintType.Linear,
                Min = joint.minDistance,
                Max = joint.maxDistance,
                SpringFrequency = 1f, // ?
                SpringDamping = 0.1f // ?
            });

            var jointFrameA = BodyFrame.Identity;
            jointFrameA.Position = joint.anchor;

            var connectedEntity = system.GetPrimaryEntity(joint.connectedBody);
            
            var isConnectedBodyConverted =
                joint.connectedBody == null || connectedEntity != Entity.Null;

            RigidTransform bFromBSource =
                isConnectedBodyConverted ? RigidTransform.identity : Math.DecomposeRigidBodyTransform(joint.connectedBody.transform.localToWorldMatrix);

            var jointFrameB = BodyFrame.Identity;
            jointFrameB.Position = math.mul(bFromBSource, new float4(joint.connectedAnchor, 1f)).xyz;

            var jointData = JointData.Create(jointFrameA, jointFrameB, constraints);

            //CreateJointEntity(system, joint.gameObject, jointData, system.GetPrimaryEntity(joint.gameObject), joint.connectedBody == null ? Entity.Null : connectedEntity, joint.enableCollision);
            constraints.Dispose();
        }

        public static void ConvertFixedJoint(GameObjectConversionSystem system, LegacyFixed joint)
        {
            var legacyWorldFromJointA = math.mul(
                new RigidTransform(joint.transform.rotation, joint.transform.position),
                new RigidTransform(quaternion.identity, joint.anchor)
            );

            RigidTransform worldFromBodyA = Math.DecomposeRigidBodyTransform(joint.transform.localToWorldMatrix);
            var connectedEntity = system.GetPrimaryEntity(joint.connectedBody);
            RigidTransform worldFromBodyB = connectedEntity == Entity.Null
                ? RigidTransform.identity
                : Math.DecomposeRigidBodyTransform(joint.connectedBody.transform.localToWorldMatrix);

            var bodyAFromJoint = new BodyFrame(math.mul(math.inverse(worldFromBodyA), legacyWorldFromJointA));
            var bodyBFromJoint = new BodyFrame(math.mul(math.inverse(worldFromBodyB), legacyWorldFromJointA));

            var jointData = JointData.CreateFixed(bodyAFromJoint, bodyBFromJoint);

            //CreateJointEntity(system, joint.gameObject, jointData, system.GetPrimaryEntity(joint.gameObject), joint.connectedBody == null ? Entity.Null : connectedEntity, joint.enableCollision);
        }

        public static void ConvertHingeJoint(GameObjectConversionSystem system, GameObject primaryGameObject, HingeJoint joint, Entity jointEntity, Entity connectedEntity)
        {
            RigidTransform worldFromBodyA = Math.DecomposeRigidBodyTransform(joint.transform.localToWorldMatrix);
            RigidTransform worldFromBodyB = joint.connectedBody == null
                ? RigidTransform.identity
                : Math.DecomposeRigidBodyTransform(joint.connectedBody.transform.localToWorldMatrix);

            Math.CalculatePerpendicularNormalized(joint.axis, out float3 perpendicularA, out _);
            var bodyAFromJoint = new BodyFrame
            {
                Axis = joint.axis,
                PerpendicularAxis = perpendicularA,
                Position = joint.anchor
            };

            //var connectedEntity = system.GetPrimaryEntity(joint.connectedBody);
            var isConnectedBodyConverted = joint.connectedBody == null || connectedEntity != Entity.Null;
           
            RigidTransform bFromA = isConnectedBodyConverted ? math.mul(math.inverse(worldFromBodyB), worldFromBodyA) : worldFromBodyA;
            RigidTransform bFromBSource =
                isConnectedBodyConverted ? RigidTransform.identity : worldFromBodyB;

            var bodyBFromJoint = new BodyFrame
            {
                Axis = math.mul(bFromA.rot, joint.axis),
                PerpendicularAxis = math.mul(bFromA.rot, perpendicularA),
                Position = math.mul(bFromBSource, new float4(joint.connectedAnchor, 1f)).xyz
            };

            var limits = math.radians(new FloatRange(joint.limits.min, joint.limits.max));
            var jointData = joint.useLimits
                ? JointData.CreateLimitedHinge(bodyAFromJoint, bodyBFromJoint, limits)
                : JointData.CreateHinge(bodyAFromJoint, bodyBFromJoint);

            CreateJointEntity(system, primaryGameObject, joint.gameObject, jointData, jointEntity, joint.connectedBody == null ? Entity.Null : connectedEntity, joint.enableCollision);
        }

       
        public static void ConvertConfigurableJoint(GameObjectConversionSystem system, LegacyConfigurable joint)
        {
            var linearLocks = new bool3
            (
                IsMotionLocked(joint.xMotion),
                IsMotionLocked(joint.yMotion),
                IsMotionLocked(joint.zMotion)
            );

            var linearLimited = new bool3
            (
                IsMotionLimited(joint.xMotion),
                IsMotionLimited(joint.yMotion),
                IsMotionLimited(joint.zMotion)
            );
           
            var angularFree = new bool3
            (
                IsMotionFree(joint.angularXMotion),
                IsMotionFree(joint.angularYMotion),
                IsMotionFree(joint.angularZMotion)
            );

            var angularLocks = new bool3
            (
                IsMotionLocked(joint.angularXMotion),
                IsMotionLocked(joint.angularYMotion),
                IsMotionLocked(joint.angularZMotion)
            );

            var angularLimited = new bool3
            (
                IsMotionLimited(joint.angularXMotion),
                IsMotionLimited(joint.angularYMotion),
                IsMotionLimited(joint.angularZMotion)
            );

            var jointFrameOrientation = GetJointFrameOrientation(joint.axis, joint.secondaryAxis);
            var jointData = CreateConfigurableJoint(system, jointFrameOrientation, joint, linearLocks, linearLimited, joint.linearLimit, joint.linearLimitSpring, angularFree, angularLocks, angularLimited,
                joint.lowAngularXLimit, joint.highAngularXLimit, joint.angularXLimitSpring, joint.angularYLimit, joint.angularZLimit, joint.angularYZLimitSpring);
            
            //CreateJointEntity(system, joint.gameObject, jointData, system.GetPrimaryEntity(joint.gameObject), joint.connectedBody == null ? Entity.Null : system.GetPrimaryEntity(joint.connectedBody), joint.enableCollision);
        }
        
        
        
        // from physics legacyconversionsystem 0.4.0p5
        // i didnt need to convert this particular method
        static void ConvertConfigurableJoint(LegacyConfigurable joint)
        {
            var linearLocks =
                GetAxesWithMotionType(ConfigurableJointMotion.Locked, joint.xMotion, joint.yMotion, joint.zMotion);
            var linearLimited =
                GetAxesWithMotionType(ConfigurableJointMotion.Limited, joint.xMotion, joint.yMotion, joint.zMotion);
            var angularFree =
                GetAxesWithMotionType(ConfigurableJointMotion.Free, joint.angularXMotion, joint.angularYMotion, joint.angularZMotion);
            var angularLocks =
                GetAxesWithMotionType(ConfigurableJointMotion.Locked, joint.angularXMotion, joint.angularYMotion, joint.angularZMotion);
            var angularLimited =
                GetAxesWithMotionType(ConfigurableJointMotion.Limited, joint.angularXMotion, joint.angularYMotion, joint.angularZMotion);
            
            var jointFrameOrientation = GetJointFrameOrientation(joint.axis, joint.secondaryAxis);
            var jointData = CreateConfigurableJoint(jointFrameOrientation, joint, linearLocks, linearLimited, joint.linearLimit, joint.linearLimitSpring, angularFree, angularLocks, angularLimited,
                joint.lowAngularXLimit, joint.highAngularXLimit, joint.angularXLimitSpring, joint.angularYLimit, joint.angularZLimit, joint.angularYZLimitSpring);
            
            //m_EndJointConversionSystem.CreateJointEntity(joint, GetConstrainedBodyPair(joint), jointData);

        }*/

        
        static bool3 GetAxesWithMotionType(
            ConfigurableJointMotion motionType,
            ConfigurableJointMotion x, ConfigurableJointMotion y, ConfigurableJointMotion z
        ) =>
            new bool3(x == motionType, y == motionType, z == motionType);

    }
    
}

RagdollAuthoring.cs

using System.Collections.Generic;
using thelebaron.damage;
using thelebaron.entities;
using GameComponents;
using Modules.Actors;
using Modules.PhysicsConversion;
using ModulesHybrid.HybridAI;
using Unity.Collections;
using Unity.Entities;
using Unity.Physics;
using Unity.Physics.Authoring;
using Unity.Transforms;
using UnityEngine;
// ReSharper disable RedundantNameQualifier
// ReSharper disable ParameterHidesMember

namespace Prototyping
{
    /// <summary>
    /// Ragdoll setup for dots physics backing a SkinnedMeshRenderer + gameobject hierarchy
    /// </summary>
    public class RagdollAuthoring : MonoBehaviour, IConvertGameObjectToEntity
    {
        public PersonBase PersonBase => transform.GetComponent<PersonBase>(); // do not use at runtime

        public GameObject ragdollRoot; // should not be the root gameobject though
        [SerializeField] public PhysicsCategoryTags belongsTo;
        [SerializeField] public PhysicsCategoryTags collidesWith;
        
        
        public List<Transform> ragdollHierarchy = new List<Transform>();
        public Entity[] ragdollEntities; //unsure if used

        private CollisionFilter Filter()
        {
            var filter = CollisionFilter.Default;
            filter.CollidesWith = collidesWith.Value;
            filter.BelongsTo = belongsTo.Value;

            return filter;
        }
        
        public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
        {
            
            var     builder    = new BlobBuilder(Allocator.Temp);
            ref var bodyData = ref builder.ConstructRoot<HumanBlob>();

            
            dstManager.AddBuffer<HitboxEntities>(entity);

            // Must use several loops for now, appears unavoidable until there is an easier way to convert child gameObjects when a root is Inject
            
            // Loop 01 Create entity for each ragdoll limb transform
            for (var i = 0; i < ragdollHierarchy.Count; i++)
            {
                var limbData = ragdollHierarchy[i].GetComponent<RagdollLimbData>();
                var limbEntity = conversionSystem.CreateAdditionalEntity(transform);
                limbData.entity = limbEntity;
            }
            
            // Loop 02 Setup components with new entities
            for (var i = 0; i < ragdollHierarchy.Count; i++)
            {
                var limbData = ragdollHierarchy[i].GetComponent<RagdollLimbData>();
                var rb = ragdollHierarchy[i].GetComponent<Rigidbody>();
                var joint = ragdollHierarchy[i].GetComponent<CharacterJoint>();
                
                if(joint!=null)
                    limbData.connectedEntity = joint.connectedBody.GetComponent<RagdollLimbData>().entity;

                
                AddLimbComponents(entity, dstManager, conversionSystem, limbData.entity, rb, ref bodyData);

                var buffer = dstManager.GetBuffer<HitboxEntities>(entity);
                buffer.Add(new HitboxEntities {Value = limbData.entity});
            }
            
            
            var blob = builder.CreateBlobAssetReference<HumanBlob>(Allocator.Persistent);
            bodyData = ref blob.Value;
            var ragdoll = new Ragdoll
            {
                Body = bodyData
            };
            
            dstManager.AddComponentData(entity, ragdoll);
            
            builder.Dispose();
        }

        private void AddLimbComponents(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem, 
            Entity bodypartEntity, 
            Rigidbody rigidbody,
            ref HumanBlob humanBlob)
        {
            // Set name
#if UNITY_EDITOR
            dstManager.SetName(bodypartEntity, rigidbody.name);            
#endif
            var limbTr = rigidbody.transform;
            var limbData = rigidbody.transform.GetComponent<RagdollLimbData>();
            // Game components
            dstManager.AddComponentObject(bodypartEntity, limbTr);
            dstManager.AddComponentData(bodypartEntity, new CopyTransformToTranslationRotation());
            dstManager.AddComponentData(bodypartEntity, new BleedTag()); //todo add bool toggling this
            
            dstManager.AddComponentData(bodypartEntity, new HealthLink {Value = entity, Multiplier = 1});
            dstManager.AddComponentData(bodypartEntity, new HealthState());
            dstManager.AddComponentData(bodypartEntity, new Hitbox {
                DeadCollisionFilter = Filter(), BodypartType = limbData.bodypartType
            });
            
            // Generic conversion
            // Transform Components
            dstManager.AddComponentData(bodypartEntity, new Translation{Value = rigidbody.transform.position});
            dstManager.AddComponentData(bodypartEntity, new Rotation{Value = rigidbody.transform.rotation});
            dstManager.AddComponentData(bodypartEntity, new LocalToWorld());
            
            // Physics Components
            var massProperties = MassProperties.UnitSphere;
            var kinematicMass = PhysicsMass.CreateKinematic(massProperties);
            var dynamicMass = PhysicsMass.CreateDynamic(massProperties, rigidbody.mass * 1);
            
            // Make it kinematic on start
            dstManager.AddComponentData(bodypartEntity, kinematicMass);
            dstManager.AddComponentData(bodypartEntity, new PhysicsVelocity());
            // Store dynamic data
            dstManager.AddComponentData(bodypartEntity, new PhysicsMassStore{ Dynamic = dynamicMass, Kinematic = kinematicMass});
            dstManager.AddComponentData(bodypartEntity, new PhysicsGravityFactor{ Value = 0 });
            
            // Legacy Physics Components Conversion
            LegacyColliderConversion(entity, dstManager, conversionSystem, bodypartEntity, rigidbody, ref humanBlob);
            
            if(limbData.connectedEntity!=Entity.Null)
                LegacyJointUtility.ConvertCharacterJoint(conversionSystem, gameObject, rigidbody.GetComponent<UnityEngine.CharacterJoint>(), limbData.entity, limbData.connectedEntity);

            
            dstManager.GetComponentData<PhysicsCollider>(bodypartEntity).Value.Value.Filter = CollisionFilter.Default;//Filter();
        }

        

        /// <summary>
        /// Creates a collider for each corresponding bodypart and assigns bodypart data to a blob
        /// </summary>
        private void LegacyColliderConversion(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem, 
            Entity bodypartEntity, 
            Rigidbody rigidbody,
            ref HumanBlob humanBlob)
        {
            var limbData = rigidbody.transform.GetComponent<RagdollLimbData>();
            
            switch (limbData.bodypartType)
            {
                case BodypartType.Head:
                    
                    var head = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = head });
                    
                    // Fill in blob data
                    humanBlob.Head = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Head,
                        Bodypart  = BodypartType.Head,
                        Value     = bodypartEntity
                    };
                    
                    break;
                
                case BodypartType.Chest:
                    
                    var chest = LegacyColliderUtility.CreateBoxCollider(rigidbody.GetComponent<UnityEngine.BoxCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = chest });
                    
                    // Fill in blob data
                    humanBlob.Chest = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Body,
                        Bodypart  = BodypartType.Chest,
                        Value     = bodypartEntity
                    };
                    
                    break;
                
                case BodypartType.Hips:
                    
                    var hips = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = hips });
                    
                    // Fill in blob data
                    humanBlob.Hips = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Body,
                        Bodypart  = BodypartType.Hips,
                        Value     = bodypartEntity
                    };

                    break;
                case BodypartType.Leg_L:
                    
                    var legL = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = legL });
                    // Fill in blob data
                    humanBlob.LegL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Legs,
                        Bodypart  = BodypartType.Leg_L,
                        Value     = bodypartEntity
                    };
                    
                    break;
                case BodypartType.Leg_R:
                    
                    var legR = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = legR });
                    // Fill in blob data
                    humanBlob.LegR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Legs,
                        Bodypart  = BodypartType.Leg_R,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Calf_L:

                    var calfL = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = calfL });
                    // Fill in blob data
                    humanBlob.CalfL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Legs,
                        Bodypart  = BodypartType.Calf_L,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Calf_R:
                    
                    var calfR = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = calfR });
                    // Fill in blob data
                    humanBlob.CalfR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Legs,
                        Bodypart  = BodypartType.Calf_R,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Foot_L:
                    
                    var footL = LegacyColliderUtility.CreateBoxCollider(rigidbody.GetComponent<UnityEngine.BoxCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = footL });
                    // Fill in blob data
                    humanBlob.FootL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Feet,
                        Bodypart  = BodypartType.Foot_L,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Foot_R:
                    
                    var footR = LegacyColliderUtility.CreateBoxCollider(rigidbody.GetComponent<UnityEngine.BoxCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = footR });
                    // Fill in blob data
                    humanBlob.FootR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Feet,
                        Bodypart  = BodypartType.Foot_R,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Arm_L:
                    
                    var armL = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = armL });
                    // Fill in blob data
                    humanBlob.ArmL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Arms,
                        Bodypart  = BodypartType.Arm_L,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Arm_R:
                    
                    var armR = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = armR });
                    // Fill in blob data
                    humanBlob.ArmR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Arms,
                        Bodypart  = BodypartType.Arm_R,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Forearm_L:
                    
                    var farmL = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = farmL });
                    // Fill in blob data
                    humanBlob.ForearmL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Arms,
                        Bodypart  = BodypartType.Forearm_L,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Forearm_R:
                    
                    var farmR = LegacyColliderUtility.CreateCapsuleCollider(rigidbody.GetComponent<UnityEngine.CapsuleCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = farmR });
                    // Fill in blob data
                    humanBlob.ForearmR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Arms,
                        Bodypart  = BodypartType.Forearm_R,
                        Value     = bodypartEntity
                    };
                    
                    break;
                case BodypartType.Hand_L:
                    
                    var handL = LegacyColliderUtility.CreateBoxCollider(rigidbody.GetComponent<UnityEngine.BoxCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = handL });
                    // Fill in blob data
                    humanBlob.HandL = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Hands,
                        Bodypart  = BodypartType.Hand_L,
                        Value     = bodypartEntity
                    };
                    break;
                case BodypartType.Hand_R:
                    
                    var handR = LegacyColliderUtility.CreateBoxCollider(rigidbody.GetComponent<UnityEngine.BoxCollider>());
                    dstManager.AddComponentData(bodypartEntity, new PhysicsCollider { Value = handR });
                    // Fill in blob data
                    humanBlob.HandR = new Part
                    {
                        Hitpoints = PersonBase.Bodyparts.Hands,
                        Bodypart  = BodypartType.Hand_R,
                        Value     = bodypartEntity
                    };
                    break;
                
                default:
                    break;
            }
        }

        
    }
}