《SteamVR实战之PMCore》

版本

作者

参与者

完成日期

备注

SteamVRPro_PMCore_V01_1.0

严立钻

2019.04.22

#第一篇：PMCore目录结构

##A.01、Art/

###A.01.01、E1/

//\Assets\E1\Scripts\Rsk\Dismantle\DismantleLoadAndCreate.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

//立钻哥哥：负责生成学习模型（模型的命名为当前实验的ID）

public class DismantleLoadAndCreate : MonoSingleton<DismantleLoadAndCreate>{

    public GameObject prefab;

    private void Start(){

        string path = string.Format(“Exprement/DismantlePrefabs/{0}”, CurrentInfo.currentExp.exp_id);

        Debug.Log(“立钻哥哥：打印路径 ” + path);

        prefab = GameObject.Instantiate(Resources.Load<GameObject>(path));

        prefab.name = CurrentInfo.currentExp.exp_id;

    }

    public void Fun(){

    }

}    //立钻哥哥：public class DismantleLoadAndCreate:MonoSingleton<>{}

//\Assets\E1\Scripts\LearnProcess.cs

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class LearnProcess : MonoBehaviour{

    void Start(){

        ProcessManager.instance.ShowButtonForLearn();

    }    //立钻哥哥：void Start(){}

}    //立钻哥哥：public class LearnProcess:MonoBehaviour{}

###A.01.02、E2/

###A.01.03、Effect/

###A.01.04、Font/

###A.01.05、Models/

###A.01.06、Scenes/

using MCS.WebApi.Models;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Valve.Newtonsoft.Json;

public class TestScript : MonoBehaviour{

    void Start(){

        UI_Manager.Instance.OpenPanel(PanelType.LogOnPanel);

    }

}    //立钻哥哥：public class TestScript:MonoBehaviour{}

###A.01.07、SKY/

###A.01.08、UI/

##A.02、E1/

###A.02.01、Prefabs/

using UnityEngine;

using UnityEngine.SceneManagement;

using UnityEngine.VR;

using System;

using DG.Tweening;

namespace Valve.VR.InteractionSystem{

    //立钻哥哥改写的[Player_VR]

    public class Player_VR : MonoBehaviour{

        public static Player_VR Instance;

        public Transform head;

        public Camera Main;

        [SerializeField]

        public Transform camRig;

        float renderScale;

        public GameObject leftHand;    //左手模型

        public GameObject rightHand;    //右手模型

        public Transform root;

        private void Awake(){

            Instance = this;

        }

        public void ReSetCamRig(){

            camRig.SetParent(root);

            camRig.transform.localEulerAngles = Vector3.zero;

            camRig.transform.localPosition = Vector3.zero;

            camRig.transform.localScale = Vector3.one;

        }

        public void CamRigGoto(){

            camRig.position = desPosition;

        }

        public void CamRigGoRoat(Vector3 roat){

            camRig.eulerAngles = roat;

        }

        //立钻哥哥：以头为基准移动

        //[headPositon]: 想要让头去的位置（世界坐标）

        public void HeadGoTo(Vector3 headPosition){

            if(head){

               camRig.position = headPosition - (head.position - camRig.position);

            }

        }

        public void HeadGoTo(Vector3 headPosition, float time, TweenCallback ac=null){

            if(head){

                Vector3 pos = headPosition - (head.positon - camRig.position);

                camRig.DOMove(pos, time).OnComplete(ac);

            }

        }

        //以头为基准旋转

        //[headRotation]: 头将要去的旋转（世界旋转）

        public void HeadRotate(){

            if(head){

                Vector3 deltaAngleY = new Vector3(0, (camRig.eulerAngles - head.eulerAngles).y, 0);

                camRig.rotation = headRotation * Quaternion.Euler(deltaAngleY);

            }

        }

        //把头移动到指定地点并且旋转到指定方向

        //[headPosition]: 想要让头去的位置；

        //[headRotation]: 头将要去到的旋转；

        //[isImmediately]: 是否瞬移（默认为否）；

