c# - Unity HTC VIVE 远距传送

Question

我正在为 HTC VIVE 开发并尝试创建一个传送脚本，当用户捕获某个对象时，该脚本允许用户传送到某个位置(由我预先定义)。我目前有一个传送代码，它像普通的传送器一样工作，用户指向一个位置，房间就会移动到那个位置。我对此进行了修改，以便无论用户指向何处，他们都将始终传送到特定位置。这是第一步，但我真的很想在用户拿起某个物体时触发这种传送，有没有人知道在哪里加注星标或如何执行此操作？

这是修改后的传送器的代码:

namespace VRTK{
using UnityEngine;
using System.Collections;

public delegate void TeleportEventHandler(object sender, DestinationMarkerEventArgs e);

public class VRTK_BasicTeleport : MonoBehaviour
{
    public float blinkTransitionSpeed = 0.6f;
    [Range(0f, 32f)]
    public float distanceBlinkDelay = 0f;
    public bool headsetPositionCompensation = true;
    public string ignoreTargetWithTagOrClass;
    public bool limitToNavMesh = false;

    public event TeleportEventHandler Teleporting;
    public event TeleportEventHandler Teleported;

    protected Transform eyeCamera;
    protected bool adjustYForTerrain = false;
    protected bool enableTeleport = true;

    private float blinkPause = 0f;
    private float fadeInTime = 0f;
    private float maxBlinkTransitionSpeed = 1.5f;
    private float maxBlinkDistance = 33f;

    public void InitDestinationSetListener(GameObject markerMaker)
    {
        if (markerMaker)
        {
            foreach (var worldMarker in markerMaker.GetComponents<VRTK_DestinationMarker>())
            {
                worldMarker.DestinationMarkerSet += new DestinationMarkerEventHandler(DoTeleport);
                worldMarker.SetInvalidTarget(ignoreTargetWithTagOrClass);
                worldMarker.SetNavMeshCheck(limitToNavMesh);
                worldMarker.SetHeadsetPositionCompensation(headsetPositionCompensation);
            }
        }
    }

    protected virtual void Start()
    {
        Utilities.SetPlayerObject(this.gameObject, VRTK_PlayerObject.ObjectTypes.CameraRig);

        adjustYForTerrain = false;
        eyeCamera = Utilities.AddCameraFade();

        InitDestinationMarkerListeners();
        InitHeadsetCollisionListener();

        enableTeleport = true;
    }

    protected void OnTeleporting(object sender, DestinationMarkerEventArgs e)
    {
        if (Teleporting != null)
            Teleporting(this, e);
    }

    protected void OnTeleported(object sender, DestinationMarkerEventArgs e)
    {
        if (Teleported != null)
            Teleported(this, e);
    }

    protected virtual void Blink(float transitionSpeed)
    {
        fadeInTime = transitionSpeed;
        SteamVR_Fade.Start(Color.black, 0);
        Invoke("ReleaseBlink", blinkPause);
    }

    protected virtual bool ValidLocation(Transform target)
    {
        //If the target is one of the player objects or a UI Canvas then it's never a valid location
        if(target.GetComponent<VRTK_PlayerObject>() || target.GetComponent<VRTK_UIGraphicRaycaster>())
        {
            return false;
        }

        bool validNavMeshLocation = false;
        if (target)
        {
            NavMeshHit hit;
            validNavMeshLocation = NavMesh.SamplePosition(target.position, out hit, 1.0f, NavMesh.AllAreas);
        }
        if (!limitToNavMesh)
        {
            validNavMeshLocation = true;
        }

        return (validNavMeshLocation && target && target.tag != ignoreTargetWithTagOrClass && target.GetComponent(ignoreTargetWithTagOrClass) == null);
    }

    protected virtual void DoTeleport(object sender, DestinationMarkerEventArgs e)
    {
        if (enableTeleport && ValidLocation(e.target) && e.enableTeleport)
        {
            OnTeleporting(sender, e);
            Vector3 newPosition = GetNewPosition(e.destinationPosition, e.target);
            CalculateBlinkDelay(blinkTransitionSpeed, newPosition);
            Blink(blinkTransitionSpeed);
            SetNewPosition(newPosition, e.target);
            OnTeleported(sender, e);
        }
    }

