LaserMovable.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using Autohand;
using Autohand.Demo;
using PixoVR.Core;
using PixoVR.Event;
using Sirenix.OdinInspector;
using UnityEngine;
 
public enum RotationOnRelease
{
    None,
    Initial,
    OnGrabStart,
    LookAtCamera
}
 
[RequireComponent(typeof(DistanceGrabbable))]
public class LaserMovable : MonoBehaviour
{
    [SerializeField] private Transform _transformToMove;
    [SerializeField] private DistanceGrabbable _distanceGrabbable;
    [SerializeField] private RotationOnRelease _rotationOnRelease = RotationOnRelease.Initial;
    [SerializeField] private float _zoomInSpeed = 2;
    [SerializeField] private bool _invertedForward = true;
 
    private const float MAX_DISTANCE = 15;
    private const float MIN_DISTANCE = 1;
    
    private Hand _currentSelectingHand;
    public bool IsPulling { get; internal set; }
    public bool IsTargeted { get; internal set; }
    private Transform _previousParent = null;
    private Quaternion _rotationOnGrab;
    private Vector3 _initialPosition;
    private Quaternion _intitialRotation;
    private InputListener _inputListener;
 
    private bool _startedSelecting = false;
 
    public virtual void Awake()
    {
        _inputListener = ServiceLocator.Resolve<InputListener>();
        _initialPosition = _transformToMove.position;
        _intitialRotation = _transformToMove.rotation;
    }
 
    private void OnEnable()
    {
        _distanceGrabbable.StartTargeting.AddListener(OnStartTargeting);
        _distanceGrabbable.StopTargeting.AddListener(OnStopTargeting);
        _distanceGrabbable.StartSelecting.AddListener((Hand hand, Grabbable grabbable) =>
        {
            _startedSelecting = true;
        });
        _distanceGrabbable.StopSelecting.AddListener((Hand hand, Grabbable grabbable) =>
        {
            _startedSelecting = false;
        });
        _inputListener.TriggerPressed += OnTriggerPressed;
        _inputListener.TriggerReleased += OnTriggerReleased;
 
        EventBetter.Listen(this, (WaypointRespawnEvent respawnEvent) =>
        {
            if (respawnEvent.RespawnTransform == _transformToMove)
            {
                _initialPosition = _transformToMove.position;
                _intitialRotation = _transformToMove.rotation;
            }
        });
        
        EventBetter.Listen(this, (LongPressEvent longPressEvent) =>
        {
            if (longPressEvent.Button != CommonButton.gripButton)
            {
                return;
            }
            
            if (_currentSelectingHand != null)
            {
                OnTriggerReleased(_currentSelectingHand);
            }
 
            _transformToMove.position = _initialPosition;
            _transformToMove.rotation = _intitialRotation;
        });
    }
 
    private void OnDisable()
    {
        EventBetter.Unlisten<LongPressEvent>(this);
        EventBetter.Unlisten<WaypointRespawnEvent>(this);
        _distanceGrabbable.StartTargeting.RemoveListener(OnStartTargeting);
        _distanceGrabbable.StopTargeting.RemoveListener(OnStopTargeting);
        _inputListener.TriggerPressed -= OnTriggerPressed;
        _inputListener.TriggerReleased -= OnTriggerReleased;
        
        if (_currentSelectingHand != null)
        {
            OnTriggerReleased(_currentSelectingHand);
        }
 
        IsPulling = false;
        IsTargeted = false;
        _currentSelectingHand = null;
    }
 
    private void Update()
    {
        if (!IsTargeted)
        {
            return;
        }
 
        if (IsPulling)
        {
            float yAxis = GetCurrentHandYAxis();
            if (yAxis != 0)
            {
                MoveAlongRay(yAxis);
            }
        }
    }
 
    private void MoveAlongRay(float moveDirection)
    {
        float distance = Vector3.Distance(_currentSelectingHand.transform.position, _transformToMove.position);
        float deltaMove = -moveDirection * Time.deltaTime * _zoomInSpeed;
        
        if (distance >= MAX_DISTANCE && deltaMove < 0)
        {
            return;
        }
        
        if (distance <= MIN_DISTANCE && deltaMove > 0)
        {
            return;
        }
        
        _transformToMove.Translate((_currentSelectingHand.transform.position - _transformToMove.position) * deltaMove,
            Space.World);
    }
    
 
    private float GetCurrentHandYAxis()
    {
        return _inputListener.GetAxis(_currentSelectingHand).y;
    }
    
 
    private void OnStartTargeting(Hand hand, Grabbable grabbable)
    {
        if (hand.holdingObj != null || IsPulling)
        {
            return;
        }
        _currentSelectingHand = hand;
        IsTargeted = true;
        StartTargeting();
    }
 
    public virtual void StartTargeting()
    {
    }
 
    private void OnStopTargeting(Hand hand, Grabbable grabbable)
    {
        if (IsPulling || _startedSelecting)
        {
            return;
        }
        _currentSelectingHand = null;
        IsTargeted = false;
        StopTargeting();
    }
    
    public virtual void StopTargeting()
    {
    }
    
    public virtual void OnTriggerGrab(Hand hand, Grabbable grabbable)
    {
        if (hand.holdingObj != null)
        {
            return;
        }
        IsPulling = true;
        _previousParent = _transformToMove.parent;
        _rotationOnGrab = _transformToMove.rotation;
        _transformToMove.SetParent(_currentSelectingHand.transform);
    }
 
    public virtual void OnTriggerReleased(Hand hand, Grabbable grabbable)
    {
        IsPulling = false; 
        OnStopTargeting(hand, grabbable);
        _transformToMove.SetParent(_previousParent);
        if (_rotationOnRelease == RotationOnRelease.Initial)
        {
            _transformToMove.rotation = _intitialRotation;
        }
        else if (_rotationOnRelease == RotationOnRelease.OnGrabStart)
        {
            _transformToMove.rotation = _rotationOnGrab;
        }
        else if (_rotationOnRelease == RotationOnRelease.LookAtCamera)
        {
            if (Camera.main != null)
            {
                Vector3 lookPosition = _transformToMove.position - Camera.main.transform.position;
                //don't change the up vector
                lookPosition.y = 0;
                if (_invertedForward)
                {
                    _transformToMove.rotation = Quaternion.LookRotation(lookPosition);
                }
                else
                {
                    _transformToMove.rotation = Quaternion.LookRotation(Vector3.Scale(lookPosition, new Vector3(-1, -1, -1)));
                }
            }
        }
    }
    
    
    private void OnTriggerPressed(Hand hand)
    {
        if (hand == _currentSelectingHand && IsTargeted)
        {
            OnTriggerGrab(_currentSelectingHand, null);
        }
    }
 
    private void OnTriggerReleased(Hand hand)
    {
        if (hand == _currentSelectingHand && IsTargeted)
        {
            OnTriggerReleased(_currentSelectingHand, null);
        }
    }
}