        //[time]: 如果不瞬移，time代表缓慢移动到目标点的时间

        public void HeadGoToAndRotate(Vector3 headPosition, Quaternion headRotation, bool isImmediately=false, float time=1f){

            HeadRotate(headRotation);

            if(isImmediately){

                HeadGoTo(headPosition);

            }else{

                HeadGoTo(headPosition, time);

            }

        }

    }    //立钻哥哥：public class Player_VR:MonoBehaviour{}

}    //立钻哥哥：namespace Valve.VR.InteractionSystem{}

++知识点01：HeadGoTo（以头为基准移动）

++++立钻哥哥：public void HeadGoTo(Vector3 headPosition){}

++++HeadGoTo(headPosition);

++知识点02：HeadGoTo（以头为基准移动）

++++立钻哥哥：public void HeadGoTo(Vector3 headPosition, float time, TweenCallback ac=null){}

++++HeadGoTo(headPosition, time);

++知识点03：HeadRotate（以头为基准旋转）

++++立钻哥哥：public void HeadRotate(Quaternion headRotation){}

++++HeadRotate(headRotation);

//立钻哥哥：拆解脚本

[RequireComponent(typeof(InteractableObject))]

public class Dismantle : BaseDisintegrateAction{}

++++Player_VR playerInstance;

++++playerInstance = Player_VR.Instance;

//立钻哥哥：背包系统

public class InventoryContentItemBorder : MonoBehaviour{}

++++InteractGrab temp = Player_VR.Instance.rightHand.GetComponentInChildren<InteractGrab>();

//立钻哥哥：缩放脚本：获取两手距离，用于计算当前物体的缩放程度

[RequireComponent(typeof(InteractableObject))]

public class Scaling : BaseDisintegrateAction{}

++++Player_VR playerInstance;

++++playerInstance = Player_VR.Instance;

//立钻哥哥：主菜单控制器

public class MainMenuController : MonoSingleton<MainMenuController>{}

++++mainMenuFollowPoint.transform.position = Player_VR.Instance.transform.position;

++++mainMenuFollowPoint.transform.rotation = Player_VR.Instance.transform.rotation;

++++mainMenuFollowPoint.transform.SetParent(Player_VR.Instance.transform);

//Extension of GraphicRaycaster to support ray casting with world space rays instead of just screen-space pointer positions.（立钻哥哥：GraphicRaycaster的扩展，支持使用世界空间射线进行光线投射，而不仅仅是屏幕空间指针的位置）

[RequireComponent(typeof(Canvas))]

public class OVRRaycaster : GraphicRaycaster, IPointerEnterHandler{}

++++canvas.worldCamera = Valve.VR.InteractionSystem.Player_VR.Instance.head.GetComponent<Camera>();

++++private void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList, Ray ray, bool checkForBlocking){}

//立钻哥哥：namespace Valve.VR.InteractionSystem{}

public class RenderModel : MonoBehaviour{}

++++handSkeleton.origin = Player_VR.Instance.root;

//Purpose: Collider dangling from the player’s head.（立钻哥哥：目的:碰撞器悬挂在玩家的头部.）

using UnityEngine;

using System.Collections;

namespace Valve.VR.InteractionSystem{

    [RequireComponent(typeof(CapsuleCollider))]

    public class BodyCollider : MonoBehaviour{

        public Transform head;

        private CapsuleCollider capsuleCollider;

        void Awake(){

            capsuleCollider = GetComponent<CapsuleCollider>();

        }

        void FixedUpdate(){

            float distanceFromFloor = Vector3.Dot(head.localPosition, Vector3.up);

            capsuleCollider.height = Mathf.Max(capsuleCollider.radius, distanceFromFloor);

            transform.localPosition = head.localPosition - 0.5f * distanceFromFloor * Vector3.up;

        }

    }    //立钻哥哥：public class BodyCollider:MonoBehaviour{}

}    //立钻哥哥：namesapce Valve.VR.InteractionSystem{}

using System;

using System.Threading;

using UnityEngine;

using UnityEngine.Events;

using Valve.VR;