    protected virtual void SetNewPosition(Vector3 position, Transform target)
    {
        this.transform.position = CheckTerrainCollision(position, target);
    }

    protected virtual Vector3 GetNewPosition(Vector3 tipPosition, Transform target)
    {
        float newX = 0;
        float newY = 17;
        float newZ = 0;

        return new Vector3(newX, newY, newZ);
    }

    protected Vector3 CheckTerrainCollision(Vector3 position, Transform target)
    {
        if (adjustYForTerrain && target.GetComponent<Terrain>())
        {
            var terrainHeight = Terrain.activeTerrain.SampleHeight(position);
            position.y = (terrainHeight > position.y ? position.y : terrainHeight);
        }
        return position;
    }

    private void CalculateBlinkDelay(float blinkSpeed, Vector3 newPosition)
    {
        blinkPause = 0f;
        if (distanceBlinkDelay > 0f)
        {
            float distance = Vector3.Distance(this.transform.position, newPosition);
            blinkPause = Mathf.Clamp((distance * blinkTransitionSpeed) / (maxBlinkDistance - distanceBlinkDelay), 0, maxBlinkTransitionSpeed);
            blinkPause = (blinkSpeed <= 0.25 ? 0f : blinkPause);
        }
    }

    private void ReleaseBlink()
    {
        SteamVR_Fade.Start(Color.clear, fadeInTime);
        fadeInTime = 0f;
    }

    private void InitDestinationMarkerListeners()
    {
        var controllerManager = GameObject.FindObjectOfType<SteamVR_ControllerManager>();
        InitDestinationSetListener(controllerManager.left);
        InitDestinationSetListener(controllerManager.right);

        foreach (var destinationMarker in GameObject.FindObjectsOfType<VRTK_DestinationMarker>())
        {
            if (destinationMarker.gameObject != controllerManager.left && destinationMarker.gameObject != controllerManager.right)
            {
                InitDestinationSetListener(destinationMarker.gameObject);
            }
        }
    }

    private void InitHeadsetCollisionListener()
    {
        var headset = GameObject.FindObjectOfType<VRTK_HeadsetCollisionFade>();
        if (headset)
        {
            headset.HeadsetCollisionDetect += new HeadsetCollisionEventHandler(DisableTeleport);
            headset.HeadsetCollisionEnded += new HeadsetCollisionEventHandler(EnableTeleport);
        }
    }

    private void DisableTeleport(object sender, HeadsetCollisionEventArgs e)
    {
        enableTeleport = false;
    }

    private void EnableTeleport(object sender, HeadsetCollisionEventArgs e)
    {
        enableTeleport = true;
    }
}

这里是指针的代码:

namespace VRTK{
using UnityEngine;
using System.Collections;

public class VRTK_BezierPointer : VRTK_WorldPointer
{
    public float pointerLength = 10f;
    public int pointerDensity = 10;
    public bool showPointerCursor = true;
    public float pointerCursorRadius = 0.5f;
    public float beamCurveOffset = 1f;
    public GameObject customPointerTracer;
    public GameObject customPointerCursor;
    public LayerMask layersToIgnore = Physics.IgnoreRaycastLayer;

    private GameObject projectedBeamContainer;
    private GameObject projectedBeamForward;
    private GameObject projectedBeamJoint;
    private GameObject projectedBeamDown;

    private GameObject pointerCursor;
    private GameObject curvedBeamContainer;
    private CurveGenerator curvedBeam;

    // Use this for initialization
    protected override void Start()
    {
        base.Start();
        InitProjectedBeams();
        InitPointer();
        TogglePointer(false);
    }

    protected override void Update()
    {
        base.Update();
        if (projectedBeamForward.gameObject.activeSelf)
        {
            ProjectForwardBeam();
            ProjectDownBeam();
            DisplayCurvedBeam();
            SetPointerCursor();
        }
    }

