C# Unity HTC VIVE隐形传送

我正在为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;
    }
}

名称空间VRTK{
使用UnityEngine；
使用系统集合；
公共委托void TeleportEventHandler（对象发送方、目标市场eventargs e）；
公共类VRTK_基本要素报告：单一行为
{
公共浮动闪烁转换速度=0.6f；
[射程（0f，32f）]
公共浮动距离闪烁延迟=0f；
公共bool头戴式耳机位置补偿=真；
公共字符串ignoreTargetWithTagOrClass；
公共bool limitToNavMesh=false；
公共事件远程传送；文坦德勒远程传送；
公共事件远程传送；远程传送；
保护变换摄像机；
受保护的bool adjustYForTerrain=假；
受保护的bool enableTeleport=true；
专用浮点闪烁暂停=0f；
专用浮点fadeInTime=0f；
专用浮点maxBlinkTransitionSpeed=1.5f；
专用浮点数maxBlinkDistance=33f；
public void InitDestinationSetListener（游戏对象标记器）
{
if（markerMaker）
{
foreach（markerMaker.GetComponents（）中的var worldMarker）
{
worldMarker.DestinationMarkerSet+=新的DestinationMarkerEventHandler（DoTeleport）；
worldMarker.SetInvalidTarget（ignoreTargetWithTagOrClass）；
worldMarker.SetNavMeshCheck（limitToNavMesh）；
worldMarker.SetHeadsetPositionCompension（头位置补偿）；
}
}
}
受保护的虚拟void Start（）
{
实用程序.SetPlayerObject（this.gameObject，VRTK_PlayerObject.ObjectTypes.CameraRig）；
adjustYForTerrain=假；
eyeCamera=Utilities.AddCameraFade（）；
InitDestinationMarkerListeners（）；
InitHeadsetCollisionListener（）；
enableTeleport=true；
}
受保护的void OnTeleporting（对象发送方、目标MarkerEventargs e）
{
if（远程传送！=null）
远程传送（本，e）；
}
受保护的无效OnTeleported（对象发送方、目标MarkerEventArgs e）
{
如果（远程传输！=null）
远程传送（这个，e）；
}
受保护的虚拟无效闪烁（浮动转换速度）
{
fadeInTime=转换速度；
SteamVR_淡入淡出开始（Color.black，0）；
调用（“释放闪烁”，闪烁暂停）；
}
受保护的虚拟布尔有效位置（转换目标）
{
//如果目标是播放器对象或UI画布之一，则它永远不是有效位置
if（target.GetComponent（）| target.GetComponent（））
{
返回false；
}
bool validNavMeshLocation=false；
如果（目标）
{
导航命中命中；
validNavMeshLocation=NavMesh.SamplePosition（目标位置，命中率，1.0f，NavMesh.AllAreas）；
}
如果（！limitToNavMesh）
{
validNavMeshLocation=true；
}
返回（validNavMeshLocation&&target&&target.tag！=ignoreTargetWithTagOrClass&&target.GetComponent（ignoreTargetWithTagOrClass）==null）；
}
受保护的虚拟void DoTeleport（对象发送方、目标MarkerEventargs e）
{
if（启用远程传送和有效定位（e.target）和e.enableTeleport）
{
OnTeleporting（发送方，e）；
Vector3 newPosition=GetNewPosition（如destinationPosition，如target）；
计算链路延迟（闪烁转换速度、新位置）；
闪烁（闪烁转换速度）；
设置新位置（新位置，例如目标）；
onteleport（发送方，e）；
}
}
受保护的虚拟void SetNewPosition（向量3位置，变换目标）
{
this.transform.position=检查地形碰撞（位置、目标）；
}
受保护的虚拟向量3 GetNewPosition（向量3预设，变换目标）
{
float newX=0；
float newY=17；
float newZ=0；
返回新矢量3（newX、newY、newZ）；
}
受保护矢量3检查地形碰撞（矢量3位置，变换目标）
{
if（adjustYForTerrain&&target.GetComponent（））
{
var terrainHeight=Terrain.activeTerrain.SampleHeight（位置）；
position.y=（地形高度>position.y？position.y：地形高度）；
}
返回位置；
}
私有无效计算链接延迟（浮动闪烁速度，矢量3新位置）
{
闪烁暂停=0f；
如果（距离闪烁延迟>0f）
{
浮动距离=矢量3.距离（this.transform.position，newPosition）；
blinkPause=Mathf.Clamp（（距离*blinkTransitionSpeed）/（maxBlinkDistance-距离BlinkDelay），0，maxBlinkTransitionSpeed）；
blinkPause=（blinkSpeed您是如何尝试拾取对象的。您是使用某种光线投射还是仅在碰撞时拾取？然而，无论您想在拾取对象时触发远程传送，都应该简单到从用于拾取对象的任何脚本调用远程传送脚本。
例如：

void ontriggenter（碰撞器其他）
{
if（other.gameObject.CompareTag（“拾取”））
{
}
}

Unity有很好的脚本文档，你可以找到很多解释基本知识的教程，即使你读了其中的一个，你也应该能够做更多的工作
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);
        }
    }
}
}

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