2D Simulation API

using System.Numerics;
using Altruist.Physx;            // PhysxWorldEngine2D, IPhysxWorldEngine2D
using Altruist.Physx.Contracts;  // PhysxBodyType, PhysxForce
using Altruist.Physx.TwoD;       // body, fixture, shape, contact types

var world = PhysxWorldEngine2D.Create(new PhysxWorldSettings2D
{
    Gravity = new Vector2(0, -10),
    FixedDeltaTime = 1f / 60f,
    VelocityIterations = 8,
    PositionIterations = 3,
});

for (var tick = 0; tick < 600; tick++)
    world.Step(world.FixedDeltaTime);

world.Dispose();

public sealed class MatchFactory(IPhysxWorldEngineFactory2D physics)
{
    public IPhysxWorldEngine2D NewWorld() =>
        physics.Create(new PhysxWorldSettings2D { Gravity = Vector2.Zero });
}

var world = PhysxWorldEngine2D.Create(new PhysxWorldSettings2D
{
    Gravity = new Vector2(0, -10),
    FixedDeltaTime = 1f / 60f,
    MaxSubSteps = 4,
});

world.Step(1f / 30f);   // two steps of 1/60
world.Step(1f / 120f);  // nothing yet: half a step accumulated
world.Step(1f / 120f);  // one step

var crate = world.CreateBody(new PhysxBodyDef2D
{
    Type = PhysxBodyType.Dynamic,
    Position = new Vector2(0, 5),
    Angle = 0f,
    UserData = myEntity,
});

// Push a car forward along its own +X axis.
var forward = car.GetWorldVector(new Vector2(1, 0));
car.ApplyForce(PhysxForce.Impulse2D(forward * 2f));

// Where is the ball relative to the car's nose?
var local = car.GetLocalPoint(ball.Position);
bool ballInFront = local.X > 0;

var r = Rotation2D.FromDegrees(90);         // or FromRadians(...)
var world = r.Rotate(new Vector2(1, 0));    // (0, 1): local to world, counter-clockwise
var local = r.Unrotate(world);              // (1, 0): world to local

world.CreateFixture(crate, new PhysxFixtureDef2D
{
    Shape = PhysxShape2D.Box(0.5f, 0.5f),
    Density = 1f,
    Friction = 0.4f,
    Restitution = 0.2f,
});

var walls = world.CreateBody(new PhysxBodyDef2D { Type = PhysxBodyType.Static });
world.CreateFixture(walls, new PhysxFixtureDef2D
{
    // Up the left side, across the top, down the right side: clockwise.
    Shape = PhysxShape2D.Chain(new[]
    {
        new Vector2(-5, 0), new Vector2(-5, 10), new Vector2(5, 10), new Vector2(5, 0),
    }, loop: true),
});

public readonly record struct PhysxFilter2D
{
    public PhysxFilter2D(ushort Category = 1, ushort Mask = 0xFFFF, short Group = 0);
    public ushort Category { get; init; }
    public ushort Mask { get; init; }
    public short Group { get; init; }
    public static readonly PhysxFilter2D Default; // category 1, mask 0xFFFF, group 0
}

const ushort Cars = 1 << 1, Ball = 1 << 2, Walls = 1 << 3;

// Cars hit walls and the ball, but not each other.
var carFilter = new PhysxFilter2D(Category: Cars, Mask: Walls | Ball);

// Debris pieces with the same negative group pass through each other.
var debris = new PhysxFilter2D(Category: 1, Mask: 0xFFFF, Group: -1);

public interface IPhysxContactListener2D
{
    void BeginContact(IPhysxContact2D contact) { }
    void EndContact(IPhysxContact2D contact) { }
    void PreSolve(IPhysxContact2D contact) { }
    void PostSolve(IPhysxContact2D contact, float normalImpulse) { }
}

world.SetContactListener(listener);   // null removes it

public sealed class ArenaContacts : IPhysxContactListener2D
{
    public void BeginContact(IPhysxContact2D c)
    {
        if (Is(c, "ball", "goal")) OnGoal();
    }

    public void PreSolve(IPhysxContact2D c)
    {
        // One-way platform: a body below passes through.
        if (c.FixtureA.UserData is "platform" && c.GetWorldManifold().Normal.Y < 0)
            c.IsEnabled = false;

        // The ball always bounces hard off cars, whatever the materials say.
        if (Is(c, "ball", "car"))
            c.Restitution = 0.9f;
    }

    public void PostSolve(IPhysxContact2D c, float normalImpulse)
    {
        if (normalImpulse > 5f) OnHardHit(c.GetWorldManifold().Midpoint, normalImpulse);
    }

    private static bool Is(IPhysxContact2D c, string a, string b) =>
        (c.FixtureA.UserData ?? c.BodyA.UserData, c.FixtureB.UserData ?? c.BodyB.UserData) switch
        {
            var (x, y) when Equals(x, a) && Equals(y, b) => true,
            var (x, y) when Equals(x, b) && Equals(y, a) => true,
            _ => false,
        };