    protected override void InitPointer()
    {
        pointerCursor = (customPointerCursor ? Instantiate(customPointerCursor) : CreateCursor());

        pointerCursor.name = string.Format("[{0}]WorldPointer_BezierPointer_PointerCursor", this.gameObject.name);
        Utilities.SetPlayerObject(pointerCursor, VRTK_PlayerObject.ObjectTypes.Pointer);
        pointerCursor.layer = LayerMask.NameToLayer("Ignore Raycast");
        pointerCursor.SetActive(false);

        curvedBeamContainer = new GameObject(string.Format("[{0}]WorldPointer_BezierPointer_CurvedBeamContainer", this.gameObject.name));
        Utilities.SetPlayerObject(curvedBeamContainer, VRTK_PlayerObject.ObjectTypes.Pointer);
        curvedBeamContainer.SetActive(false);
        curvedBeam = curvedBeamContainer.gameObject.AddComponent<CurveGenerator>();
        curvedBeam.transform.parent = null;
        curvedBeam.Create(pointerDensity, pointerCursorRadius, customPointerTracer);
        base.InitPointer();
    }

    protected override void SetPointerMaterial()
    {
        if (pointerCursor.GetComponent<Renderer>())
        {
            pointerCursor.GetComponent<Renderer>().material = pointerMaterial;
        }

        foreach (Renderer mr in pointerCursor.GetComponentsInChildren<Renderer>())
        {
            mr.material = pointerMaterial;
        }

        base.SetPointerMaterial();
    }

    protected override void TogglePointer(bool state)
    {
        state = (pointerVisibility == pointerVisibilityStates.Always_On ? true : state);

        projectedBeamForward.gameObject.SetActive(state);
        projectedBeamJoint.gameObject.SetActive(state);
        projectedBeamDown.SetActive(state);
    }

    protected override void DisablePointerBeam(object sender, ControllerInteractionEventArgs e)
    {
        base.DisablePointerBeam(sender, e);
        TogglePointerCursor(false);
        curvedBeam.TogglePoints(false);
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
        if (projectedBeamDown != null)
        {
            Destroy(projectedBeamDown);
        }
        if (pointerCursor != null)
        {
            Destroy(pointerCursor);
        }
        if (curvedBeam != null)
        {
            Destroy(curvedBeam);
        }
        if (projectedBeamContainer != null)
        {
            Destroy(projectedBeamContainer);
        }
        if (curvedBeamContainer != null)
        {
            Destroy(curvedBeamContainer);
        }
    }

    private GameObject CreateCursor()
    {
        var cursorYOffset = 0.02f;
        var cursor = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
        cursor.GetComponent<MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        cursor.GetComponent<MeshRenderer>().receiveShadows = false;
        cursor.transform.localScale = new Vector3(pointerCursorRadius, cursorYOffset, pointerCursorRadius);
        Destroy(cursor.GetComponent<CapsuleCollider>());
        return cursor;
    }

    private void TogglePointerCursor(bool state)
    {
        var pointerCursorState = (showPointerCursor && state ? showPointerCursor : false);
        var playAreaCursorState = (showPlayAreaCursor && state ? showPlayAreaCursor : false);
        pointerCursor.gameObject.SetActive(pointerCursorState);
        base.TogglePointer(playAreaCursorState);
    }

    private void InitProjectedBeams()
    {
        projectedBeamContainer = new GameObject(string.Format("[{0}]WorldPointer_BezierPointer_ProjectedBeamContainer", this.gameObject.name));
        Utilities.SetPlayerObject(projectedBeamContainer, VRTK_PlayerObject.ObjectTypes.Pointer);
        projectedBeamContainer.transform.parent = this.transform;
        projectedBeamContainer.transform.localPosition = Vector3.zero;

        projectedBeamForward = new GameObject(string.Format("[{0}]WorldPointer_BezierPointer_ProjectedBeamForward", this.gameObject.name));
        Utilities.SetPlayerObject(projectedBeamForward, VRTK_PlayerObject.ObjectTypes.Pointer);
        projectedBeamForward.transform.parent = projectedBeamContainer.transform;

        projectedBeamJoint = new GameObject(string.Format("[{0}]WorldPointer_BezierPointer_ProjectedBeamJoint", this.gameObject.name));
        Utilities.SetPlayerObject(projectedBeamJoint, VRTK_PlayerObject.ObjectTypes.Pointer);
        projectedBeamJoint.transform.parent = projectedBeamContainer.transform;
        projectedBeamJoint.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f);

        projectedBeamDown = new GameObject(string.Format("[{0}]WorldPointer_BezierPointer_ProjectedBeamDown", this.gameObject.name));
        Utilities.SetPlayerObject(projectedBeamDown, VRTK_PlayerObject.ObjectTypes.Pointer);
    }