namespace Valve.VR{

    //This component simplifies the use of Pose actions. Adding it to a gameobject will auto set that transform’s position and rotation every update to match the pose. Advanced velocity estimation is handled through a buffer of the last 30 updates.（立钻哥哥：这个组件简化了姿态动作的使用。将其添加到gameobject将自动设置转换位置并在每次更新时旋转以匹配该姿态。高级速度估计是通过最近30次更新的缓冲区来处理的.）

    public class SteamVR_Behaviour_Pose : MonoBehaviour{}

}    //立钻哥哥：namespace Valve.VR{}

//立钻哥哥：提供分解操作

using UnityEngine;

using Valve.VR;

namesapce YanlzXR.VR.InteractSystem{

    public class InteractDisintegrate : MonoBehaviour{}

}    //立钻哥哥：namesapace YanlzXR.VR.InteractSystem{}

//立钻哥哥：抓握交互

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Valve.VR;

using Valve.VR.InteractionSystem;

namespace YanlzXR.VR.InteractionSystem{

    public class InteractGrab : MonoBehaviour{}

}    //立钻哥哥：namespace YanlzXR.VR.InteractionSystem{}

//立钻哥哥：触摸交互

using System.Collection;

using System.Collections.Generic;

using UnityEngine;

namesapce YanlzXR.VR.InteractSystem{

    public class InteractTouch : MonoBehaviour{}

}    //立钻哥哥：namespace YanlzXR.VR.InteractSystem{}

//立钻哥哥：射线交互类

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

namespace YanlzXR.VR.InteractSystem{

    public class InteractRaycaster : MonoBehaviour{

        //立钻哥哥：射线打到的所有物体

        [HideInInspector]

        public RaycastHit[] raycastResult;

        //立钻哥哥：射线忽略层

        public LayerMask rayCastLayerMask = ~(1 << 0);

        private OVRRayTransform uiRayTransform;

        protected virtual void Awake(){

            uiRayTransform = GetComponent<OVRRayTransform>();

        }

        public virtual void GetRaycastResult(){

            raycastResult = Physics.RaycastAll(transform.position, transform.forward, 100, rayCastLayerMask);

        }

        private void Update(){

            if(uiRayTransform == null){

                GetRaycastReult();

            }

       }

    }    //立钻哥哥：public class InteractRaycaster:MonoBehaviour{}

}    //立钻哥哥：namespace YanlzXR.VR.InteractSystem{}

//立钻哥哥：手控制器

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Valve.VR;

namespace YanlzXR.VR.InteractSystem{

    public class HandController : MonoBehaviour{

        public SteamVR_Input_Sources input_Sources;

        public GameObject renderModelPrefab;

        private void Start(){

            InitController();

        }

        private void InitController(){

            GameObject renderModelInstance = GameObject.Instantiate(renderModelPrefab);

            renderModelInstance.layer = gameObject.layer;

            renderModelInstance.tag = gameObject.tag;

            renderModelInstance.transform.parent = this.transform;

            renderModelInstance.transform.localPosition = Vector3.zero;

            renderModelInstance.transform.localRotation = Quaternion.indentity;

            renderModelInstance.transform.localScale = renderModelPrefab.transform.localScale;

            renderModelInstance.GetComponent<Valve.VR.InteractionSystem.RenderModel>().Show();

        }

    }    //立钻哥哥：public class HandController:MonoBehaviour{}

}    //立钻哥哥：namespace YanlzXR.VR.InteractSystem{}

using YanlzXR.VR.InteractSystem;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Valve.VR;

public class UITouch : MonoBehaviour{

    //立钻哥哥：当前被Touch的物体

    public MainMenuInteractable currentTouchObject;

    public HandController handController;

    private InteractRaycaster raycaster;

    [HideInInspector]

    public readonly List<MainMenuInteractable> interactableObjs = new List<MainMenuInteractable>();

    public SteamVR_Action_Boolean grabAction = SteamVR_Input.GetAction<SteamVR_Action_Boolean>(“InteractUI”);

    private void Awake(){}

