public static void Remove(SteamVR_Camera vrcam) { if (!isQuitting && _instance != null) { instance.RemoveInternal(vrcam); } }
public void AttachToCamera(SteamVR_Camera vrcam) { if (target == vrcam.head) return; target = vrcam.head; var root = transform.parent; var origin = vrcam.head.parent; root.parent = origin; root.localPosition = Vector3.zero; root.localRotation = Quaternion.identity; root.localScale = Vector3.one; // Make a copy of the eye camera to pick up any camera fx. vrcam.enabled = false; var go = Instantiate(vrcam.gameObject); vrcam.enabled = true; go.name = "camera"; DestroyImmediate(go.GetComponent<SteamVR_Camera>()); cam = go.GetComponent<Camera>(); cam.fieldOfView = config.fov; cam.useOcclusionCulling = false; cam.enabled = false; // manually rendered colorMat = new Material(Shader.Find("Custom/SteamVR_ColorOut")); alphaMat = new Material(Shader.Find("Custom/SteamVR_AlphaOut")); clipMaterial = new Material(Shader.Find("Custom/SteamVR_ClearAll")); var offset = go.transform; offset.parent = transform; offset.localPosition = new Vector3(config.x, config.y, config.z); offset.localRotation = Quaternion.Euler(config.rx, config.ry, config.rz); offset.localScale = Vector3.one; // Strip children of cloned object (AudioListener in particular). while (offset.childCount > 0) DestroyImmediate(offset.GetChild(0).gameObject); // Setup clipping quad (using camera clip causes problems with shadows). clipQuad = GameObject.CreatePrimitive(PrimitiveType.Quad); clipQuad.name = "ClipQuad"; DestroyImmediate(clipQuad.GetComponent<MeshCollider>()); var clipRenderer = clipQuad.GetComponent<MeshRenderer>(); clipRenderer.material = clipMaterial; clipRenderer.shadowCastingMode = ShadowCastingMode.Off; clipRenderer.receiveShadows = false; clipRenderer.lightProbeUsage = LightProbeUsage.Off; clipRenderer.reflectionProbeUsage = ReflectionProbeUsage.Off; var clipTransform = clipQuad.transform; clipTransform.parent = offset; clipTransform.localScale = new Vector3(1000.0f, 1000.0f, 1.0f); clipTransform.localRotation = Quaternion.identity; clipQuad.SetActive(false); }
public static void Add(SteamVR_Camera vrcam) { if (!isQuitting) { instance.AddInternal(vrcam); } }
// Use this for initialization void Start() { poseArray = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; SteamVR_Events.DeviceConnected.Listen(OnDeviceConnected); SteamVR_Events.System(EVREventType.VREvent_ChaperoneUniverseHasChanged).Listen(OnUniverseChanged); SteamVR_Events.InputFocus.Listen(OnInputFocus); SteamVR_Events.NewPoses.Listen(OnNewPoses); baseStations = new List <string> (); if (hmdTracking) { GetChaperoneSize(); } currGameAreaPos = player.transform.position; // backupCamera = GameObject.FindGameObjectWithTag ("BackupCamera"); backupCamera.gameObject.SetActive(false); mainCam = headCamera.GetComponent <SteamVR_Camera> (); backupCam = backupCamera.GetComponent <SteamVR_Camera> (); tracker = GameObject.Find("Tracker"); height = Random.Range(0.8f, 1.6f); initialPlayerPosition = player.transform.position; initialEnvironmentPosition = GameObject.Find("Environment").transform.position; }
public override void Initialize(NVRPlayer player) { Player = player; Player.gameObject.SetActive(false); SteamVR_ControllerManager controllerManager = Player.gameObject.AddComponent <SteamVR_ControllerManager>(); controllerManager.left = Player.LeftHand.gameObject; controllerManager.right = Player.RightHand.gameObject; //Player.gameObject.AddComponent<SteamVR_PlayArea>(); for (int index = 0; index < Player.Hands.Length; index++) { Player.Hands[index].gameObject.AddComponent <SteamVR_TrackedObject>(); } SteamVR_Camera steamVrCamera = Player.Head.gameObject.AddComponent <SteamVR_Camera>(); Player.Head.gameObject.AddComponent <SteamVR_Ears>(); NVRHelpers.SetField(steamVrCamera, "_head", Player.Head.transform, false); NVRHelpers.SetField(steamVrCamera, "_ears", Player.Head.transform, false); Player.Head.gameObject.AddComponent <SteamVR_TrackedObject>(); Player.gameObject.SetActive(true); SteamVR_Render[] steamvr_objects = GameObject.FindObjectsOfType <SteamVR_Render>(); for (int objectIndex = 0; objectIndex < steamvr_objects.Length; objectIndex++) { steamvr_objects[objectIndex].lockPhysicsUpdateRateToRenderFrequency = false; //this generally seems to break things :) Just make sure your Time -> Physics Timestep is set to 0.011 } }
void AddInternal(SteamVR_Camera vrcam) { var camera = vrcam.GetComponent <Camera>(); var length = cameras.Length; var sorted = new SteamVR_Camera[length + 1]; int insert = 0; for (int i = 0; i < length; i++) { var c = cameras[i].GetComponent <Camera>(); if (i == insert && c.depth > camera.depth) { sorted[insert++] = vrcam; } sorted[insert++] = cameras[i]; } if (insert == length) { sorted[insert] = vrcam; } cameras = sorted; #if (UNITY_5_3_OR_NEWER || UNITY_5_2 || UNITY_5_1 || UNITY_5_0) enabled = true; #endif }
void Awake() { SteamVR_Camera steamCamera = this.transform.parent.gameObject.GetComponentInChildren <SteamVR_Camera>(); if (steamCamera == null) { vrCamera = Camera.main.transform; } else { vrCamera = steamCamera.transform; } if (vrCamera == null) { Debug.LogError("vrCamera is null"); enabled = false; return; } SteamVR_PlayArea steamPlayArea = this.transform.parent.gameObject.GetComponent <SteamVR_PlayArea>(); if (steamPlayArea == null) { vrPlayArea = transform.parent; } else { vrPlayArea = steamPlayArea.transform; } if (vrPlayArea == null) { Debug.LogError("vrplayarea is null"); enabled = false; return; } }
// Token: 0x06005F56 RID: 24406 RVA: 0x00217BE4 File Offset: 0x00215FE4 private void RemoveInternal(SteamVR_Camera vrcam) { int num = this.cameras.Length; int num2 = 0; for (int i = 0; i < num; i++) { SteamVR_Camera x = this.cameras[i]; if (x == vrcam) { num2++; } } if (num2 == 0) { return; } SteamVR_Camera[] array = new SteamVR_Camera[num - num2]; int num3 = 0; for (int j = 0; j < num; j++) { SteamVR_Camera steamVR_Camera = this.cameras[j]; if (steamVR_Camera != vrcam) { array[num3++] = steamVR_Camera; } } this.cameras = array; }
public override void Initialize(NVRPlayer player) { Player = player; Player.gameObject.SetActive(false); SteamVR_ControllerManager controllerManager = Player.gameObject.AddComponent <SteamVR_ControllerManager>(); controllerManager.left = Player.LeftHand.gameObject; controllerManager.right = Player.RightHand.gameObject; //controllerManager.objects = new GameObject[2] { Player.LeftHand.gameObject, Player.RightHand.gameObject }; Player.gameObject.AddComponent <SteamVR_PlayArea>(); for (int index = 0; index < Player.Hands.Length; index++) { Player.Hands[index].gameObject.AddComponent <SteamVR_TrackedObject>(); } SteamVR_Camera steamVrCamera = Player.Head.gameObject.AddComponent <SteamVR_Camera>(); SteamVR_Ears steamVrEars = Player.Head.gameObject.AddComponent <SteamVR_Ears>(); NVRHelpers.SetField(steamVrCamera, "_head", Player.Head.transform, false); NVRHelpers.SetField(steamVrCamera, "_ears", Player.Head.transform, false); Player.Head.gameObject.AddComponent <SteamVR_TrackedObject>(); Player.gameObject.SetActive(true); }
// Token: 0x06005F53 RID: 24403 RVA: 0x00217B10 File Offset: 0x00215F10 public static void Remove(SteamVR_Camera vrcam) { if (!SteamVR_Render.isQuitting && SteamVR_Render._instance != null) { SteamVR_Render.instance.RemoveInternal(vrcam); } }
void RenderEye(SteamVR vr, Hmd_Eye eye, LayerMask mask) { int i = (int)eye; SteamVR_Render.eye = eye; if (cameraMask != null) { cameraMask.Set(vr, eye); } foreach (var c in cameras) { c.transform.localPosition = vr.eyes[i].pos; c.transform.localRotation = vr.eyes[i].rot; // Update position to keep from getting culled cameraMask.transform.position = c.transform.position; var camera = c.GetComponent <Camera>(); camera.targetTexture = SteamVR_Camera.GetSceneTexture(camera.hdr); int cullingMask = camera.cullingMask; camera.cullingMask |= mask; camera.Render(); camera.cullingMask = cullingMask; } }
// Use this for initialization void Start() { cameraScript = cameraRig.transform.Find("Camera (eye)").GetComponent <SteamVR_Camera>(); watchAnimator = canvasSet.GetComponent <Animator>(); selfCollider = GetComponent <SphereCollider>(); canvasColliders = new List <Collider>(); foreach (Transform t in canvasSet.transform) { canvasColliders.Add(t.gameObject.GetComponent <BoxCollider>()); } notificationCanvasOn = false; timeCanvas.SetActive(true); canvasSet.SetActive(false); trackedObj = leftController.GetComponent <SteamVR_TrackedObject>(); noticed = false; interacted = false; ended = false; // disable notification canavases by default // enable time canvas, which shows time by default // wait for keyboard trigger to enable notification canvases and disable time canvas // once reading is done, back to time canvas. // }
private IEnumerator RenderLoop() { while (true) { yield return(new WaitForEndOfFrame()); var vr = SteamVR.instance; if (vr.compositor.CanRenderScene()) { vr.compositor.SetTrackingSpace(trackingSpace); vr.compositor.WaitGetPoses(poses, gamePoses); SteamVR_Utils.Event.Send("new_poses", poses); } GL.IssuePluginEvent(20150313); // Fire off render event to perform our compositor sync SteamVR_Camera.GetSceneTexture(cameras[0].GetComponent <Camera>().hdr).GetNativeTexturePtr(); // flush render event var overlay = SteamVR_Overlay.instance; if (overlay != null) { overlay.UpdateOverlay(vr); } RenderEye(vr, Hmd_Eye.Eye_Left, leftMask); RenderEye(vr, Hmd_Eye.Eye_Right, rightMask); if (cameraMask != null) { cameraMask.Clear(); } GL.IssuePluginEvent(20150213); // Fire off render event for in-process present hook } }
void AddInternal(SteamVR_Camera vrcam) { try { var camera = vrcam.GetComponent <Camera>(); var length = cameras.Length; var sorted = new SteamVR_Camera[length + 1]; int insert = 0; for (int i = 0; i < length; i++) { var c = cameras[i].GetComponent <Camera>(); if (i == insert && c.depth > camera.depth) { sorted[insert++] = vrcam; } sorted[insert++] = cameras[i]; } if (insert == length) { sorted[insert] = vrcam; } cameras = sorted; } catch (Exception e) { Console.WriteLine(e); } }
private void RemoveInternal(SteamVR_Camera vrcam) { var length = cameras.Length; int count = 0; for (int i = 0; i < length; i++) { var c = cameras[i]; if (c == vrcam) { ++count; } } if (count == 0) { return; } var sorted = new SteamVR_Camera[length - count]; int insert = 0; for (int i = 0; i < length; i++) { var c = cameras[i]; if (c != vrcam) { sorted[insert++] = c; } } cameras = sorted; }
private IEnumerator RenderLoop() { while (Application.isPlaying) { yield return(waitForEndOfFrame); if (pauseRendering) { continue; } var compositor = OpenVR.Compositor; if (compositor != null) { if (!compositor.CanRenderScene()) { continue; } compositor.SetTrackingSpace(trackingSpace); //SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_WaitGetPoses); //This is what the above commented out line does: GL.IssuePluginEvent(201510020); // Hack to flush render event that was queued in Update (this ensures WaitGetPoses has returned before we grab the new values). SteamVR_Camera.GetSceneTexture(cameras[0].GetComponent <Camera>().hdr).GetNativeTexturePtr(); compositor.GetLastPoses(poses, gamePoses); SteamVR_Events.NewPoses.Send(poses); SteamVR_Events.NewPosesApplied.Send(); } var overlay = SteamVR_Overlay.instance; if (overlay != null) { overlay.UpdateOverlay(); } var vr = SteamVR.instance; RenderEye(vr, EVREye.Eye_Left); RenderEye(vr, EVREye.Eye_Right); // Move cameras back to head position so they can be tracked reliably foreach (var c in cameras) { c.transform.localPosition = Vector3.zero; c.transform.localRotation = Quaternion.identity; } if (cameraMask != null) { cameraMask.Clear(); } } }
public override void SetVREnabled(bool isEnabled) { if (!IsPresent) { return; } if (steamCamera == null) { var playerObject = GameObject.FindWithTag("Player"); var camera = Camera.main.transform; var trackingSpace = camera.parent; var head = trackingSpace != null ? trackingSpace.parent : trackingSpace; if (playerObject == null || trackingSpace == null) { throw new UnityException("[OpenVRManager] Your prefab doesn't respect the correct hierarchy"); } // Creates the SteamVR's main camera. steamCamera = camera.gameObject.AddComponent <SteamVR_Camera>(); // The controllers. if (_addControllersNode) { var controllerGameObject = new GameObject("SteamVR_Controllers"); var controllerTransform = controllerGameObject.transform; controllerTransform.parent = head; controllerTransform.localPosition = Vector3.zero; controllerTransform.localRotation = Quaternion.identity; // We need to disable the gameobject because the SteamVR_ControllerManager component // Will check attached controllers in the awake method. // Here we don't have attached controllers yet. controllerGameObject.SetActive(false); var controllerManager = controllerGameObject.AddComponent <SteamVR_ControllerManager>(); controllerManager.left = CreateController(controllerManager.transform, "Controller (left)"); controllerManager.right = CreateController(controllerManager.transform, "Controller (right)"); // Now that controllers are attached, we can enable the GameObject controllerGameObject.SetActive(true); } // And finally the play area. if (_addPlayArea) { var playArea = new GameObject("SteamVR_PlayArea"); playArea.transform.parent = playerObject.transform; playArea.AddComponent <MeshRenderer>(); playArea.AddComponent <MeshFilter>(); playArea.AddComponent <SteamVR_PlayArea>(); } head.localPosition = Vector3.zero; head.localRotation = Quaternion.identity; } VRSettings.enabled = isEnabled; }
private static void Prefix(ref Resolution res) { // We use the unscaled resolution for screen liquid effects to prevent the effects from being scaled or going off-screen Resolution scaledHMDRes = SteamVR_Camera.GetResolutionForAspect(16, 9); res.width = scaledHMDRes.width; res.height = scaledHMDRes.height; }
private void GetReferencesSteamVR() { var scm = GetComponentInChildren <SteamVR_ControllerManager>(true); steamVRRoot = scm.gameObject; steamVrHead = GetComponentInChildren <SteamVR_Camera>(true); steamVrLeft = scm.left; steamVrRight = scm.right; }
void OnPostRender() { var vr = SteamVR.instance; var camera = GetComponent <Camera>(); var aspect = scale * camera.aspect / vr.aspect; var x0 = -scale; var x1 = scale; var y0 = aspect; var y1 = -aspect; var blitMaterial = SteamVR_Camera.blitMaterial; blitMaterial.mainTexture = SteamVR_Camera.GetSceneTexture(camera.hdr); GL.PushMatrix(); GL.LoadOrtho(); #if !(UNITY_5_0) blitMaterial.SetPass(0); #else blitMaterial.SetPass(QualitySettings.activeColorSpace == ColorSpace.Linear ? 1 : 0); #endif GL.Begin(GL.QUADS); GL.TexCoord2(0.0f, 0.0f); GL.Vertex3(x0, y0, 0); GL.TexCoord2(1.0f, 0.0f); GL.Vertex3(x1, y0, 0); GL.TexCoord2(1.0f, 1.0f); GL.Vertex3(x1, y1, 0); GL.TexCoord2(0.0f, 1.0f); GL.Vertex3(x0, y1, 0); GL.End(); GL.PopMatrix(); var overlay = SteamVR_Overlay.instance; if (overlay && overlay.texture && overlayMaterial && drawOverlay) { var texture = overlay.texture; overlayMaterial.mainTexture = texture; var u0 = 0.0f; var v0 = 1.0f - (float)Screen.height / texture.height; var u1 = (float)Screen.width / texture.width; var v1 = 1.0f; GL.PushMatrix(); GL.LoadOrtho(); #if !(UNITY_5_0) overlayMaterial.SetPass(QualitySettings.activeColorSpace == ColorSpace.Linear ? 1 : 0); #else overlayMaterial.SetPass(0); #endif GL.Begin(GL.QUADS); GL.TexCoord2(u0, v0); GL.Vertex3(-1, -1, 0); GL.TexCoord2(u1, v0); GL.Vertex3(1, -1, 0); GL.TexCoord2(u1, v1); GL.Vertex3(1, 1, 0); GL.TexCoord2(u0, v1); GL.Vertex3(-1, 1, 0); GL.End(); GL.PopMatrix(); } }
// Token: 0x06000D79 RID: 3449 RVA: 0x00054530 File Offset: 0x00052730 public void AttachToCamera(SteamVR_Camera vrcam) { if (this.target == vrcam.head) { return; } this.target = vrcam.head; Transform parent = base.transform.parent; Transform parent2 = vrcam.head.parent; parent.parent = parent2; parent.localPosition = Vector3.zero; parent.localRotation = Quaternion.identity; parent.localScale = Vector3.one; vrcam.enabled = false; GameObject gameObject = Object.Instantiate <GameObject>(vrcam.gameObject); vrcam.enabled = true; gameObject.name = "camera"; Object.DestroyImmediate(gameObject.GetComponent <SteamVR_Camera>()); Object.DestroyImmediate(gameObject.GetComponent <SteamVR_Fade>()); this.cam = gameObject.GetComponent <Camera>(); this.cam.stereoTargetEye = StereoTargetEyeMask.None; this.cam.fieldOfView = this.config.fov; this.cam.useOcclusionCulling = false; this.cam.enabled = false; this.colorMat = new Material(Shader.Find("Custom/SteamVR_ColorOut")); this.alphaMat = new Material(Shader.Find("Custom/SteamVR_AlphaOut")); this.clipMaterial = new Material(Shader.Find("Custom/SteamVR_ClearAll")); Transform transform = gameObject.transform; transform.parent = base.transform; transform.localPosition = new Vector3(this.config.x, this.config.y, this.config.z); transform.localRotation = Quaternion.Euler(this.config.rx, this.config.ry, this.config.rz); transform.localScale = Vector3.one; while (transform.childCount > 0) { Object.DestroyImmediate(transform.GetChild(0).gameObject); } this.clipQuad = GameObject.CreatePrimitive(PrimitiveType.Quad); this.clipQuad.name = "ClipQuad"; Object.DestroyImmediate(this.clipQuad.GetComponent <MeshCollider>()); MeshRenderer component = this.clipQuad.GetComponent <MeshRenderer>(); component.material = this.clipMaterial; component.shadowCastingMode = ShadowCastingMode.Off; component.receiveShadows = false; component.lightProbeUsage = LightProbeUsage.Off; component.reflectionProbeUsage = ReflectionProbeUsage.Off; Transform transform2 = this.clipQuad.transform; transform2.parent = transform; transform2.localScale = new Vector3(1000f, 1000f, 1f); transform2.localRotation = Quaternion.identity; this.clipQuad.SetActive(false); }
public void Awake() { playerCtrl = GetComponent <PlayerController>(); headCamera = GetComponentInChildren <SteamVR_Camera>(); if (!playerCtrl.IsViveController) { throw new System.Exception("Cannot use VivePlayerMovement on non vive player"); } }
private void SetScale(float scale) { this.scale = scale; SteamVR_Camera steamVR_Camera = SteamVR_Render.Top(); if (steamVR_Camera != null) { steamVR_Camera.origin.localScale = new Vector3(scale, scale, scale); } }
void setPositionalData(SensorData sensor, SteamVR_Camera head) { sensor.position.x = head.transform.position.x; sensor.position.y = head.transform.position.y; sensor.position.z = head.transform.position.z; sensor.rotation.pitch = head.transform.rotation.eulerAngles.y; sensor.rotation.yaw = head.transform.rotation.eulerAngles.z; sensor.rotation.roll = head.transform.rotation.eulerAngles.x; }
private void SetupVRPlayerCamera() { if (VRCamera) { return; } // Handle head transform manually to better fit into the game's systems and allow things like syncing lookDir online // This is handled in harmony injections to FPSCamera VRCamera = fpscamera.gameObject.AddComponent <SteamVR_Camera>(); }
void FindTracker() { foreach (var cam in Object.FindObjectsOfType(typeof(SteamVR_Camera)) as SteamVR_Camera[]) { if (cam.applyDistortion) { tracker = cam; break; } } }
public void ForceLast() { if (SteamVR_Camera.values != null) { IDictionaryEnumerator enumerator = SteamVR_Camera.values.GetEnumerator(); try { while (enumerator.MoveNext()) { object obj = enumerator.Current; DictionaryEntry dictionaryEntry = (DictionaryEntry)obj; FieldInfo fieldInfo = dictionaryEntry.Key as FieldInfo; fieldInfo.SetValue(this, dictionaryEntry.Value); } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } SteamVR_Camera.values = null; } else { Component[] components = base.GetComponents <Component>(); for (int i = 0; i < components.Length; i++) { SteamVR_Camera steamVR_Camera = components[i] as SteamVR_Camera; if (steamVR_Camera != null && steamVR_Camera != this) { UnityEngine.Object.DestroyImmediate(steamVR_Camera); } } components = base.GetComponents <Component>(); if (this != components[components.Length - 1]) { SteamVR_Camera.values = new Hashtable(); FieldInfo[] fields = base.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (FieldInfo fieldInfo2 in fields) { if (fieldInfo2.IsPublic || fieldInfo2.IsDefined(typeof(SerializeField), true)) { SteamVR_Camera.values[fieldInfo2] = fieldInfo2.GetValue(this); } } GameObject gameObject = base.gameObject; UnityEngine.Object.DestroyImmediate(this); gameObject.AddComponent <SteamVR_Camera>().ForceLast(); } } }
// Start is called before the first frame update void Start() { head = SteamVR_Render.Top().head; rb = GetComponent <Rigidbody>(); player = GetComponent <CapsuleCollider>(); vision = GetComponent <SteamVR_Camera>(); LeftHand = GetComponentInChildren <Transform>(); RightHand = GetComponentInChildren <Transform>(); velocity.y = Mathf.Clamp(velocity.y, 0, 100); }
// Token: 0x060055B2 RID: 21938 RVA: 0x001D894C File Offset: 0x001D6D4C public override void Awake() { base.Awake(); this.mouseGaze = base.GetComponentInChildren <NeckMouseRotator>(); this.neckTransform = this.mouseGaze.transform; this.gameView = base.GetComponentInChildren <SteamVR_GameView>(); this.eyeTransform = this.neckTransform.GetChild(0); this.postCamera = this.gameView.GetComponent <Camera>(); SteamVR_Camera componentInChildren = base.GetComponentInChildren <SteamVR_Camera>(); this.eyeCamera = componentInChildren.GetComponent <Camera>(); }
private void StationSensor(Collider other, VRSensor sensor) { if (!trainDepart) { SteamVR_Camera player = other.GetComponent <SteamVR_Camera>(); if (player != null) { Depart(); trainDepart = true; } } }
private void OnPostRender() { SteamVR instance = SteamVR.instance; Camera component = base.GetComponent <Camera>(); float num = this.scale * component.aspect / instance.aspect; float x = -this.scale; float x2 = this.scale; float y = num; float y2 = -num; Material blitMaterial = SteamVR_Camera.blitMaterial; blitMaterial.mainTexture = SteamVR_Camera.GetSceneTexture(component.hdr); GL.PushMatrix(); GL.LoadOrtho(); blitMaterial.SetPass(0); GL.Begin(7); GL.TexCoord2(0f, 0f); GL.Vertex3(x, y, 0f); GL.TexCoord2(1f, 0f); GL.Vertex3(x2, y, 0f); GL.TexCoord2(1f, 1f); GL.Vertex3(x2, y2, 0f); GL.TexCoord2(0f, 1f); GL.Vertex3(x, y2, 0f); GL.End(); GL.PopMatrix(); SteamVR_Overlay instance2 = SteamVR_Overlay.instance; if (instance2 && instance2.texture && SteamVR_GameView.overlayMaterial && this.drawOverlay) { Texture texture = instance2.texture; SteamVR_GameView.overlayMaterial.mainTexture = texture; float x3 = 0f; float y3 = 1f - (float)Screen.height / (float)texture.height; float x4 = (float)Screen.width / (float)texture.width; float y4 = 1f; GL.PushMatrix(); GL.LoadOrtho(); SteamVR_GameView.overlayMaterial.SetPass((QualitySettings.activeColorSpace != ColorSpace.Linear) ? 0 : 1); GL.Begin(7); GL.TexCoord2(x3, y3); GL.Vertex3(-1f, -1f, 0f); GL.TexCoord2(x4, y3); GL.Vertex3(1f, -1f, 0f); GL.TexCoord2(x4, y4); GL.Vertex3(1f, 1f, 0f); GL.TexCoord2(x3, y4); GL.Vertex3(-1f, 1f, 0f); GL.End(); GL.PopMatrix(); } }
void AddInternal(SteamVR_Camera vrcam) { var camera = vrcam.GetComponent<Camera>(); var length = cameras.Length; var sorted = new SteamVR_Camera[length + 1]; int insert = 0; for (int i = 0; i < length; i++) { var c = cameras[i].GetComponent<Camera>(); if (i == insert && c.depth > camera.depth) sorted[insert++] = vrcam; sorted[insert++] = cameras[i]; } if (insert == length) sorted[insert] = vrcam; cameras = sorted; }
public static void Remove(SteamVR_Camera vrcam) { if (!isQuitting && _instance != null) instance.RemoveInternal(vrcam); }
public static void Add(SteamVR_Camera vrcam) { if (!isQuitting) instance.AddInternal(vrcam); }
void RemoveInternal(SteamVR_Camera vrcam) { var length = cameras.Length; int count = 0; for (int i = 0; i < length; i++) { var c = cameras[i]; if (c == vrcam) ++count; } if (count == 0) return; var sorted = new SteamVR_Camera[length - count]; int insert = 0; for (int i = 0; i < length; i++) { var c = cameras[i]; if (c != vrcam) sorted[insert++] = c; } cameras = sorted; }