public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
            {
                NativeArray <KinematicMotor>  chunkMotors       = chunk.GetNativeArray(KinematicMotorType);
                NativeArray <Movement>        chunkMovements    = chunk.GetNativeArray(MovementType);
                NativeArray <PhysicsCollider> chunkColliders    = chunk.GetNativeArray(PhysicsColliderType);
                NativeArray <Translation>     chunkTranslations = chunk.GetNativeArray(TranslationType);
                NativeArray <Rotation>        chunkRotations    = chunk.GetNativeArray(RotationType);

                for (int i = 0; i < chunk.Count; i++)
                {
                    KinematicMotor  motor       = chunkMotors[i];
                    Movement        movement    = chunkMovements[i];
                    PhysicsCollider collider    = chunkColliders[i];
                    Translation     translation = chunkTranslations[i];
                    Rotation        rotation    = chunkRotations[i];

                    RigidTransform transform = new RigidTransform
                    {
                        pos = translation.Value,
                        rot = rotation.Value
                    };

                    float3 velocity = movement.Value;

                    unsafe
                    {
                        Collider *queryCollider;
                        {
                            Collider *colliderPtr = collider.ColliderPtr;

                            byte *copiedColliderMemory = stackalloc byte[colliderPtr->MemorySize];
                            queryCollider = (Collider *)(copiedColliderMemory);
                            UnsafeUtility.MemCpy(queryCollider, colliderPtr, colliderPtr->MemorySize);
                            queryCollider->Filter = CollisionFilter.Default;
                        }

                        KinematicMotorUtilities.SolveCollisionConstraints(World, DeltaTime, motor.MaxIterations, motor.SkinWidth, 360, queryCollider, ref transform, ref velocity, ref DistanceHits, ref ColliderCastHits, ref SurfaceConstraintInfos);
                    }

                    translation.Value = transform.pos;
                    movement.Value    = velocity;

                    // Apply data back to chunk
                    {
                        chunkTranslations[i] = translation;
                        chunkMovements[i]    = movement;
                    }
                }
            }
            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
            {
                NativeArray <CharacterController> chunkCharacterControllers = chunk.GetNativeArray(CharacterControllerType);
                NativeArray <PhysicsCollider>     chunkPhysicsColliders     = chunk.GetNativeArray(PhysicsColliderType);
                NativeArray <Translation>         chunkTranslations         = chunk.GetNativeArray(TranslationType);
                NativeArray <Rotation>            chunkRotations            = chunk.GetNativeArray(RotationType);

                for (int i = 0; i < chunk.Count; i++)
                {
                    CharacterController controller  = chunkCharacterControllers[i];
                    PhysicsCollider     collider    = chunkPhysicsColliders[i];
                    Translation         translation = chunkTranslations[i];
                    Rotation            rotation    = chunkRotations[i];

                    RigidTransform transform = new RigidTransform
                    {
                        pos = translation.Value,
                        rot = rotation.Value
                    };

                    unsafe
                    {
                        Collider *queryCollider;
                        {
                            Collider *colliderPtr = collider.ColliderPtr;

                            byte *copiedColliderMemory = stackalloc byte[colliderPtr->MemorySize];
                            queryCollider = (Collider *)(copiedColliderMemory);
                            UnsafeUtility.MemCpy(queryCollider, colliderPtr, colliderPtr->MemorySize);
                            queryCollider->Filter = CollisionFilter.Default;
                        }

                        KinematicMotorUtilities.MaxHitCollector <DistanceHit> distanceHitCollector = new KinematicMotorUtilities.MaxHitCollector <DistanceHit>(controller.GroundTollerance, ref DistanceHits);
                        {
                            ColliderDistanceInput input = new ColliderDistanceInput
                            {
                                MaxDistance = controller.GroundTollerance,
                                Transform   = transform,
                                Collider    = queryCollider
                            };
                            World.CalculateDistance(input, ref distanceHitCollector);
                        }

                        for (int hitIndex = 0; hitIndex < distanceHitCollector.NumHits; hitIndex++)
                        {
                            DistanceHit hit = distanceHitCollector.AllHits[hitIndex];
                            KinematicMotorUtilities.CreateConstraintFromHit(World, hit.ColliderKey, hit.RigidBodyIndex, hit.Position, float3.zero, hit.SurfaceNormal, hit.Distance, DeltaTime, out SurfaceConstraintInfo constraint);
                            SurfaceConstraintInfos[hitIndex] = constraint;
                        }

                        float3 outPosition = transform.pos;
                        float3 outVelocity = -math.up();
                        SimplexSolver.Solve(World, DeltaTime, math.up(), distanceHitCollector.NumHits, ref SurfaceConstraintInfos, ref outPosition, ref outVelocity, out float integratedTime);

                        if (distanceHitCollector.NumHits == 0)
                        {
                            controller.State = CharacterControllerState.NONE;
                        }
                        else
                        {
                            outVelocity = math.normalize(outVelocity);
                            float slopeAngleSin   = math.dot(outVelocity, -math.up());
                            float slopeAngleCosSq = 1 - slopeAngleSin * slopeAngleSin;
                            float maxSlopeCos     = math.cos(controller.MaxSlope);

                            controller.State = CharacterControllerState.GROUNDED;
                        }
                    }

                    // Apply data back to chunk
                    {
                        chunkCharacterControllers[i] = controller;
                    }
                }
            }