    private void Update(){}

    private void OnEnable(){}

    private void OnDisable(){}

    //立钻哥哥：处理射线打到的物体

    private void ProcessInteractObjects(){}

    //立钻哥哥：射线投射获取InteractObject

    protected virtual void RayCastGetInteractObject(){}

    protected virtual void TouchedObject(){}

    protected virtual void UnTouchObject(){}

    protected virtual void InteractDown(SteamVR_Action_Boolean fromAction, SteamVR_Input_Sources fromSource){}

    protected virtual void InteractUp(SteamVR_Action_Boolean fromAction, SteamVR_Input_Sources fromSource){}

}    //立钻哥哥：public class UITouch:MonoBehaviour{}

//Purpose: Highlights the controller when hovering over interactables.（立钻哥哥：用途:悬停在interactables上时突出显示控制器.）

using UnityEngine;

using System.Collections;

namespace Valve.VR.InteractionSystem{

    public class ControllerHoverHightlight : MonoBehaviour{

        public Material highLightMaterial;

        public bool fireHapticsOnHightlight = true;

        protected Hand hand;

        protected RenderModel renderModel;

        protected SteamVR_Events.Action renderModelLoadedAction;

        protected void Awake(){}

        protected void OnHandInitialized(int deviceIndex){}

        private void RenderModel_onControllerLoaded(){}

        protected void OnParentHandHoverBegin(Interactable other){}

        private void OnParentHandHoverEnd(Interactable other){}

        private void OnParentHandInputFocusAcquired(){}

        private void OnParentHandInputFocusLost(){}

        public void ShowHighlight(){}

        public void HideHighlight(){}

    }    //立钻哥哥：public class ControllerHoverHightlight:MonoBehaviour{}

}    //立钻哥哥：namespace Valve.VR.InteractionSystem{}

//Purpose: Displays text and button hints on the controllers.（立钻哥哥：用途:在控制器上显示文本和按钮提示）

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using UnityEngine.UI;

using System.Text;

namespace Valve.VR.InteractionSystem{

    public class ControllerButtonHints : MonoBehaviour{

        public Material controllerMaterial;

        public Color flashColor = new Color(1.0f, 0.557f, 0.0f);

        public GameObject textHintPrefab;

        public SteamVR_Action_Vibration hapticFlash = SteamVR_Input.GetAction<SteamVR_Action_Vibration>(“Haptic”);

        //Info for each of the buttons.（立钻哥哥：每个按钮的信息.）

        private class ActionHintInfo{}

        private Dictionary<ISteamVR_Action_In_Source, ActionHintInfo> actionHintInfos;

        SteamVR_Events.Action renderModelLoadedAction;

        protected SteamVR_Input_Sources inputSource;

        void Awake(){}

        void Start(){}

        private void HintDebugLog(string msg){}

        void OnEnable(){}

        void OnDisable(){}

        private void OnParentHandInputFocusLost(){}

        public virtual void SetInputSource(SteamVR_Input_Sources newInputSource){}

        //Gets called when the hand has been initialized and a render model has been set.（立钻哥哥：在初始化手并设置呈现模型时调用.）

        private void OnHandInitialized(int deviceIndex){}

        void OnRenderModelLoaded(SteamVR_RenderModel renderModel, bool succeess){}

        private IEnumerator DoInitialize(SteamVR_RenderModel renderModel){}

        private void CreateAndAddButtonInfo(ISteamVR_Action_In action, SteamVR_Input_Sources inputSource){}

        private void ComputeTextEndTransforms(){}

        private void ShowButtonHint(params ISteamVR_Action_In_Source[] actions){}

        private void HideAllButtonHints(){}

        private void HideButtonHint(params ISteamVR_Action_In_Source[] actions){}

        private bool IsButtonHintActive(ISteamVR_Action_In_Source action){}

        private IEnumerator TestButtonHints(){}

        private IEnumerator TestTextHints(){}

        void Update(){}

        private void UpdateTextHint(ActionHintInfo hintInfo){}

        private void Clear(){}

