Angular movement

[sourcefranke]

Hello,

I am pretty new to kinematics.
There's a topic I currently need to do some research for at a new work project.

It's about putting two bodies together with some joint in between.
What I try to achieve: I want to move only the second body and let it rotate around the joint.
But I am struggling at some point, because of I am not sure, what's missing to make it work.
Or did I even do something completely wrong already.

To ensure, it's clear, what I try to achieve, I've attached some drawings.

Again, sorry, I'm a total beginner in getting familiar and gathering domain knowledge.

I have tried to come up with some solution with the help of chatGPT.
The issue there (as you maybe already tried by yourself),
this chat bot was mixing things up in terms of version 1 and version 2 of this framework.

Code snippet

What I've "produced" so far (with the help of the well-known AI chat tool):

using Physics.Callbacks;
using System.Numerics;

namespace Physics
{
    public class JointPhysics
    {

        public void Main()
        {
            // Initialize buffer pool and simulation
            Simulation simulation = Simulation.Create(
                new(),
                new PhysicsNarrowPhase(),
                new PhysicsPoseIntegrator(),
                new SolveDescription(1, 1)
            );

            // Create ground entity
            var groundBox = new Box(1, 1, 1);
            var groundHandle = simulation.Bodies.Add(
                BodyDescription.CreateDynamic(
                    new Vector3(1, 1, 1),
                    groundBox.ComputeInertia(1),
                    simulation.Shapes.Add(groundBox),
                    0.0f
                )
            );
            var groundDescription =
                BodyDescription
                    .CreateKinematic(
                        new RigidPose(new Vector3(0, -0.5f, 0)),
                        new BodyVelocity(),
                        new CollidableDescription(),
                        new BodyActivityDescription()
                    );
            simulation.Bodies.ApplyDescription(
                groundHandle,
                groundDescription
            );

            // Create the moving body
            var movingBodyShape = new Box(1, 1, 1);
            var movingBodyDescription =
                BodyDescription
                    .CreateDynamic(
                        new RigidPose(new Vector3(0, 0, 0)),
                        new BodyVelocity(),
                        movingBodyShape.ComputeInertia(1),
                        new CollidableDescription(),
                        new BodyActivityDescription()
                    );
            var movingBodyHandle = simulation.Bodies.Add(movingBodyDescription);

            // Create the revolute joint
            var hingeLocation = new Vector3(0, 0, 0);
            var hingeAxis = new Vector3(0, 1, 0);
            var hingeJoint = new Hinge()
            {
                // [...]
            };
            simulation.Solver.Add(movingBodyHandle, groundHandle, hingeJoint);

            // Define the angular motor
            AngularMotor motor = new();
            motor.TargetVelocityLocalA = new Vector3();
            motor.Settings = new MotorSettings(float.MaxValue, 0.01f);
        
            motor.Settings.Damping = 0; 
            motor.Settings.MaximumForce = 10f;

            simulation.Solver.Add(movingBodyHandle, groundHandle, motor);

            // Run the simulation for 0.5 seconds
            double simulationTime = 0;
            float timeStep = 1 / 60f;

            while (simulationTime < 0.5)
            {
                simulation.Timestep(timeStep);
                simulationTime += timeStep;

                ref var movingBodyPose = ref simulation.Bodies.GetBodyReference(movingBodyHandle).Pose;
                Console.WriteLine($"time: {simulationTime:0.000} - position: {movingBodyPose.Position}");
            }

            Console.WriteLine("Simulation complete.");

            // Dispose simulation
            simulation.Dispose();
            simulation.BufferPool.Clear();
        }
    }
}

[RossNordby]

Here's a version you can copy paste into the demos (toss it into the Initialize function, for example):

        Simulation = Simulation.Create(BufferPool, new DemoNarrowPhaseCallbacks(new SpringSettings(30, 1)), new DemoPoseIntegratorCallbacks(new Vector3(0, -10, 0)), new SolveDescription(8, 1));

        // Create the dynamic body.
        var bodyShape = new Box(1, 1, 1);
        var movingBodyDescription = BodyDescription.CreateDynamic(new Vector3(0, 3, 0), new Vector3(), bodyShape.ComputeInertia(1), Simulation.Shapes.Add(bodyShape), 0.01f);
        var movingBodyHandle = Simulation.Bodies.Add(movingBodyDescription);

        // Ccreate a kinematic body to attach the dynamic body to.
        // (Note that bodies don't have to have a shape!
        // That can be useful if you want to use a two-body constraint with a single body.
        // The second body can just be a kinematic proxy with no shape.)

        var kinematicBodyDescription = BodyDescription.CreateKinematic(new Vector3(3, 3, 0), new Vector3(), Simulation.Shapes.Add(bodyShape), 0.01f);
        var kinematicBodyHandle = Simulation.Bodies.Add(kinematicBodyDescription);

        // Create the revolute joint
        var hingeJoint = new Hinge()
        {
            // The bodies connected to the constraint start with identity rotation, so we can configure the local axes more intuitively.
            // ("local" here means "local to the body's frame of reference." When the body rotates, the hinge axis rotates with it.)
            LocalHingeAxisA = new Vector3(0, 1, 0),
            LocalHingeAxisB = new Vector3(0, 1, 0),
            LocalOffsetA = new Vector3(1.5f, 0, 0),
            LocalOffsetB = new Vector3(-1.5f, 0, 0),
            SpringSettings = new SpringSettings(30, 1)
        };
        Simulation.Solver.Add(movingBodyHandle, kinematicBodyHandle, hingeJoint);

        // Define the angular motor
        var motor = new AngularMotor { TargetVelocityLocalA = new Vector3(), Settings = new MotorSettings(float.MaxValue, 0.01f) };
        Simulation.Solver.Add(movingBodyHandle, kinematicBodyHandle, motor);

In general, I'd recommend playing around in the demos as a starting point. It's easier to incrementally modify things than to try to start from scratch.

Eventually, context windows are going to be large enough that you can just dump the entire physics engine and its documentation into the AI directly and ask it to do everything for you. Alas, not yet. We might have to wait several MONTHS before that's economical.