《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{

    public static OVRRayTransform Instance;

    public void Awake(){

        if(Instance == null){

            Instance = this;

        }

    }

    public Vector3 Dir{

        get{  return transform.forward;  }

    }

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

//Purpose: CameraFade script adapted to work with SteamVR.（立钻哥哥：用途:适用于SteamVR的摄像机脚本）

//Usage: Add to your top level “SteamVR_Camera”(the one with ApplyDistoration checked) and drag a reference to this component into “SteamVR_Camera RenderComponent” list. Then call the static helper function “SteamVR_Fade”. Start with the desired color and duration. Use a duration of zero to set the start color.（立钻哥哥：用法:将“SteamVR_Camera”添加到顶层(已检查了ApplyDistoration)，并将对该组件的引用拖放到“SteamVR_Camera RenderComponent”列表中。然后调用静态助手函数“SteamVR_Fade”。从想要的颜色和持续时间开始。使用持续时间为零来设置开始颜色.）

//Example: Fade down from black over one second.（立钻哥哥：例子:淡出黑色超过一秒钟.）

//[SteamVR_Fade.Start(Color.black, 0);]

//[SteamVR_Fade.Start(Color.clear, 1)]

//Note: This component is provided to fade out a single camera layer’s scene view. If instead you want to fade the entire view, use: “SteamVR_Fade.View(Color.black, 1);”（立钻哥哥：注意:此组件用于淡出单个相机层的场景视图。如果你想让整个视图褪色，使用:“SteamVR_Fade.View(Color)”。黑色,1);”）

//(Does not affect the game view, however.（立钻哥哥：不过，这并不影响游戏视图）)

using UnityEngine;

using Valve.VR;

namespace Valve.VR{

    public class SteamVR_Fade : MonoBehaviour{

        //default starting color: black and fully transparent.（立钻哥哥：默认启动颜色:黑色和完全透明。）

        private Color currentColor = new Color(0, 0, 0, 0);

        //default target color: black and fully transparent.（立钻哥哥：默认目标颜色:黑色和完全透明）

        private Color targetColor = new Color(0, 0, 0, 0);

        //the delta-color is basically the “speed/second” at which the current color should change.（立钻哥哥：delta-color基本上是当前颜色应该改变的“速度/秒”）

        private Color deltaColor = new Color(0, 0, 0, 0);

        static public void Start(Color newColor, float duration, bool fadeOverlay=false){

            SteamVR_Events.Fade.Send(newColor, duration, fadeOverlay);

        }

        static public void View(Color newColor, float duration){

            var compositor = OpenVR.Compositor;

            if(compositor != null){

                compositor.FadeToColor(duration, newColor.r, newColor.g, newColor.b, newColor.a, false);

            }

        }

        #if TEST_FADE_VIEW

            void Update(){

                if(Input.GetKeyDown(KeyCode.Space)){

                    SteamVR_Fade.View(Color.black, 0);

                    SteamVR_Fade.View(Color.clear, 1);

                }

            }

            @@@立钻哥哥：这个已验证，效果就是“按空格键后视野黑一下”，但是在Game视图是看不见的，因为当时想截个动图给大家看一下，PC上没有显示效果，只能在头盔中体验了，还是一个比较好的功能点设计呢：类似眨眼睛，或者UI蒙版效果都可以借鉴这种设计！

        #endif

        public void OnStartFade(Color newColor, float duration, bool fadeOverlay){

            if(duration > 0.0f){

                targetColor = newColor;

                deltaColor = (targetColor - currentColor) / duration;

            }else{

                currentColor = newColor;

            }

        }

        static Material fadeMaterial = null;

        static int fadeMaterialColorID = -1;

        void OnEnable(){

            if(fadeMaterial == null){

                fadeMaterial = new Material(Shader.Find(“Custom/SteamVR_Fade”));

                fadeMaterialColorID = Shader.PropertyToID(“fadeColor”);

            }

            SteamVR_Events.Fade.Listen(OnStartFade);

            SteamVR_Events.FadeReady.Send();

        }

        void OnDisable(){

            SteamVR_Events.Fade.Remove(OnStartFade);

        }

        void OnPostRender(){

            if(currentColor != targetColor){

                //if the difference between the current alpha and the desired alpha is smaller than “delta-alpha*deltaTime”, then we’ve pretty much done fading.（立钻哥哥：如果当前alpha值和期望alpha值之间的差小于“delta-alpha*deltaTime”，那么我们基本上已经完成了衰减.）

                if(Mathf.Abs(currentColor.a - targetColor.a) < Mathf.Abs(deltaColor.a) * Time.deltaTime){

                    currentColor = targetColor;

                    deltaColor = new Color(0, 0, 0, 0);

                }else{

                    currentColor += deltaColor * Time.deltaTime;

                }

                if(fadeOverlay){

                    var overlay = SteamVR_Overlay.instance;

                    if(overlay != null){

                        overlay.alpha = 1.0f - currentColor.a;

                    }

                }

            }    //立钻哥哥：if(currentColor != targetColor){}

            if(currentColor.a > 0 && fadeMaterial){

                fadeMaterial.SetColor(fadeMaterialColorID, currentColor);

                fadeMaterial.SetPass(0);

                GL.Begin(GL, QUADS);

                GL.Vertex3(-1, -1, 0);

                GL.Vertex3(1, -1, 0);

                GL.Vertex3(1, 1, 0);

                GL.Vertex3(-1, 1, 0);

                GL.End();

            }    //立钻哥哥：if(currentColor.a > 0 && fadeMaterial){}

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

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

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

//Purpose: Displays 2d content on a large virtual screen.（立钻哥哥：用途:在大型虚拟屏幕上显示2d内容）

using UnityEngine;

using System.Collections;

using Valve.VR;

namespace Valve.VR{

    public class SteamVR_Overlay : MonoBehaviour{

        public Texture texture;

        public bool curved = true;

        public bool antialias = true;

        public bool highquality = true;

        public float scale = 3.0f;

        public float distance = 1.25f;

        public float alpha = 1.0f;

        public Vector4 uvOffset = new Vector4(0, 0, 1, 1);

        public Vector2 mouseScale = new Vector2(1, 1);

        public Vector2 curvedRange = new Vector3(1, 2);

        public VROverlayInputMethod inputMethod = VROverlayInputMethod.None;

        static public SteamVR_Overlay instance{  get;  private set;  }

        private ulong handle = OpenVR.k_ulOverlayHandleInvalid;

        void OnEnable(){}

        void OnDisable(){}

        public void UpdateOverlay(){}

        public bool PollNextEvent(ref VREvent_t pEvent){}

        public struct IntersectionResults{

            public Vector3 point;

            public Vector3 normal;

            public Vector2 UVs;

            public float distance;

        }    //立钻哥哥：public struct IntersectionResults{}

        public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResult results){}

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

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

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using UnityEngine;

#if UNITY_2017_2_OR_NEWER

    using UnityEngine.XR;

#else

    using XRSettings = UnityEngine.VR.VRSettings;

    using XRDevice = UnityEngine.VR.XRDevice;

#endif

namespace Valve.VR{

    public class SteamVR_Behaviour : MonoBehaviour{

        private const string openVRDeviceName = “OpenVR”;

        public static bool forcingInitialization = false;

        private static SteamVR_Behaviour _instance;

        public static SteamVR_Behaviour instance{}

        public bool initializeSteamVROnAwake = true;

        public bool doNotDestroy = true;

        [HideInInspector]

        public SteamVR_Render steamvr_render;

        private static bool initializing = false;

        public static void Initialize(bool forceUnityVRToOpenVR=false){}

        protected void Awake(){}

        public void InitializeSteamVR(bool forceUnityVRToOpenVR=false){}

        #if UNITY_2018_3_OR_NEWER

            private bool loadedOpenVRDeviceSuccess = false;

            private IEnumerator DoInitializeSteamVR(bool forceUnityVRToOpenVR=false){}

            private void XRDevice_deviceLoaded(string deviceName){}

        #else

            private IEnumerator DoInitializeSteamVR(bool forceUnityVRToOpenVR=false){}

        #endif

        private void EnableOpenVR(){}

        protected void PreCull(){}

        protected void FixedUpdate(){}

        protected void LateUpdate(){}

        protected void Update(){}

        protected void OnQuit(VREvent_t vrEvent){

            #if UNITY_EDITOR

                UnityEditor.EditorApplication.isPlaying = false;

            #else

                Application.Quit();

            #endif

        }

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

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

//Purpose: Handles rendering of all SteamVR_Cameras.（立钻哥哥：用途:处理所有SteamVR_Camera的渲染）

using UnityEngine;

using System.Collectons;

using Valve.VR;

namespace Valve.VR{

    public class SteamVR_Render : MonoBehaviour{

        public SteamVR_ExternalCamera externalCamera;

        public string externalCameraConfigPath = “externalcamera.cfg”;

        public static EVREye eye{  get;  private set;  }

        public static SteamVR_Render instance{}

        static private bool isQuitting;

        void OnApplicationQuit(){}

        static public void Add(SteamVR_Camera vrcam){}

        static public void Remove(SteamVR_Camera vrcam){}

        static public SteamVR_Camera Top(){}

        private SteamVR_Camera[] cameras = new SteamVR_Camera[0];

        void AddInternal(SteamVR_Camera vrcam){}

        void RemoveInternal(SteamVR_Camera vrcam){}

        SteamVR_Camera TopInternal(){}

        public TrackedDevicePose_t[] poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];

        public TrackedDevicePose_t[] gamePoses = new TrackedDevicePose_t[0];

        static private bool _pauseRendering;

        static public bool pauseRendering{}

        private IEnumerator RenderLoop(){}

        void RenderExternalCamera(){}

        private void OnInputFocus(bool hadFocus){}

        private string GetScreenshotFliename(uint screenshotHandle, EVRScreenshotPropertyFilenames screenshotPropertyFilename){}

        private void OnRequestScreenshot(VREvent_t vrEvent){}

        private void OnEnable(){}

        private void OnSteamVRInitialized(bool success){}

        private void OnDisable(){}

        private void Awake(){}

        public void UpdatePoses(){}

        void Update(){}

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

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

using UnityEngine;

using System.Collectons;

namespace Valve.VR{

    //Automatically activates an action set on Start() and deactivates the set on OnDestroy(). Optionally deactivating all other sets as well.（立钻哥哥：自动激活Start()和OnDestroy()上的操作集。还可以选择停用所有其他集.）

    public class SteamVR_ActivateActionSetOnLoad : MonoBehaviour{

        public SteamVR_ActionSet actionSet = SteamVR_Input.GetActionSet(“default”);

        public SteamVR_Input_Sources forSources = SteamVR_Input_Sources.Any;

        public bool disableAllOtherActionSets = false;

        public bool activateOnStart = true;

        public bool deactivateOnDestroy = true;

        private void Start(){

            if(actionSet != null && activateOnStart){

                //Debug.Log(string.Format(“立钻哥哥：[SteamVR] Activating {0} action set.”, actionSet.fullPath));

                actionSet.Activate(forSources, 0, disableAllOtherActionSets);

            }

        }

        private void OnDestroy(){

            if(actionSet != null && deactivateOnDestroy){

                //Debug.Log(string.Format(“立钻哥哥：[SteamVR] Deactivating {0} action set.”, actionSet.fullPath));

                actionSet.Deactivate(forSources);

            }

        }

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

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

//Purpose: Controllers for the non-VR debug camera.（立钻哥哥：用途:用于非vr调试相机的控制器。）

using UnityEngine;

using System.Collections;

namespace Valve.VR.InteractionSystem{

    [RequireComponent(typeof(Camera))]

    public class FallbackCameraController : MonoBehaviour{

        public float speed = 4.0f;

        public float shiftSpeed = 16.0f;

        public bool showInstructions = true;

        private Vector3 startEulerAngles;

        private Vector3 startMousePosition;

        private float realtime;

        void OnEnable(){}

        void Update(){}

        void OnGUI(){}

        //[“WASD/Arrow Keys to translate the camera.”]（立钻哥哥：WASD/箭头键移动相机。）

        //[“Right mouse click to rotate the camera.”]（立钻哥哥：右击鼠标可旋转相机.）

        //[“Left mouse click for standard interactions.”]（立钻哥哥：单击鼠标左键进行标准交互）

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

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

//Purpose: The hands used by the player in the vr interaction system.（立钻哥哥：用途:玩家在vr交互系统中使用的手.）

using UnityEngine;

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using UnityEngine.Events;

using System.Threading;

namespace Valve.VR.InteractionSystem{

    //Links with an appropriate “SteamVR” controller and facilitates interactions with objects in the virtual world.（立钻哥哥：链接到适当的“SteamVR”控制器，并方便与虚拟世界中的对象进行交互。）

    public class Hand : MonoBehaviour{

        //The flags used to determine how an object is attached to the hand.（立钻哥哥：用于确定对象如何附加到手的标志.）

        [Flags]

        public enum AttachmentFlags{}

        public const AttachmentFlags defaultAttachmentFlags = AttachmentFlags.ParentToHand | AttachmentFlags.DetachOthers | AttachmentFlags.DetachFromOtherHand | AttachmentFlags.TurnOnKinematic | AttachmentFlags.SnapOnAttach;

        public Hand otherHand;

        public SteamVR_Input_Sources handType;

        public SteamVR_Behaviour_Pose trackedObject;

        public SteamVR_Action_Boolean grabPinchAction = SteamVR_Input.GetAction<SteamVR_Action_Boolean>(“GrabPinch”);

        public SteamVR_Action_Boolean grabGripAction = SteamVR_Input.GetAction<SteamVR_Action_Boolean>(“GrabGrip”);

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

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

        public struct AttachedObject{

            public GameObject attachedObject;

            public Interactable interactable;

            public Rigidbody attachedRigidbody;

            public CollisionDetectionMode collisionDetectionMode;

            public bool attachedRigidbodyWasKinematic;

            public bool attachedRigidbodyUsedGravity;

            public GameObject originalParent;

            public bool isParentedToHand;

            public GrabTypes grabbedWithType;

            public AttachmentFlags attachmentFlags;

            public Vector3 initialPositionOffset;

            public Quaternion initialRotationalOffset;

            public Transform attachedOffsetTransform;

            public Transform handAttachmentPointTransform;

            public Vector3 easeSourcePosition;

            public Quaternion easeSourceRatation;

            public float attachTime;

            public bool HasAttachFlags(AttachmentFlags flag){

                return (attachmentFlags & flag) == flag;

            }

        }    //立钻哥哥：public struct AttachedObject{}

        public ReadOnlyCollection<AttachedObject> AttachedObjects;

        //The Interactable object this Hand is currently hovering over.（立钻哥哥：这只手当前悬停的可交互对象.）

        public Interactable hoveringInteractable{}

        //Active GameObject attached to this Hand.（立钻哥哥：活动的GameObject附在这只手上.）

        public GameObject currentAttachedObject{}

        public AttachedObject? currentAttachedObjectInfo{}

        public SteamVR_Behaviour_Skeleton skeleton{}

        public void ShowController(bool permanent = false){}

        public void HideController(bool permanent = false){}

        public void ShowSkeleton(bool permanent = false){}

        public void HideSkeleton(bool permanent = false){{}

        public bool HasSkeleton(){}

        public void Show(){}

        public void Hide(){}

        public void SetVisibility(bool visible){}

        public void SetSkeletonRangeOfMotion(EVRSkeletalMotionRange newRangeOfMotion, float blendOverSeconds=0.1f){}

        public void SetTemporarySkeletonRangeOfMotion(SkeletalMotionRangeChange temporaryRangeOfMotionChange, float blendOverSeconds=0.1f){}

        public void ResetTemporarySkeletonRangeOfMotion(float blendOverSeconds=0.1f){}

        public void SetAnimationState(int stateValue){}

        public void StopAnimation(){}

        //Attach a GameObject to this GameObject.（立钻哥哥：将GameObject(游戏物体)附加到这个GameObject(游戏物体)上.）

       //[objectToAttach]: The GameObject to attach.（立钻哥哥：[objectToAttach]:要附加的GameObject.）

       //[flags]: The flags to use for attaching the object.（立钻哥哥：[flags]:用于附加对象的标志.）

       //[attachmentPoint]: Name of the GameObject in the hierarchy of this Hand which should act as the attachment point for this GameObject.（立钻哥哥：[attachmentPoint]:这只手的层次结构中GameObject的名称，它应该作为这个GameObject的连接点.）

        public void AttachObject(GameObject objectToAttach, GrabTypes graddedWithType, AttachmentFlags flags=defaultAttachmentFlags, Transform attachmentOffset=null){}

       public bool ObjectIsAttached(GameObject go){}

       public void ForceHoverUnlock(){}

       //Detach this GameObject from the attached object stack of this Hand.（立钻哥哥：从这只手的附加对象堆栈中分离这个GameObject.）

        //[objectToDetach]: The GameObject to detach from this Hand.（立钻哥哥：[objectToDetach]:要从这只手分离的GameObject.）

        public void DetachObject(GameObject objectToDetach, bool restoreOriginalParent=true){}

       //Get the world velocity of the VR Hand.（立钻哥哥：得到VR手的世界速度.）

        public Vector3 GetTrackedObjectVelocity(float timeOffset=0){}

       //Get the world space angular velocity of the VR Hand.（立钻哥哥：得到VR手的世界空间角速度.）

        public Vector3 GetTrackedObjectAngularVelocity(float timeOffset=0){}

        public void GetEstimatedPeakVelocities(out Vector3 velocity, out Vector3 angularVelocity){}

        private void CleanUpAttachedObjectStack(){}

        protected virtual void Awake(){}

        protected virtual void OnDestroy(){}

        protected virtual void OnTransformUpdated(SteamVR_Behaviour_Pose updatedPose, SteamVR_Input_Sources updateSource){}

        protected virtual IEnumerator Start(){}

        protected virtual void UpdateHovering(){}

        protected virtual bool CheckHoveringForTransform(Vector3 hoverPosition, float hoverRadius, ref float closestDistance, ref Interactable closestInteractable, Color debugColor){}

        protected virtual void UpdateNoSteamVRFallback(){}

        private void UpdateDebugText(){}

        protected virtual void OnEnable(){}

        protected virtual void OnDisable(){}

        protected virtual void Update(){}

        //Returns true when the hand is currently hovering over the interactable passed in.（立钻哥哥：当指针当前悬停在传入的可交互物体上时，返回true）

        public bool IsStillHovering(Interactable interactable){}

        protected virtual void HandFollowUpdate(){}

        protected virtual void FixedUpdate(){}

        protected void UpdateAttachedVelocity(AttachedObject attachedObjectInfo){}

        protected Vector3 TargetItemPosition(AttachedObject attacheObject){}

        protected Quaternion TargetItemRotation(AttachedObject attachedObject){}

        protected bool GetUpdateAttachedVelocities(AttachedObject attachedObjectInfo, out Vector3 velocityTarget, out Vector3 angularTarget){}

        protected virtual void OnInputFocus(bool hasFocus){}

        protected virtual void OnDrawGizmos(){}

        private void HandDebugLog(string msg){}

        //Continue to hover over this object indefinitely, whether or not the Hand moves out of its interaction trigger volume.（立钻哥哥：无论手是否移出交互触发范围，都将无限期地悬停在该对象上）

        public void HoverLock(Interactable interactable){}

        //Stop hovering over this object indefinitely.（立钻哥哥：停止无限期地悬停在这个物体上.）

        public void HoverUnlock(Interactable interactable){}

        public void TriggerHapticPulse(ushort microSecondsDuration){}

        public void TriggerHapticPulse(float duration, float frequency, float amplitude){}

        public void ShowGrabHint(){}

        public void HideGrabHint(){}

        public void ShowGrabHint(string text){}

        public GrabTypes GetGrabString(GrabTypes explicitType=GrabTypes.None){}

        public GrabTypes GetGrabEnding(GrabTypes explicitType=GrabTypes.None){}

        public bool IsGrabEnding(GameObject attachedObject){}

        public bool IsGrabbingWithType(GrabTypes type){}

        public bool IsGrabbingWithOppositeType(GrabTypes type){}

        public GrabTypes GetBestGrabbingType(){}

        public GrabTypes GetBestGrabbingType(GrabTypes preferred, bool forcePreference=false){}

        private void InitController(){}

        public void SetRenderModel(GameObject prefab){}

        public void SetHoverRenderModel(RenderModel hoverRenderModel){}

        public int GetDeviceIndex(){}

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

    [System.Serializable]

    public class HandEvent : UnityEvent<Hand>{}

    UNITY_EDITOR

    [UnityEditor.CustomEditor(typeof(Hand))]

    public class HandEditor : UnityEditor.Editor{

        public override void OnInspectorGUI(){}

    }    //立钻哥哥：public class HandEditor:UnityEditor.Editor{}

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

//Purpose: Makes the hand act as an input module for Unity’s event system.（立钻哥哥：目的:使手作为Unity事件系统的输入模块.）

using UnityEngine;

using System.Collecitons;

using UnityEngine.EventSystems;

namespace Valve.VR.InteractionSystem{

    public class InputModule : BaseInputModule{

        private GameObject submitObject;

        private static InputModule _instance;

        public static InputModule instance{}

        public override bool ShouldActivateModule(){}

        public void HoverBegin(GameObject gameObject){}

        public void HoverEnd(GameObject gameObject){}

        public void Submit(GameObject gameObject){}

        public override void Process(){}

    }    //立钻哥哥：public class InputModule:BaseInputModule{}

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

++知识点01：public static InputModule instance{}单例

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

private static InputModule _instance;

public static InputModule instance{

    get{

        if(_instance == null){

            _instance = GameObject.FindObjectOfType<InputModule>();

        }

        return _instance;

    }

}

++知识点02：public override bool ShouldActivateModule(){}

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

public override bool ShouldActivateModule(){

    if(!base.ShouldActivateModule){

       return false;

    }

    return submitObject != null;

}

++知识点03：public void HoverBegin(GameObject gameObject){}

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

public void HoverBegin(GameObject gameObject){

    PointerEventData pointerEventData = new PointerEventData(eventSystem);

    ExecuteEvents.Execute(gameObject, pointerEventData, ExecuteEvents.pointerEnterHandler);

}

++知识点04：public void HoverEnd(GameObject gameObject){}

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

public void HoverEnd(GameObject gameObject){

    PointerEventData pointerEventData = new PointerEventData(eventSystem);

pointerEventData.selectedObject = null;

    ExecuteEvents.Execute(gameObject, pointerEventData, ExecuteEvents.pointerEnterHandler);

}

++知识点05：public void Submit(GameObject gameObject){}

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

public void Submit(GameObject gameObject){

     submitObject = gameObject;

}

++知识点06：public override void Process(){}

++++立钻哥哥：\Assets\ThirdPartyPlugins\SteamVR\InteractionSystem\Core\Scripts\InputModule.cs

public override void Process(){

    if(submitObject){

        BaseEventData data = GetBaseEventData();

        data.selectedObject = submitObject;

        ExecuteEvents.Execute(submitObject, data, ExecuteEvents.submitHandler);

       submitObject = null;

    }

}

++知识点07：BaseInputModule

++++立钻哥哥：C:\Users\unity\AppData\Local\Temp\MetadataAsSource\f5f8a652081f4ec99a4c8a9b8a92baf2\6cc51b7c5187442c852bf027ee8c061d\BaseInputModule.cs

//程序集 UnityEngine.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

// E:\E_ProgramFiles_02\UnitySetup64-2018.3.0f2\Unity\Editor\Data\UnityExtensions\Unity\GUISystem\UnityEngine.UI.dll

using System.Collections.Generic;

namespace UnityEngine.EventSystems{

    //A base module that raises events and sends them to GameObjects.（立钻哥哥：一个引发事件并将其发送到GameObjects的基本模块.）

    [RequireComponent(typeof(EventSystem))]

    public abstract class BaseInputModule : UIBehaviour{

        protected List<RaycastResult> m_RaycastResultCache;

        protected BaseInput m_InputOverride;

        protected BaseInputModule();

        //The current BaseInput being used by the input module.（立钻哥哥：输入模块使用的当前基输入.）

        public BaseInput input{  get;  }

        //Used to override the default BaseInput for the input module.（立钻哥哥：用于覆盖输入模块的默认BaseInput.）

        public BaseInput inputOverride{  get;  set;  }

        protected EventSystem eventSystem{  get;  }

        //Given an input movement, determine the best MoveDirection.（立钻哥哥：给定一个输入移动，确定最佳移动方向.）

        protected static MoveDirection DetermineMoveDirection(float x, float y);

        protected static MoveDirection DetermineMoveDirection(float x, float y, float deadZone);

        //Given 2 GameObjects, return a common root GameObject (or null).（立钻哥哥：给定两个GameObject，返回一个通用根GameObject(或null).）

        protected static GameObject FindCommonRoot(GameObject g1, GameObject g2);

        protected static RaycastResult FindFirstRaycast(List<RaycastResult> candidates);

        //Called when the module is activated. Override this if you want custom code to execute when you activate your module.（立钻哥哥：当模块被激活时调用。如果希望在激活模块时执行自定义代码，请覆盖此选项.）

        public virtual void ActivateModule();

        //Called when the module is deactivated. Override this if you want custom code to execute when you deactivate your module.（立钻哥哥：当模块被停用时调用。如果希望在停用模块时执行自定义代码，请覆盖此选项）

        public virtual void DeactivateModule();

        //Check to see if the module is supported. Override this if you have a platform specific module (eg. TouchInputModule) that you do not want to activate on standalone.（立钻哥哥：检查模块是否受支持。如果您有一个特定于平台的模块(例如TouchInputModule)您不希望在独立时激活）

        //返回结果：Is the module supported.（立钻哥哥：是否支持该模块.）

        public virtual bool IsModuleSupported();

        //Is the pointer with the given ID over an EventSystem object?（立钻哥哥：具有给定ID的指针是否位于EventSystem对象上?）

        public virtual bool IsPointerOverGameObject(int pointerId);

        //Process the current tick for the module.（立钻哥哥：处理模块的当前标记.）

        public abstract void Process();

        //Should be activated.（立钻哥哥：应该被激活.）

        //返回结果：Should the module be activated.（立钻哥哥：如果模块被激活.）

        public virtual bool ShouldActivateModule(){}

        //Update the internal state of the Module.（立钻哥哥：更新模块的内部状态.）

        public virtual void UpdateModule();

        //Given some input data generate an AxisEventData that can be used by the event.（立钻哥哥：给定一些输入数据生成一个AxisEventData，该数据可被事件使用.）

        protected virtual AxisEventData GetAxisEventData(float x, float y, float moveDeadZone);

        //Generate a BaseEventData that can be used by the EventSystem.（立钻哥哥：生成一个可以被EventSystem使用的BaseEventData）

        protected virtual BaseEventData GetBaseEventData();

        //Handle sending enter and exit events when a new enter target is found.（立钻哥哥：当找到新的enter目标时，处理发送enter和exit事件.）

        protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget);

        protected override void OnDisable();

        protected override void OnEnable();

    }    //立钻哥哥：public abstract class BaseInputModule:UIBehaviour{}

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

++++public class InputModule : BaseInputModule{}

++知识点08：PointerEventData

++++立钻哥哥：C:\Users\unity\AppData\Local\Temp\MetadataAsSource\f5f8a652081f4ec99a4c8a9b8a92baf2\5a3518c078024486902212bd5a76c299\PointerEventData.cs

//程序集 UnityEngine.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

//E:\E_ProgramFiles_02\UnitySetup64-2018.3.0f2\Unity\Editor\Data\UnityExtensions\Unity\GUISystem\UnityEngine.UI.dll

using System;

using System.Collections.Generic;

namespace UnityEngine.EventSystems{

    //Event payload associated with pointer (mouse/touch) events.（立钻哥哥：与指针(鼠标/触摸)事件关联的事件有效负载.）

    public class PointerEventData : BaseEventData{

        //List of objects in the hover stack.（立钻哥哥：悬停堆栈中的对象列表.）

        public List<GameObject> hovered;

        public PointerEventData(EventSystem eventSystem);

        //The GameObject that received the OnPointerDown.（立钻哥哥：接收OnPointerDown的GameObject.）

        public GameObject pointerPress{  get;  set;  }

        //The camera associated with the last OnPointerPress event.（立钻哥哥：与上次OnPointerPress事件相关的摄像机.）

        public Camera pressEventCamera{  get;  }

        public Camera enterEventCamera{  get;  }

        //The EventSystems.PointerEventData.InputButton for this event.（立钻哥哥：EventSystems.PointerEventData.InputButton这个事件）

        public InputButton button{  get;  set;  }

        //Is a drag operation currently occuring.（立钻哥哥：当前正在执行拖动操作.）

        public bool dragging{  get;  set;  }

        //Should a drag threshold be used? （立钻哥哥：应该使用拖动阈值吗?）

        public bool useDragThreshold{  get;  set;  }

        //The amount of scroll since the last update.（立钻哥哥：自上次更新以来的滚动量）

        public Vector2 scrollDelta{  get;  set;  }

        //Number of clicks in a row.（立钻哥哥：一行中的单击次数.）

        public int clickCount{  get;  set;  }

        //The last time a click event was sent.（立钻哥哥：上一次发送单击事件.）

        public float clickTime{  get;  set;  }

        [Obsolete(“Use either pointerCurrentRaycast.worldNormal or pointerPressRaycast.worldNormal.（立钻哥哥：使用pointerCurrentRaycast.worldNormal或pointerPressRaycast.worldNormal）”)]

        public Vector3 worldNormal{  get;  set;  }

        public Vector3 worldPosition{  get;  set;  }

        //The screen space coordinates of the last pointer click.（立钻哥哥：屏幕空间坐标的最后一个指针点击.）

        public Vector2 pressPosition{  get;  set;  }

        //Pointer delta since last update.（立钻哥哥：指针增量自从上次更新.）

        public Vector2 delta{  get;  set;  }

        //Current pointer position.（立钻哥哥：当前指针位置）

        public Vector2 position{  get;  set;  }

        //Identification of the pointer.（立钻哥哥：指针的标识.）

        public int pointerId{  get;  set;  }

        public bool eligibleForClick{  get;  set;  }

        //RaycastResult associated with the pointer press.（立钻哥哥：与指针按下相关联的RaycastResult.）

        public RaycastResult pointerPressRaycast{  get;  set;  }

        //RaycastResult associated with the current event.（立钻哥哥：与当前事件关联的RaycastResult.）

        public RaycastResult pointerCurrentRaycast{  get;  set;  }

        //The object that is receving OnDrag.（立钻哥哥：正在接收OnDrag的对象。）

        public GameObject pointerDrag{  get;  set;  }

        //The object that the press happened on even if it can not handle the press event.（立钻哥哥：即使不能处理press事件，也要处理被压入的对象.）

        public GameObject rawPointerPress{  get;  set;  }

        //The GameObject for the last press event.（立钻哥哥：最后一个按下事件的GameObject）

        public GameObject lastPress{  get;  }

        //The object that received “OnPointerEnter”.（立钻哥哥：接收“OnPointerEnter”的对象.）

        public GameObject pointerEnter{  get;  set;  }

        //Is the pointer moving.（立钻哥哥：指针在移动吗?）

        public bool IsPointerMoving();

        //Is scroll being used on the input device.（立钻哥哥：正在输入设备上使用滚动.）

        public bool IsScrolling();

        public override string ToString();

        //Input press tracking.（立钻哥哥：输入按下跟踪）

        public enum InputButton{

            Left = 0,

            Right = 1,

            Middle = 2

        }

        //The state of a press for the given frame.（立钻哥哥：给定帧的按下状态.）

        public enum FramePressState{

            Pressed = 0,

            Released = 1,

            PressedAndReleased = 2,

            NotChanged = 3

        }

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

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

++++PointerEventData pointerEventData = new PointerEventData(eventSystem);

++++ExecuteEvents.Execute(gameObject, pointerEventData, ExecuteEvents.pointerEnterHandler);

++++pointerEventData.selectedObject = null;

++知识点09：ExecuteEvents

++++立钻哥哥：C:\Users\unity\AppData\Local\Temp\MetadataAsSource\f5f8a652081f4ec99a4c8a9b8a92baf2\f82c7557f9954a8a947e019071a1c2e1\ExecuteEvents.cs

//程序集 UnityEngine.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

//E:\E_ProgramFiles_02\UnitySetup64-2018.3.0f2\Unity\Editor\Data\UnityExtensions\Unity\GUISystem\UnityEngine.UI.dll

namespace UnityEngine.EventSystems{

    //Helper class that can be used to send IEventSystemHandler events to GameObjects.（立钻哥哥：Helper类，可用于将IEventSystemHandler事件发送到GameObjects.）

    public static class ExecuteEvents{

        //IBeginDragHandler execute helper function.（立钻哥哥：IBeginDragHandler执行helper函数.）

        public static EventFunction<IBeginDragHandler> beginDragHandler{  get;  }

        public static EventFunction<IDeselectHandler> deselectHandler{  get;  }

        public static EventFunction<ISelectHandler> selectHandler{  get;  }

        public static EventFunction<IUpdateSelectedHandler> updateSelectedHandler{  get;  }

        public static EventFunction<IScrollHandler> scrollHandler{  get;  }

        public static EventFunction<IDropHandler> dropHandler{  get;  }

        public static EventFunction<IEndDragHandler> dragHandler{  get;  }

        public static EventFunction<IDragHandler> dragHandler{  get;  }

        public static EventFunction<ICancelHandler> cancelHandler{  get;  }

        public static EventFunction<IMoveHandler> moveHandler{  get;  }

        public static EventFunction<IInitializePotentialDragHandler> initializePotentialDrag{  get;  }

        public static EventFunction<IPointerUpHandler> pointerUpHandler{  get;  }

        public static EventFunction<IPointerDownHandler> pointerDownHandler{  get;  }

        public static EventFunction<IPointerExitHandler> pointerExitHandler{  get;  }

        public static EventFunction<IPointerEnterHandler> pointerEnterHandler{  get;  }

        public static EventFunction<IPointerClickHandler> pointerClickHandler{  get;  }

        public static EventFunction<ISubmitHandler> submitHandler{  get;  }

        public static bool CanHandleEvent<T>(GameObject go) where T : IEventSystemHandler;

        public static bool Execute<T>(GameObject target, BaseEventData eventData, EventFunction<T> functor) where T : IEventSystemHandler;

        public static GameObject ExecuteHierarchy<T>(GameObject root, BaseEventData eventData, EventFunction<T> callbackFunction) where T : IEventSystemHandler;

        public static GameObject GetEventHandler<T>(GameObject root) where T : IEventSystemHandler;

        public static T ValidateEventData<T>(BaseEventData data) where T : class;

        public delegate void EventFunction<T1>(T1 handler, BaseEventData eventData);

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

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

++++ExecuteEvents.Execute(gameObject, pointerEventData, ExecuteEvent.pointerEnterHandler);

++++ExecuteEvents.Execute(submitObject, data, ExecuteEvent.submitHandler);

++知识点10：BaseEventData

++++立钻哥哥：C:\Users\unity\AppData\Local\Temp\MetadataAsSource\f5f8a652081f4ec99a4c8a9b8a92baf2\0049f4b839ea4dd18b778f7722b23518\BaseEventData.cs

//程序集 UnityEngine.UI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

//E:\E_ProgramFiles_02\UnitySetup64-2018.3.0f2\Unity\Editor\Data\UnityExtensions\Unity\GUISystem\UnityEngine.UI.dll

namespace UnityEngine.EventSystems{

    //A class that contains the base event data that is common to all event types in the new EventSystem.（立钻哥哥：包含基本事件数据的类，这些基本事件数据对新事件系统中的所有事件类型都是通用的.）

    public class BaseEventData : AbstractEventData{

        //Construct a BaseEventData tied to the passed EventSystem.（立钻哥哥：构造与传递的事件系统绑定的BaseEventData.）

        public BaseEventData(EventSystem eventSystem);

        //A reference to the BaseInputModule that sent this event.（立钻哥哥：发送此事件的BaseInputModule的引用.）

        public BaseInputModule currentInputModule{  get;  }

        //The object currently considered selected by the EventSystem.（立钻哥哥：事件系统当前考虑选择的对象.）

        public GameObject selectedObject{  get;  set;  }

    }    //立钻哥哥：public class BaseEventData : AbstractEventData{}

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

++++BaseEventData data = GetBaseEventData();

using System;

using System.Collections.Generic;

using Valve.VR;

namespace UnityEngine.EventSystems{