        private void ShowText(ISteamVR_Action_In_Source action, string text, bool highlightButton=true){}

        private void HideText(ISteamVR_Action_In_Source action){}

        private void HideAllText(){}

        private string GetActiveHintText(ISteamVR_Action_In_Source action){}

        private static ControllerButtonHints GetControllerButtonHints(Hand hand){}

        public static void ShowButtonHint(Hand hand, params ISteamVR_Action_In_Source[] actions){}

        public static void HideButtonHint(Hand hand, params ISteamVR_Action_In_Source[] actions){}

        public static void HideAllButtonHints(Hand hand){}

        pubic static bool IsButtonHintActive(Hand hand, ISteamVR_Action_In_Source action){}

        public static void ShowTextHint(Hand hand, ISteamVR_Action_In_Source action, string text, bool highlightButton=true){}

        public static void HideTextHint(Hand hand, ISteamVR_Action_In_Source action){}

        public static void HideAllTextHints(Hand hand){}

        public static string GetActiveHintText(Hand hand, ISteamVR_Action_In_Source action){}

    }    //立钻哥哥：public class ControllerButtonHints:MonoBehaviour{}

}    //立钻哥哥：namespace Valve.VR.InteractionSystem{}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using YanlzXR.VR.InteractionSystem;

using UnityEngine.EventSystems;

public class RayController : MonoBehaviour{

    protected LineRenderer lineRenderer;

    public float lineWidth = 0.01f;

    public Color nonObject_Color = Color.blue;

    public Color interactable_Color = Color.green;

    public Color unInteractable_Color = Color.red;

    protected InteractRaycaster interactRaycaster;

    protected InteractGrab interactGrab;

    private OVRRayTransform uiRay;

    private void Awake(){

        GetLineRenderer();

        interactRaycaster = GetComponentInParent<InteractRaycaster>();

        uiRay = GetComponentInParent<OVRRayTransform>();

        interactGrab = GetComponentInParent<InteractGrab>();

    }

    void Start(){

        InitLineRender();

    }

    protected virtual void GetLineRenderer(){

        lineRenderer = GetComponent<LineRenderer>();

        if(lineRenderer == null){

            lineRenderer = gameObject.AddComponent<LineRenderer>();

        }

    }

    protected virtual void InitLineRender(){

        lineRenderer.useWorldSpace = false;

        lineRenderer.positionCount = 2;

        lineRenderer.startWidth = lineWidth;

        lineRenderer.endWithth = lineWidth;

    }

    private void Update(){

        UpdateLinePosition();

        UpdateLineColor();

    }

    protected virtual void UpdateLinePosition(){

        lineRenderer.SetPosition(0, Vector3.zero);

        if(OVRInputModule.currentRayCastResult.gameObject != null && uiRay && !interactGrab.GetGrabbedObject){

            lineRenderer.SetPosition(1, Vector3.forward * OVRInputModule.currentRayCastResult.distance);

        }else if(interactGrab.GetGrabbedObject()){

            lineRenderer.SetPosition(1, Vector3.forward * interactGrab.GetGrabbedObject().hitDistance);

        }else if(interactRaycaster.raycastResult != null  && interactRaycaster.raycastResult.Length > 0 && interactRaycaster.raycastResult.Length > 0){

            lineRenderer.SetPosition(1, Vector3.forward * interactRaycaster.raycastResult[0].distance);

        }else{

            lineRenderer.SetPosition(1, Vector3.forward * 1);

        }

    }    //立钻哥哥：protected virtual void UpdateLinePosition(){}

    protected virtual void UpdateLineColor(){

        if(OVRInputModule.currentRayCastResult.gameObject != null && uiRay){

            SetColor(interactable_Color);

            return;

        }

        if((interactGrab.GetGrabbedObject())){

            SetColor(interactable_Color);

            return;

        }

        if(interactRaycaster.raycastResult == null || interactRaycaster.raycastResult.Length == 0){

            SetColor(nonObject_Color);

            return;

        }

        InteractableObject obj = interactRaycaster.raycastResult[0].transform.GetComponent<InteractableObject>();

        if(obj != null && obj.isInteractable){

            SetColor(interactable_Color);

        }else{

            SetColor(unInteractable_Color);

        }

    }    //立钻哥哥：protected virtual void UpdateLineColor(){}

