XR: движение стиком и шаговый поворот

Level
├── XrStartup (XrStartup.cs)
├── Player (CharacterBody3D, XrPlayer.cs)
│   ├── CollisionShape3D (CapsuleShape3D)
│   └── XROrigin3D
│       ├── XRCamera3D (head)
│       ├── XRController3D (left_hand, grip)
│       └── XRController3D (right_hand, grip)
└── Floor (StaticBody3D)
    └── CollisionShape3D (BoxShape3D)

using System;
using Reckfell;

public sealed class XrWalk
{
    private bool turnLatched;

    // Call once per physics tick. Upright, unscaled rig; one instance per player.
    // true means physical head/body alignment is blocked, not successful tracking.
    public bool Step(CharacterBody3D body, XROrigin3D origin, Entity3D head,
        Vector2 move, float turn, bool allowInput, double delta)
    {
        if (!move.IsFinite() || !float.IsFinite(turn)
            || !double.IsFinite(delta) || delta <= 0 || delta > 1)
            throw new ArgumentOutOfRangeException(nameof(delta), "Invalid input or physics delta.");
        if (!allowInput)
        {
            body.Velocity = Vector3.Zero;
            turnLatched = true; // Require neutral before the next snap after focus loss.
            return false;
        }
        if (RoomScaleBody.FollowHead(body, origin, head))
        {
            body.Velocity = Vector3.Zero;
            turnLatched = true;
            return true;
        }
        if (Mathf.Abs(turn) <= 0.25f) turnLatched = false;
        if (!turnLatched && Mathf.Abs(turn) >= 0.75f)
        {
            RoomScaleBody.TurnAroundHead(body, origin, head,
                -Mathf.Sign(turn) * Mathf.Pi / 6);
            turnLatched = true;
        }
        if (move.Length() <= 0.2f) move = Vector2.Zero;
        if (move.LengthSquared() > 1) move = move.Normalized();
        Vector3 forward = -head.GlobalBasis.Z;
        forward.Y = 0;
        if (forward.LengthSquared() < 0.000001f) forward = -body.GlobalBasis.Z;
        forward = forward.Normalized();
        Vector3 horizontal = (forward.Cross(Vector3.Up) * move.X + forward * move.Y) * 2;
        Vector3 velocity = body.Velocity;
        velocity.X = horizontal.X;
        velocity.Z = horizontal.Z;
        if (body.IsOnFloor() && velocity.Y < 0) velocity.Y = 0;
        else velocity.Y -= 9.8f * (float)delta;
        body.Velocity = velocity; // Units/second: MoveAndSlide applies its own frame delta.
        body.MoveAndSlide(); // Carries the origin with the body; do not compensate it here.
        return false;
    }
}

using Reckfell;

public partial class XrPlayer : CharacterBody3D
{
    [Export] public XROrigin3D Origin { get; set; } = null!;
    [Export] public XRCamera3D Head { get; set; } = null!;
    [Export] public XRController3D MoveController { get; set; } = null!;
    [Export] public XRController3D TurnController { get; set; } = null!;
    [Export] public XrStartup Startup { get; set; } = null!;
    public bool PhysicalGap { get; private set; }
    private readonly XrWalk walk = new();

    public override void _Ready()
    {
        if (Origin is null || Head is null || MoveController is null
            || TurnController is null || Startup is null || !IsAncestorOf(Origin)
            || Head.GetParent() != Origin || MoveController.GetParent() != Origin
            || TurnController.GetParent() != Origin)
        {
            ReckfellApi.PushError("XrPlayer: assign the startup and complete body/origin rig.");
            SetPhysicsProcess(false);
        }
    }

    public override void _PhysicsProcess(double delta)
    {
        var tracker = XRServer.GetTracker(Head.Tracker) as XRPositionalTracker;
        var pose = tracker?.GetPose("default"); // Borrowed state: do not Dispose.
        var movePose = MoveController.GetPose();
        var turnPose = TurnController.GetPose();
        bool active = Startup.HasFocus && pose is not null && pose.HasTrackingData
            && movePose is not null && movePose.HasTrackingData
            && turnPose is not null && turnPose.HasTrackingData;
        PhysicalGap = walk.Step(this, Origin, Head,
            active ? MoveController.GetVector2("move_player") : Vector2.Zero,
            active ? TurnController.GetVector2("turn_player").X : 0, active, delta);
    }
}