// CubeGrabber.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;

public class CubeGrabber : MonoBehaviour {
    //// Class ////
    // A list of all grabbable objects.
    private static HashSet<Cube> _cubes = new HashSet<Cube>();

    public static void RegisterCube(Cube cube) {
        _cubes.Add(cube);
    }

    public static void UnregisterCube(Cube cube) {
        _cubes.Remove(cube);
    }

    //// Instance ////

    // Keep track of which hand we want to watch.
    private enum Hand { LeftHand, RightHand };
    [SerializeField] private Hand _hand;

    // Whether or not we're grabbing.
    private bool _triggerPressed;

    // Information on the current cube we're holding & controller velocity
    private Cube        _activeCube;
    private Vector3     _grabPositionOffset;
    private Quaternion  _grabRotationOffset;

    // Current controller pose data. Updated in UpdatePose().
    private Vector3     _lastValidControllerVelocity;
    private Vector3     _lastValidControllerAngularVelocity;

    void Update() {
        XRNode handNode = _hand == Hand.LeftHand ? XRNode.LeftHand : XRNode.RightHand;
        string trigger  = _hand == Hand.LeftHand ? "Left Trigger" : "Right Trigger";

        // Get velocity & angular velocity of the hand.
        bool handIsTracking = UpdatePose(handNode, ref _lastValidControllerVelocity, ref _lastValidControllerAngularVelocity);

        // Determine if we're pressing the trigger far enough to activate grabbing.
        bool triggerPressed = Input.GetAxisRaw(trigger) > 0.8f;

        bool triggerBegan = triggerPressed && !_triggerPressed;
        bool triggerActive = triggerPressed;
        bool triggerEnded = !triggerPressed && _triggerPressed;

        // If we start holding the trigger and aren't already holding a cube, start grabbing it.
        if (triggerBegan && _activeCube == null) {
            Cube cubeToGrab = GetClosestGrabbableCube();

            // Found a valid cube, let's grab it!
            if (cubeToGrab != null) {
                _activeCube = cubeToGrab;
                _activeCube.BeginGrabbing();

                // Calculate grab offset.
                _grabPositionOffset = transform.InverseTransformPoint(_activeCube.transform.position);
                _grabRotationOffset = Quaternion.Inverse(transform.rotation) * _activeCube.transform.rotation;
            }
        }

        // If we're currently holding a cube, position it.
        if (triggerActive && _activeCube != null) {
            // Position the cube
            PositionActiveCube();
        }

        // If we let go of the trigger with an active cube, drop it.
        if (triggerEnded && _activeCube != null) {
            // Calculate cube throw velocity. Take into account the offset from the controller.
            Vector3 cubeVelocity = _lastValidControllerVelocity + Vector3.Cross(_lastValidControllerAngularVelocity, transform.rotation * _grabPositionOffset);
            Vector3 cubeAngularVelocity = _lastValidControllerAngularVelocity;

            // Throw cube.
            _activeCube.EndGrabbing(cubeVelocity, cubeAngularVelocity);
            _activeCube = null;
        }

        // Update cached trigger value.
        _triggerPressed = triggerPressed;
    }

    private Cube GetClosestGrabbableCube() {
        Cube cubeToGrab = null;
        float cubeToGrabDistance = float.MaxValue;
        foreach (Cube cube in _cubes) {
            // Skip cubes that have already been grabbed.
            if (cube.grabbed) continue;

            float distance = cube.DistanceToCubeSurface(transform.position);

            // Skip if we're not colliding with the cube.
            if (distance > 0.0f) continue;

            // Replace cubeToGrab if it's closer than any previously seen cube.
            if (distance < cubeToGrabDistance) {
                cubeToGrab = cube;
                cubeToGrabDistance = distance;
            }
        }

        return cubeToGrab;
    }

    // Position the active cube.
    private void PositionActiveCube() {
        // Calculate the cube position, including delta grab offset.
        Vector3 cubePosition = transform.TransformPoint(_grabPositionOffset);
        Quaternion cubeRotation = transform.rotation * _grabRotationOffset;

        // Position the cube.
        _activeCube.PositionCube(cubePosition, cubeRotation);
    }

    private static bool UpdatePose(XRNode node, ref Vector3 velocity, ref Vector3 angularVelocity) {
        // Update velocity & angular velocity with the given XRNode via XRNodeState
        List<XRNodeState> nodeStates = new List<XRNodeState>();
        InputTracking.GetNodeStates(nodeStates);

        foreach (XRNodeState nodeState in nodeStates) {
            if (nodeState.nodeType == node) {
                // Matches the hand we're looking for - let's grab its velocity.
                Vector3 nodeVelocity;
                Vector3 nodeAngularVelocity;

                bool gotVelocity        = nodeState.TryGetVelocity(out nodeVelocity);
                bool gotAngularVelocity = nodeState.TryGetAngularVelocity(out nodeAngularVelocity);

                if (gotVelocity)
                    velocity = nodeVelocity;
                if (gotAngularVelocity)
                    angularVelocity = nodeAngularVelocity;

                return gotVelocity;
            }
        }

        return false;
    }
}
  

    // Cube.cs
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Cube : MonoBehaviour {
    [SerializeField] private float _grabRadius = 0.25f;

    public bool grabbed { get; private set; }

    private Rigidbody _rigidbody;

    // Unity events
    private void Awake() {
        _rigidbody = GetComponent<Rigidbody>();
    }

    private void OnEnable() {
        CubeGrabber.RegisterCube(this);
    }

    private void OnDisable() {
        CubeGrabber.UnregisterCube(this);
    }

    // Used to verify we're actually colliding with the cube at the given grabPosition.
    public float DistanceToCubeSurface(Vector3 grabPosition) {
        return Vector3.Distance(grabPosition, transform.position) - _grabRadius;
    }

    // Grab events
    public void BeginGrabbing() {
        // Mark as grabbed.
        grabbed = true;

        // Mark the rigidbody as kinematic.
        _rigidbody.isKinematic = true;
    }

    public void PositionCube(Vector3 position, Quaternion rotation) {
        // Move rigidbody
        _rigidbody.MovePosition(position);
        _rigidbody.MoveRotation(rotation);
    }


    public void EndGrabbing(Vector3 velocity, Vector3 angularVelocity) {
        // Mark the rigidbody as non-kinematic
        _rigidbody.isKinematic = false;
        _rigidbody.velocity = velocity;
        _rigidbody.angularVelocity = angularVelocity;

        // Mark as free to grab again.
        grabbed = false;
    }
}
  

    // Cube.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Normal.Realtime;

public Class Cube : MonoBehaviour {
    // ...

    private Rigidbody         _rigidbody;
    private RealtimeTransform _realtimeTransform;

    // Unity Events
    private void Awake() {
        _rigidbody         = GetComponent<Rigidbody>();
        _realtimeTransform = GetComponent<RealtimeTransform>();
    }

    // ...

    public void BeginGrabbing() {
        // ...

        // Request ownership from the transform.
        _realtimeTransform.RequestOwnership();
    }
}