    public virtual void SetColor(Color color){

        lineRenderer.material.SetColor(“_TintColor”, color);

    }

}    //立钻哥哥：public class RayController:MonoBehaivour{}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class OVRRayTransform : MonoBehaviour{

    public static OVRRayTransform Instance;

    public void Awake(){

        if(Instance == null){

            Instance = this;

        }

    }

    public Vector3 Dir{

        get{  return transform.forward;  }

    }

}    //立钻哥哥：public class OVRRayTransform:MonoBehaviour{}

//VR extension of PointerInputModule which supports gaze and controller pointing.（立钻哥哥：支持凝视和控制器指向的PointerInputModule的VR扩展）

public class OVRInputModule : PointerInputModule{}

++++leftData.worldSpaceRay = new Ray(OVRRayTransform.Instance.transform.position, OVRRayTransform.Instance.Dir);

++++if(OVRRayTransform.Instance){}

++++YanlzXR.VR.InteractSystem.InteractRaycaster interactRaycaster = OVRRayTransform.Instance.GetComponent<YanlzXR.VR.InteractSystem.InteractRaycaster>();

++++float uiDistance = (raycast.gameObject.transform.position - OVRRayTransform.Instance.transform.position).sqrMagnitude;

++++float objectDistance = (interactRaycaster.raycastResult[0].point - OVRRayTransform.Instance.transform.position).sqrMagnitude;

//立钻哥哥：射线交互

public class InteractRaycaster : MonoBehaviour{}

++++private OVRRayTransform uiRayTransform;

++++uiRayTransform = GetComponent<OVRRayTransform>();

//立钻哥哥：射线控制

public class RayController : MonoBehaviour{}

++++private OVRRayTransform uiRay;

++++uiRay = GetComponentInParent<OVRRayTransform>();

using System;

using System.Collections.Generic;

using Valve.VR;

namespace UnityEngine.EventSystems{

    //VR extension of PointerInputModule which supports gaze and controller pointing.（立钻哥哥：支持凝视和控制器指向的PointerInputModule的VR扩展.）

    public class OVRInputModule : PointerInputModule{

        public Valve.VR.SteamVR_Action_Boolean confirmAction = SteamVR_Input.GetAction<SteamVR_Action_Boolean>(“InteractUI”, “Confirm”);

        public SteamVR_Input_Sources inputSource = SteamVR_Input_Sources.RightHand;

        public SteamVR_ActionSet ui_InputAction = SteamVR_Input.GetActionSet(“InteractUI”);

        protected override void Start(){}

        //Convenience function for cloning PointerEventData.（立钻哥哥：方便的功能克隆PointerEventData.）

        protected void CopyFromTo(OVRPointerEventData @from, OVRPointerEventData @to){}

        protected new void CopyFromTo(PointerEventData @from, PointerEventData @to){}

        //For RectTransform, calculate it’s normal in world space.（立钻哥哥：对于RectTransform，计算它在世界空间中的法线.）

        static Vector3 GetRectTransformNormal(RectTransform rectTransform){}

        //State for a pointer controlled by a world space ray. E.g. gaze pointer.（立钻哥哥：由世界空间射线控制的指针的状态。如目光指针.）

        virtual protected MouseState GetGazePointerData(){}

        //Get state for pointer which is a pointer moving in world space across the surface of a world space canvas.（立钻哥哥：获取指针的状态，该指针在世界空间中移动，穿过世界空间画布的表面.）

        protected MouseState GetCanvasPointerData(){}