    private void OnGoal() { }
    private void OnHardHit(Vector2 at, float impulse) { }
}

private readonly List<PhysxContactInfo2D> _hits = new();

public void BeginContact(IPhysxContact2D c) => _hits.Add(c.ToInfo());

var ballOnGround = false;
foreach (var c in world.Contacts)
{
    if (!c.IsTouching || !c.IsEnabled) continue;
    if (Equals(c.BodyA.UserData, "ball") || Equals(c.BodyB.UserData, "ball"))
        ballOnGround = true;
}

public sealed class ClosestSolidHit : IPhysxRayCastCallback2D
{
    public bool Found;
    public Vector2 Point;
    public Vector2 Normal;
    public IPhysxFixture2D? Fixture;

    public float OnHit(IPhysxFixture2D fixture, Vector2 point, Vector2 normal, float fraction)
    {
        if (fixture.IsTrigger) return -1;   // look through triggers
        Found = true;
        Point = point;
        Normal = normal;
        Fixture = fixture;
        return fraction;                    // keep the closest
    }
}

var hit = new ClosestSolidHit();
world.RayCast(eye, eye + direction * 50f, hit);

var hits = world.RayCast(new PhysxRay2D(eye, eye + direction * 50f), maxHits: 3);

using System.Numerics;
using Altruist.Physx;
using Altruist.Physx.Contracts;
using Altruist.Physx.TwoD;

public sealed class BallInABox : IPhysxContactListener2D, IDisposable
{
    private readonly IPhysxWorldEngine2D _world;

    public IPhysxBody2D Ball { get; }
    public int WallHits { get; private set; }
    public float HardestImpact { get; private set; }

    public BallInABox()
    {
        _world = PhysxWorldEngine2D.Create(new PhysxWorldSettings2D
        {
            Gravity = new Vector2(0, -10),
            FixedDeltaTime = 1f / 60f,
        });
        _world.SetContactListener(this);

        // A 20 x 10 box. Wound clockwise, so the loop collides on its inside.
        var walls = _world.CreateBody(new PhysxBodyDef2D { Type = PhysxBodyType.Static, UserData = "walls" });
        _world.CreateFixture(walls, new PhysxFixtureDef2D
        {
            Shape = PhysxShape2D.Chain(new[]
            {
                new Vector2(-10, 0), new Vector2(-10, 10), new Vector2(10, 10), new Vector2(10, 0),
            }, loop: true),
            Friction = 0.1f,
        });

        Ball = _world.CreateBody(new PhysxBodyDef2D
        {
            Type = PhysxBodyType.Dynamic,
            Position = new Vector2(0, 5),
            Bullet = true,
            UserData = "ball",
        });
        _world.CreateFixture(Ball, new PhysxFixtureDef2D
        {
            Shape = PhysxShape2D.Circle(0.5f),
            Density = 1f,
            Restitution = 0.8f,
        });
        Ball.LinearVelocity = new Vector2(12, 4);
    }

    public void Step() => _world.Step(_world.FixedDeltaTime);

    public float? DistanceToFloor()
    {
        var hit = new ClosestHit();
        _world.RayCast(Ball.Position, Ball.Position + new Vector2(0, -20), hit);
        return hit.Found ? Ball.Position.Y - hit.Point.Y : null;
    }

    // Contact listener: runs inside Step, on the stepping thread.
    public void BeginContact(IPhysxContact2D c)
    {
        if (Equals(c.BodyA.UserData, "walls") || Equals(c.BodyB.UserData, "walls"))
            WallHits++;
    }

    public void PostSolve(IPhysxContact2D c, float normalImpulse) =>
        HardestImpact = MathF.Max(HardestImpact, normalImpulse);

    public void Dispose() => _world.Dispose();

    private sealed class ClosestHit : IPhysxRayCastCallback2D
    {
        public bool Found;
        public Vector2 Point;

        public float OnHit(IPhysxFixture2D fixture, Vector2 point, Vector2 normal, float fraction)
        {
            if (Equals(fixture.Body.UserData, "ball")) return -1;  // ignore the ball itself
            Found = true;
            Point = point;
            return fraction;                                       // clip: keep the closest
        }
    }
}

using var sim = new BallInABox();
for (var tick = 0; tick < 600; tick++)
    sim.Step();

Console.WriteLine($"ball at {sim.Ball.Position}, {sim.WallHits} wall hits, " +
                  $"hardest impact {sim.HardestImpact:F2}, {sim.DistanceToFloor():F2} above the floor");

if (!PhysxWorldEngine2D.ParallelWorldsSupported)
{
    // Box2DThreading.FailureReason says why (an incompatible Box2DSharp version).
    // Step the worlds one after another instead.
}

Parallel.ForEach(rooms, room => room.World.Step(room.World.FixedDeltaTime));