    private float GetForwardBeamLength()
    {
        var actualLength = pointerLength;
        Ray pointerRaycast = new Ray(transform.position, transform.forward);
        RaycastHit collidedWith;
        var hasRayHit = Physics.Raycast(pointerRaycast, out collidedWith, pointerLength, ~layersToIgnore);

        //reset if beam not hitting or hitting new target
        if (!hasRayHit || (pointerContactTarget && pointerContactTarget != collidedWith.transform))
        {
            pointerContactDistance = 0f;
        }

        //check if beam has hit a new target
        if (hasRayHit)
        {
            pointerContactDistance = collidedWith.distance;
        }

        //adjust beam length if something is blocking it
        if (hasRayHit && pointerContactDistance < pointerLength)
        {
            actualLength = pointerContactDistance;
        }

        return actualLength;
    }

    private void ProjectForwardBeam()
    {
        var setThicknes = 0.01f;
        var setLength = GetForwardBeamLength();
        //if the additional decimal isn't added then the beam position glitches
        var beamPosition = setLength / (2 + 0.00001f);

        projectedBeamForward.transform.localScale = new Vector3(setThicknes, setThicknes, setLength);
        projectedBeamForward.transform.localPosition = new Vector3(0f, 0f, beamPosition);
        projectedBeamJoint.transform.localPosition = new Vector3(0f, 0f, setLength - (projectedBeamJoint.transform.localScale.z / 2));
        projectedBeamContainer.transform.localRotation = Quaternion.identity;
    }

    private void ProjectDownBeam()
    {
        projectedBeamDown.transform.position = new Vector3(projectedBeamJoint.transform.position.x, projectedBeamJoint.transform.position.y, projectedBeamJoint.transform.position.z);

        Ray projectedBeamDownRaycast = new Ray(projectedBeamDown.transform.position, Vector3.down);
        RaycastHit collidedWith;

        var downRayHit = Physics.Raycast(projectedBeamDownRaycast, out collidedWith, float.PositiveInfinity, ~layersToIgnore);

        if (!downRayHit || (pointerContactTarget && pointerContactTarget != collidedWith.transform))
        {
            if (pointerContactTarget != null)
            {
                base.PointerOut();
            }
            pointerContactTarget = null;
            destinationPosition = Vector3.zero;
        }

        if (downRayHit)
        {
            projectedBeamDown.transform.position = new Vector3(projectedBeamJoint.transform.position.x, projectedBeamJoint.transform.position.y - collidedWith.distance, projectedBeamJoint.transform.position.z);
            projectedBeamDown.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
            pointerContactTarget = collidedWith.transform;
            destinationPosition = projectedBeamDown.transform.position;

            base.PointerIn();
        }
    }

    private void SetPointerCursor()
    {
        if (pointerContactTarget != null)
        {
            TogglePointerCursor(true);
            pointerCursor.transform.position = projectedBeamDown.transform.position;
            base.SetPlayAreaCursorTransform(pointerCursor.transform.position);
            UpdatePointerMaterial(pointerHitColor);
        }
        else
        {
            TogglePointerCursor(false);
            UpdatePointerMaterial(pointerMissColor);
        }
    }

    private void DisplayCurvedBeam()
    {
        Vector3[] beamPoints = new Vector3[]
        {
            this.transform.position,
            projectedBeamJoint.transform.position + new Vector3(0f, beamCurveOffset, 0f),
            projectedBeamDown.transform.position,
            projectedBeamDown.transform.position,
        };

        curvedBeam.SetPoints(beamPoints, pointerMaterial);
        if (pointerVisibility != pointerVisibilityStates.Always_Off)
        {
            curvedBeam.TogglePoints(true);
        }
    }
}
}

Answer 1

你是如何尝试挑选对象的。您是使用某种射线转换还是只是碰撞？然而，无论您想在拾取对象时触发传送，都应该像从用于拾取对象的任何脚本调用传送脚本一样简单。例如:

void OnTriggerEnter(Collider other) 
    {
        if (other.gameObject.CompareTag ("Pick Up"))
        {
            <<call your teleport script here>>
        }
    }

Unity 有非常好的脚本文档，您可以找到很多解释基础知识的教程，即使您阅读了其中的一个，您应该能够相对轻松地完成大部分您想做的事情。