        //New version of “ShouldStartDrag” implemented first in “PointerInputModule”. This version differs in that for ray based pointers it makes a decision about whether a drag should start based on the angular change to pointer has made so far, as seen from the camera. This also works when the world space ray is translated rather than rotated, since the beginning and end of the movement are considered as angle from the same point.（立钻哥哥：新版本的“ShouldStartDrag”首先在“PointerInputModule”中实现。这个版本的不同之处在于，对于基于光线的指针，它根据到目前为止指针的角度变化来决定是否应该开始拖动，就像从摄像机中看到的那样。当世界空间射线被平移而不是旋转时也是如此，因为运动的开始和结束被认为是从同一点出发的角度.）

        private bool ShouldStartDrag(PointerEventData pointerEvent){}

        //The purpose of this function is to allow us to switch between using the standard “IsPointerMoving” method for mouse driven pointers, but to always return true when it’s a ray based pointer. All real-world ray-based input devices are always moving so for simplicity we just return true for them. (If PointerEventData.IsPointerMoving was virtual we could just override that in “OVRRayPointerEventData”.)（立钻哥哥：这个函数的目的是允许我们在使用鼠标驱动指针的标准“IsPointerMoving”方法之间进行切换，但是当它是基于光线的指针时，总是返回true。所有实际的基于ray的输入设备总是在移动，为了简单起见，我们只返回true。(如果PointerEventData.IsPointerMoving是virtual虚函数的，我们可以在“OVRRayPointerEventData”中重写它。)）

        static bool IsPointerMoving(PointerEventData pointerEvent){}

        protected Vector2 SwipeAdjustedPosition(Vector2 originalPosition, PointerEventData pointerEvent){}

        //Exactly the same as the code from “PointerInputModule”, except that we call our own “IsPointerMoving”. (This would also not be necessary if “PointerEventData.IsPointerMoving” was virtual.)（立钻哥哥：与“PointerInputModule”中的代码完全相同，只是我们将自己的代码称为“IsPointerMoving”。(如果“PointerEventData.IsPointerMoving”是virtual虚函数，也不需要这样做)）

        protected override void ProcessDrag(PointerEventData pointerEvent){}

        //Get state of button corresponding to gaze pointer.（立钻哥哥：获取与凝视指针对应的按钮状态.）

        virtual protected PointerEventData.FramePressState GetGazeButtonState(){}

        //Get extra scroll delta from gamepad.（立钻哥哥：从gamepad获得额外的滚动增量.）

        protected Vector2 GetExtraScrollDelta(){}

    }    //立钻哥哥：public class OVRInputModule:PointerInputModule{}

}    //立钻哥哥：namespace UnityEngine.EventSystems{}

using System;

using System.Text;

using UnityEngine;

using UnityEngine.Assertions;

namespace UnityEngine.EventSystems{

    //Extension of Unity’s “PointerEventData” to support ray based pointing and also touchpad swiping.（立钻哥哥：Unity的“PointerEventData”的扩展，支持基于光线的指向和触摸板的滑动.）

    public class OVRPointerEventData : PointerEventData{

        public OVRPointerEventData(EventSystem eventSystem) : base(eventSystem){}

        public Ray worldSpaceRay;

        public Vector2 swipeStart;

        public override string ToString(){}

    }    //立钻哥哥：public class OVRPointerEventData:PointerEventData{}

    //Static helper for “OVRPointerEventData”.（立钻哥哥：用于“OVRPointerEventData”的静态助手.）

    public static class PointerEventDataExtension{

        public static bool IsVRPointer(this PointerEventData pointerEventData){

            return (pointerEventData is OVRPointerEventData);

        }

        public static Ray GetRay(this PointerEventData pointerEventData){

            OVRPointerEventData vrPointerEventData = pointerEventData as OVRPointerEventData;

            Assert.IsNotNull(vrPointerEventData);

            return vrPointerEventData.worldSpaceRay;

        }

        public static Vector2 GetSwipeStart(this PointerEventData pointerEventData){

            OVRPointerEventData vrPointerEventData = pointerEventData as OVRPointerEventData;

            Assert.IsNotNull(vrPointerEventData);

            return vrPointerEventData.swipeStart;

        }

        public static void SetSwipeStart(this PointerEventData pointerEventData, Vector2 start){

            OVRPointerEventData vrPointerEventData = pointerEventData as OVRPointerEventData;

            Assert.IsNotNull(vrPointerEventData);

            vrPointerEventData.swipeStart = start;

        }

    }    //立钻哥哥：public static class PointerEventDataExtension{}

}    //立钻哥哥：namespace UnityEngine.EventSystems{}

using System;

using System.Collections;

using System.Collections.Generic;

using System.Text;

using UnityEngine;

using UnityEngine.UI;

using UnityEngine.EventSystem;

using UnityEngine.Serialization;

//Extension of GraphicRaycaster to support ray casting with world space rays instead of just screen-space pointer positions.（立钻哥哥：扩展GraphicRaycaster来支持世界空间射线的光线投射，而不仅仅是屏幕空间指针的位置.）

[RequireComponent(typeof(Canvas))]

public class OVRRaycaster : GraphicRaycaster, IPointerEnterHandler{

    [Tooltip(“A world space pointer for this canvas.（立钻哥哥：这个画布的一个世界空间指针）”)]

    public GameObject pointer;

    public int sortOrder = 0;

    protected OVRRaycaster(){}

    [NonSerialized]

    private Canvas m_Canvas;

    private Canvas canvas{}

    public override Camera eventCamera{}

    public override int sortOrderPriority{}

    protected override void Start(){}

    //For the given ray, find graphics on this canvas which it intersects and are not blocked by other world objects.（立钻哥哥：对于给定的光线，在画布上找到它与之相交且不被其他世界对象阻塞的图形.）

    [NonSerialized]

    private List<RaycastHit> m_RaycastResults = new List<RaycastHit>();

    private void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList, Ray ray, bool checkForBlocking){}

    //Performs a raycast using eventData.worldSpaceRay.（立钻哥哥：使用eventData.worldSpaceRay执行光线转换.）

    public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList){}

    //Performs a raycast using the pointer object attached to this “OVRRaycaster”.（立钻哥哥：使用附加到此“OVRRaycaster”的指针对象执行光线转换.）

    public void RaycastPointer(PointerEventData eventData, List<RaycastResult> resultAppendList){}

    //Perform a raycast into the screen and collect all graphics underneath it.（立钻哥哥：将光线投射到屏幕上，并收集屏幕下面的所有图形.）

    [NonSerialized]

    static readonly List<RaycastHit> s_SortedGraphics = new List<RaycastHit>();

    private void GraphicRaycast(Canvas canvas, Ray ray, List<RaycastHit> results){}

    //Get screen position of worldPosition contained in this RaycastResult.（立钻哥哥：获取包含在这个RaycastResult中的worldPosition的屏幕位置.）

    public Vector2 GetScreenPosition(RaycastResult raycastResult){}

    //Detects whether a ray intersects a RectTransform and if it does also returns the world position of the intersection.（立钻哥哥：检测射线是否与RectTransform相交，如果相交，则返回相交点的世界位置.）

    static bool RayIntersectsRectTransform(RectTransform rectTransform, Ray ray, out Vector3 worldPos){}

    struct RaycastHit{

        public Graphic graphic;

        public Vector3 worldPos;

        public bool fromMouse;

    }

    //Is this the currently focussed Raycaster according to the InputModule.（立钻哥哥：根据InputModule，这是当前聚焦的光线吗?）

    public bool IsFocussed(){}

    public void OnPointerEnter(PointerEventData e){

        if(e.IsVRPointer){

            //Gaze has entered this canvas. We’ll make it the active one so that canvas-mouse pointer can be used.（立钻哥哥：凝视进入了这幅画布。我们将它设置为活动的，这样就可以使用canvas-mouse指针了.）

            OVRInputModule inputModule = EventSystem.current.currentInputModule as OVRInputModule;

            if(inputModule != null){

                inputModule.activeGraphicRaycaster = this;

            }

        }

    }    //立钻哥哥：public void OnPointerEnter(PointerEventData e){}

}    //立钻哥哥：public class OVRRaycaster:GraphicRaycaster,IPointerEnterHandler{}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class OVRRayTransform : MonoBehaviour{