private void ApplyPose(SteamVR_Utils.RigidTransform relPose, SteamVR_Utils.RigidTransform pose) { var newPos = pose.pos - relPose.pos; transform.position = AttachTo.position + newPos; transform.rotation = Quaternion.Euler(pose.rot.eulerAngles); transform.RotateAround(RotationAnchor.transform.position, RotationAxis, RotateBy); }
// Builds a tessellated grid of quads across the provided bounds with three sets of UVs used to account for // lens distortion and chromatic aberration. public static Mesh CreateDistortMesh(SteamVR.IHmd hmd, SteamVR.Hmd_Eye eye, int resU, int resV, Rect bounds) { int numVerts = resU * resV; var vertices = new Vector3[numVerts]; var redUVs = new Vector3[numVerts]; var greenUVs = new Vector2[numVerts]; var blueUVs = new Vector2[numVerts]; int iTri = 0; int resUm1 = resU - 1; int resVm1 = resV - 1; var triangles = new int[2 * 3 * resUm1 * resVm1]; for (int iV = 0; iV < resV; iV++) { float v = (float)iV / resVm1; float y = SteamVR_Utils.Lerp(bounds.yMax, bounds.yMin, v); // ComputeDistortion expects 0,0 in upper left for (int iU = 0; iU < resU; iU++) { float u = (float)iU / resUm1; float x = SteamVR_Utils.Lerp(bounds.xMin, bounds.xMax, u); var coords = hmd.ComputeDistortion(eye, u, v); int idx = iV * resU + iU; vertices[idx] = new Vector3(x, y, 0.1f); redUVs[idx] = new Vector3(coords.rfRed[0], 1.0f - coords.rfRed[1], 0); greenUVs[idx] = new Vector2(coords.rfGreen[0], 1.0f - coords.rfGreen[1]); blueUVs[idx] = new Vector2(coords.rfBlue[0], 1.0f - coords.rfBlue[1]); if (iV > 0 && iU > 0) { int a = (iV - 1) * resU + (iU - 1); int b = (iV - 1) * resU + iU; int c = iV * resU + (iU - 1); int d = iV * resU + iU; triangles[iTri++] = a; triangles[iTri++] = b; triangles[iTri++] = d; triangles[iTri++] = a; triangles[iTri++] = d; triangles[iTri++] = c; } } } var mesh = new Mesh(); mesh.vertices = vertices; mesh.normals = redUVs; // stuff data in normals since only two uv sets exposed mesh.uv = greenUVs; mesh.uv2 = blueUVs; mesh.triangles = triangles; return(mesh); }
void Update() { if (cameras.Length == 0) { enabled = false; return; } // If our FixedUpdate rate doesn't match our render framerate, then catch the handoff here. SteamVR_Utils.QueueEventOnRenderThread(Unity.k_nRenderEventID_PostPresentHandoff); // Force controller update in case no one else called this frame to ensure prevState gets updated. SteamVR_Controller.Update(); // Dispatch any OpenVR events. var vr = SteamVR.instance; var vrEvent = new VREvent_t(); for (int i = 0; i < 64; i++) { if (!vr.hmd.PollNextEvent(ref vrEvent)) { break; } switch ((EVREventType)vrEvent.eventType) { case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard) SteamVR_Utils.Event.Send("input_focus", false); break; case EVREventType.VREvent_InputFocusReleased: // that app has released input focus SteamVR_Utils.Event.Send("input_focus", true); break; default: var name = System.Enum.GetName(typeof(EVREventType), vrEvent.eventType); if (name != null) { SteamVR_Utils.Event.Send(name.Substring(8) /*strip VREvent_*/, vrEvent); } break; } } // Ensure various settings to minimize latency. Application.targetFrameRate = -1; Application.runInBackground = true; // don't require companion window focus QualitySettings.maxQueuedFrames = -1; QualitySettings.vSyncCount = 0; // this applies to the companion window if (lockPhysicsUpdateRateToRenderFrequency) { Time.fixedDeltaTime = 1.0f / vr.hmd_DisplayFrequency; } }
protected override void UpdateHovering() { if ((noSteamVRFallbackCamera == null) && (isActive == false)) { return; } if (hoverLocked) { return; } if (applicationLostFocusObject.activeSelf) { return; } float closestDistance = float.MaxValue; Interactable closestInteractable = null; if (useHoverSphere) { float scaledHoverRadius = hoverSphereRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(hoverSphereTransform)); CheckHoveringForTransform(hoverSphereTransform.position, scaledHoverRadius, ref closestDistance, ref closestInteractable, Color.green); } if (useControllerHoverComponent && mainRenderModel != null && mainRenderModel.IsControllerVisibile()) { float scaledHoverRadius = controllerHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); // substitute drumstick object in place of SteamVR's HoverPoint if (drumstick != null) { // get position and radius of drumstick Vector3 drumstickPosition = drumstick.transform.position; float drumstickRadius = drumstick.transform.lossyScale.x / 2f; // use SteamVR's method to detect if interactable component overlaps with drumstick size and position CheckHoveringForTransform(drumstickPosition, drumstickRadius, ref closestDistance, ref closestInteractable, Color.blue); } else { Debug.LogError("Drumsticks not detected. Defaulting to SteamVR hover component."); CheckHoveringForTransform(mainRenderModel.GetControllerPosition(controllerHoverComponent), scaledHoverRadius / 2f, ref closestDistance, ref closestInteractable, Color.blue); } } if (useFingerJointHover && mainRenderModel != null && mainRenderModel.IsHandVisibile()) { float scaledHoverRadius = fingerJointHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); CheckHoveringForTransform(mainRenderModel.GetBonePosition((int)fingerJointHover), scaledHoverRadius / 2f, ref closestDistance, ref closestInteractable, Color.yellow); } // Hover on this one hoveringInteractable = closestInteractable; }
public void Set(SteamVR vr, Valve.VR.EVREye eye) { int i = (int)eye; if (hiddenAreaMeshes[i] == null) { hiddenAreaMeshes[i] = SteamVR_Utils.CreateHiddenAreaMesh(vr.hmd.GetHiddenAreaMesh(eye, Valve.VR.EHiddenAreaMeshType.k_eHiddenAreaMesh_Standard), vr.textureBounds[i]); } meshFilter.mesh = hiddenAreaMeshes[i]; }
private void ApplyPose(SteamVR_Utils.RigidTransform pose) { if (TrackPosition) { transform.position = pose.pos; } if (TrackRotation) { transform.rotation = CalibrationParams.RotationOffset * pose.rot; } }
//------------------------------------------------- private void ComputeTextEndTransforms() { //This is done as a separate step after all the ButtonHintInfos have been initialized //to make the text hints fan out appropriately based on the button's position on the controller. centerPosition /= actionHintInfos.Count; float maxDistanceFromCenter = 0.0f; foreach (var hintInfo in actionHintInfos) { hintInfo.Value.distanceFromCenter = Vector3.Distance(hintInfo.Value.textStartAnchor.position, centerPosition); if (hintInfo.Value.distanceFromCenter > maxDistanceFromCenter) { maxDistanceFromCenter = hintInfo.Value.distanceFromCenter; } } foreach (var hintInfo in actionHintInfos) { Vector3 centerToButton = hintInfo.Value.textStartAnchor.position - centerPosition; centerToButton.Normalize(); centerToButton = Vector3.Project(centerToButton, renderModel.transform.forward); //Spread out the text end positions based on the distance from the center float t = hintInfo.Value.distanceFromCenter / maxDistanceFromCenter; float scale = hintInfo.Value.distanceFromCenter * Mathf.Pow(2, 10 * (t - 1.0f)) * 20.0f; //Flip the direction of the end pos based on which hand this is float endPosOffset = 0.1f; Vector3 hintEndPos = hintInfo.Value.textStartAnchor.position + (hintInfo.Value.textEndOffsetDir * endPosOffset) + (centerToButton * scale * 0.1f); if (SteamVR_Utils.IsValid(hintEndPos)) { hintInfo.Value.textEndAnchor.position = hintEndPos; hintInfo.Value.canvasOffset.position = hintEndPos; } else { Debug.LogWarning( "<b>[SteamVR Interaction]</b> Invalid end position for: " + hintInfo.Value.textStartAnchor.name, hintInfo.Value.textStartAnchor.gameObject); } hintInfo.Value.canvasOffset.localRotation = Quaternion.identity; } }
public static Quaternion GetRotation(this Matrix4x4 matrix) { Quaternion quaternion = default(Quaternion); quaternion.w = Mathf.Sqrt(Mathf.Max(0f, 1f + matrix.m00 + matrix.m11 + matrix.m22)) / 2f; quaternion.x = Mathf.Sqrt(Mathf.Max(0f, 1f + matrix.m00 - matrix.m11 - matrix.m22)) / 2f; quaternion.y = Mathf.Sqrt(Mathf.Max(0f, 1f - matrix.m00 + matrix.m11 - matrix.m22)) / 2f; quaternion.z = Mathf.Sqrt(Mathf.Max(0f, 1f - matrix.m00 - matrix.m11 + matrix.m22)) / 2f; quaternion.x = SteamVR_Utils._copysign(quaternion.x, matrix.m21 - matrix.m12); quaternion.y = SteamVR_Utils._copysign(quaternion.y, matrix.m02 - matrix.m20); quaternion.z = SteamVR_Utils._copysign(quaternion.z, matrix.m10 - matrix.m01); return(quaternion); }
private IEnumerator RenderLoop() { while (true) { yield return(new WaitForEndOfFrame()); if (pauseRendering) { continue; } var vr = SteamVR.instance; if (!vr.compositor.CanRenderScene()) { continue; } vr.compositor.SetTrackingSpace(trackingSpace); SteamVR_Utils.QueueEventOnRenderThread(Unity.k_nRenderEventID_WaitGetPoses); // Hack to flush render event that was queued in Update (this ensures WaitGetPoses has returned before we grab the new values). Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - Begin"); SteamVR_Camera.GetSceneTexture(cameras[0].GetComponent <Camera>().hdr).GetNativeTexturePtr(); Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - End"); vr.compositor.GetLastPoses(poses, gamePoses); SteamVR_Utils.Event.Send("new_poses", poses); var overlay = SteamVR_Overlay.instance; if (overlay != null) { overlay.UpdateOverlay(vr); } 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 void Set(SteamVR vr, Valve.VR.EVREye eye) { try { int i = (int)eye; if (hiddenAreaMeshes[i] == null) { hiddenAreaMeshes[i] = SteamVR_Utils.CreateHiddenAreaMesh(vr.hmd.GetHiddenAreaMesh(eye), vr.textureBounds[i]); } meshFilter.mesh = hiddenAreaMeshes[i]; } catch (Exception e) { Console.WriteLine(e); } }
void OnRenderImage(RenderTexture src, RenderTexture dest) { try { if (SteamVR_Render.Top() == this) { int eventID; if (SteamVR_Render.eye == EVREye.Eye_Left) { // Get gpu started on work early to avoid bubbles at the top of the frame. SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_Flush); eventID = SteamVR.Unity.k_nRenderEventID_SubmitL; } else { eventID = SteamVR.Unity.k_nRenderEventID_SubmitR; } // Queue up a call on the render thread to Submit our render target to the compositor. SteamVR_Utils.QueueEventOnRenderThread(eventID); //Texture_t t = new Texture_t() { eColorSpace = EColorSpace.Auto, eType = EGraphicsAPIConvention.API_DirectX, handle = _sceneTexture.GetNativeTexturePtr() }; //VRTextureBounds_t b = SteamVR_Render.eye == EVREye.Eye_Left ? SteamVR.instance.textureBounds[0] : SteamVR.instance.textureBounds[1]; //var res = OpenVR.Compositor.Submit(SteamVR_Render.eye, ref t, ref b, EVRSubmitFlags.Submit_Default); //Console.WriteLine(res); } Graphics.SetRenderTarget(dest); SteamVR_Camera.blitMaterial.mainTexture = src; GL.PushMatrix(); GL.LoadOrtho(); SteamVR_Camera.blitMaterial.SetPass(0); GL.Begin(GL.QUADS); GL.TexCoord2(0.0f, 0.0f); GL.Vertex3(-1, 1, 0); GL.TexCoord2(1.0f, 0.0f); GL.Vertex3(1, 1, 0); GL.TexCoord2(1.0f, 1.0f); GL.Vertex3(1, -1, 0); GL.TexCoord2(0.0f, 1.0f); GL.Vertex3(-1, -1, 0); GL.End(); GL.PopMatrix(); Graphics.SetRenderTarget(null); } catch (Exception e) { Console.WriteLine(e); } }
protected virtual void UpdateHovering() { if (isActive == false) { return; } if (hoverLocked) { return; } if (applicationLostFocusObject.activeSelf) { Debug.Log("lost focus" + name); return; } float closestDistance = float.MaxValue; Interactable closestInteractable = null; if (useHoverSphere) { float scaledHoverRadius = hoverSphereRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(hoverSphereTransform)); CheckHoveringForTransform(hoverSphereTransform.position, scaledHoverRadius, ref closestDistance, ref closestInteractable, Color.green); } if (mainRenderModel != null) { if (mainRenderModel.IsControllerVisibile()) { float scaledHoverRadius = controllerHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); CheckHoveringForTransform(mainRenderModel.GetControllerPosition(controllerHoverComponent), scaledHoverRadius / 2f, ref closestDistance, ref closestInteractable, Color.blue); } if (useFingerJointHover && mainRenderModel.IsHandVisibile()) { float scaledHoverRadius = fingerJointHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); CheckHoveringForTransform(mainRenderModel.GetBonePosition((int)fingerJointHover), scaledHoverRadius / 2f, ref closestDistance, ref closestInteractable, Color.yellow); } } // Hover on this one hoveringInteractable = closestInteractable; }
protected void UpdateAttachedVelocity(AttachedObject attachedObjectInfo) { Transform attach_trans = transform; float scale = SteamVR_Utils.GetLossyScale(attach_trans); float maxVelocityChange = MaxVelocityChange * scale; float velocityMagic = VelocityMagic; float angularVelocityMagic = AngularVelocityMagic; float maxAngularVelocityChange = MaxAngularVelocityChange * scale; Vector3 targetItemPosition = attach_trans.TransformPoint(hand_attachment_offset_helper.localPosition); Vector3 positionDelta = (targetItemPosition - attachedObjectInfo.attachedRigidbody.position); Vector3 velocityTarget = (positionDelta * velocityMagic * Time.deltaTime); if (float.IsNaN(velocityTarget.x) == false && float.IsInfinity(velocityTarget.x) == false) { attachedObjectInfo.attachedRigidbody.velocity = Vector3.MoveTowards(attachedObjectInfo.attachedRigidbody.velocity, velocityTarget, maxVelocityChange); } Quaternion targetItemRotation = attach_trans.rotation * hand_attachment_offset_helper.localRotation; Quaternion rotationDelta = targetItemRotation * Quaternion.Inverse(attachedObjectInfo.attachedObject.transform.rotation); float angle; Vector3 axis; rotationDelta.ToAngleAxis(out angle, out axis); if (angle > 180) { angle -= 360; } if (angle != 0 && float.IsNaN(axis.x) == false && float.IsInfinity(axis.x) == false) { Vector3 angularTarget = angle * axis * angularVelocityMagic * Time.deltaTime; attachedObjectInfo.attachedRigidbody.angularVelocity = Vector3.MoveTowards(attachedObjectInfo.attachedRigidbody.angularVelocity, angularTarget, maxAngularVelocityChange); } }
// Sends the figurine down to the destination position over time. Once down, actually spawns the entity // and destroys the figurine. // Assumes the figurine is no longer grabbed. private IEnumerator dropFigurineToSpawn(Vector3 startPos, Vector3 destination, Hand hand) { _elapsedSpawnSeconds = 0f; float totalMeters = Vector3.Distance(startPos, destination); float _totalSeconds = totalMeters / _spawnMetersPerSecond; while (_elapsedSpawnSeconds < _totalSeconds) { hand.controller.TriggerHapticPulse(HapticSpawnDrop); var currentPos = SteamVR_Utils.Lerp(startPos, destination, _elapsedSpawnSeconds / _totalSeconds); transform.position = currentPos; _elapsedSpawnSeconds += Time.deltaTime; yield return(new WaitForEndOfFrame()); } FigurinePlacedEvent.Invoke(destination); }
//------------------------------------------------- protected virtual void OnHandHoverBegin(Hand hand) { bool showHint = false; // "Catch" the throwable by holding down the interaction button instead of pressing it. // Only do this if the throwable is moving faster than the prescribed threshold speed, // and if it isn't attached to another hand if (!attached && catchingSpeedThreshold != -1) { float catchingThreshold = catchingSpeedThreshold * SteamVR_Utils.GetLossyScale(Player.instance.trackingOriginTransform); GrabTypes bestGrabType = hand.GetBestGrabbingType(); if (bestGrabType != GrabTypes.None) { if (rigidbody.velocity.magnitude >= catchingThreshold) { hand.AttachObject(gameObject, bestGrabType, attachmentFlags); showHint = false; } } } // automatically grab any object if you were holding down the trigger before hovering the object. else if (!attached && autoGrabObject) { GrabTypes bestGrabType = hand.GetBestGrabbingType(); if (bestGrabType != GrabTypes.None) { hand.AttachObject(gameObject, bestGrabType, attachmentFlags); showHint = false; } } if (showHint) { hand.ShowGrabHint(); } }
protected virtual void OnDrawGizmos() { if (useHoverSphere) { Gizmos.color = Color.green; float scaledHoverRadius = hoverSphereRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(hoverSphereTransform)); Gizmos.DrawWireSphere(hoverSphereTransform.position, scaledHoverRadius / 2); } if (mainRenderModel != null && mainRenderModel.IsControllerVisibile()) { Gizmos.color = Color.blue; float scaledHoverRadius = controllerHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); Gizmos.DrawWireSphere(mainRenderModel.GetControllerPosition(controllerHoverComponent), scaledHoverRadius / 2 + .01f); } if (useFingerJointHover && mainRenderModel != null && mainRenderModel.IsHandVisibile()) { Gizmos.color = Color.yellow; float scaledHoverRadius = fingerJointHoverRadius * Mathf.Abs(SteamVR_Utils.GetLossyScale(this.transform)); Gizmos.DrawWireSphere(mainRenderModel.GetBonePosition((int)fingerJointHover), scaledHoverRadius / 2 + .02f); } }
private void OnRequestScreenshot(VREvent_t vrEvent) { uint handle = vrEvent.data.screenshot.handle; EVRScreenshotType type = (EVRScreenshotType)vrEvent.data.screenshot.type; if (type == EVRScreenshotType.StereoPanorama) { string previewFilename = GetScreenshotFilename(handle, EVRScreenshotPropertyFilenames.Preview); string VRFilename = GetScreenshotFilename(handle, EVRScreenshotPropertyFilenames.VR); if (previewFilename != null && VRFilename != null) { GameObject gameObject = new GameObject("screenshotPosition"); gameObject.transform.position = Top().transform.position; gameObject.transform.rotation = Top().transform.rotation; gameObject.transform.localScale = Top().transform.lossyScale; SteamVR_Utils.TakeStereoScreenshot(handle, gameObject, 32, 0.064f, ref previewFilename, ref VRFilename); OpenVR.Screenshots.SubmitScreenshot(handle, type, previewFilename, VRFilename); } } }
void OnRenderImage(RenderTexture src, RenderTexture dest) { if (SteamVR_Render.Top() == this) { int eventID; if (SteamVR_Render.eye == EVREye.Eye_Left) { // Get gpu started on work early to avoid bubbles at the top of the frame. SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_Flush); eventID = SteamVR.Unity.k_nRenderEventID_SubmitL; } else { eventID = SteamVR.Unity.k_nRenderEventID_SubmitR; } // Queue up a call on the render thread to Submit our render target to the compositor. SteamVR_Utils.QueueEventOnRenderThread(eventID); } Graphics.SetRenderTarget(dest); SteamVR_Camera.blitMaterial.mainTexture = src; GL.PushMatrix(); GL.LoadOrtho(); SteamVR_Camera.blitMaterial.SetPass(0); GL.Begin(GL.QUADS); GL.TexCoord2(0.0f, 0.0f); GL.Vertex3(-1, 1, 0); GL.TexCoord2(1.0f, 0.0f); GL.Vertex3(1, 1, 0); GL.TexCoord2(1.0f, 1.0f); GL.Vertex3(1, -1, 0); GL.TexCoord2(0.0f, 1.0f); GL.Vertex3(-1, -1, 0); GL.End(); GL.PopMatrix(); Graphics.SetRenderTarget(null); }
public static string GetBadMD5Hash(string usedString) { return(SteamVR_Utils.GetBadMD5Hash(Encoding.UTF8.GetBytes(usedString + "foobar"))); }
private void StashPose(SteamVR_Utils.RigidTransform pose) { _trackedPoses.Enqueue(new DelayedPose(pose)); }
public static Vector2 Abs(Vector2 A) { return(new Vector2(SteamVR_Utils.Abs(A.x), SteamVR_Utils.Abs(A.y))); }
public void Init(SteamVR_Camera tracker, SteamVR.Hmd_Eye eye, float depth) { this.tracker = tracker; this.eye = eye; var hmd = SteamVR.IHmd.instance; var i = (int)eye; uint x = 0, y = 0, w = 0, h = 0; hmd.GetEyeOutputViewport(eye, ref x, ref y, ref w, ref h); overlaySettings.kernel = new Vector3[] { // AA sub-pixel sampling (2x2 RGSS) new Vector3(0.125f / w, -0.375f / h, 0), new Vector3(0.375f / w, 0.125f / h, 0), new Vector3(-0.125f / w, 0.375f / h, 0), new Vector3(-0.375f / w, -0.125f / h, 0) }; float left = 0.0f, right = 0.0f, top = 0.0f, bottom = 0.0f; hmd.GetProjectionRaw(eye, ref left, ref right, ref top, ref bottom); var camera = GetComponent <Camera>(); float zFar = camera.farClipPlane; float zNear = camera.nearClipPlane; var m = Matrix4x4.identity; float idx = 1.0f / (right - left); float idy = 1.0f / (bottom - top); float idz = 1.0f / (zFar - zNear); float sx = right + left; float sy = bottom + top; m[0, 0] = 2 * idx; m[0, 1] = 0; m[0, 2] = sx * idx; m[0, 3] = 0; m[1, 0] = 0; m[1, 1] = 2 * idy; m[1, 2] = sy * idy; m[1, 3] = 0; m[2, 0] = 0; m[2, 1] = 0; m[2, 2] = -zFar * idz; m[2, 3] = -zFar * zNear * idz; m[3, 0] = 0; m[3, 1] = 0; m[3, 2] = -1.0f; m[3, 3] = 0; camera.projectionMatrix = m; camera.depth = depth; // enforce rendering order camera.eventMask = 0; // disable mouse events camera.orthographic = false; // force perspective camera.aspect = (float)w / h; // Use fov of projection matrix (which is grown to account for non-linear undistort) camera.fieldOfView = (Mathf.Atan(bottom) - Mathf.Atan(top)) * Mathf.Rad2Deg; // Copy and clear clearFlags to avoid duplicate work. if ((int)clearFlags == 0) { clearFlags = camera.clearFlags; camera.clearFlags = CameraClearFlags.Nothing; } camera.targetTexture = SteamVR_Camera.sceneTexture; overlaySettings.invProj = m.inverse; transform.parent = tracker.offset; transform.localScale = Vector3.one; var t = new SteamVR_Utils.RigidTransform(hmd.GetHeadFromEyePose(eye)); transform.localPosition = t.pos; transform.localRotation = t.rot; if (distortMesh[i] == null) { var viewportWidth = SteamVR_Camera.viewportTexture.width; var viewportHeight = SteamVR_Camera.viewportTexture.height; var eyeViewport = new Rect( 2.0f * x / viewportWidth - 1.0f, 2.0f * y / viewportHeight - 1.0f, 2.0f * w / viewportWidth, 2.0f * h / viewportHeight); distortMesh[i] = SteamVR_Utils.CreateDistortMesh(hmd, eye, 32, 32, eyeViewport); } }
private bool CalculateIntersection(DPOverlayBase dpBase, out IntersectionResults results) { results = new IntersectionResults(); return(SteamVR_Utils.ComputeIntersection(dpBase.overlay.handle, pointer.position, pointer.forward, SteamVRManager.trackingSpace, ref results)); }
public void Interpolate(RigidTransform to, float t) { pos = SteamVR_Utils.Lerp(pos, to.pos, t); rot = SteamVR_Utils.Slerp(rot, to.rot, t); }
public static Mesh CreateHiddenAreaMesh(HiddenAreaMesh_t src, VRTextureBounds_t bounds) { if (src.unTriangleCount == 0u) { return(null); } float[] array = new float[src.unTriangleCount * 3u * 2u]; Marshal.Copy(src.pVertexData, array, 0, array.Length); Vector3[] array2 = new Vector3[src.unTriangleCount * 3u + 12u]; int[] array3 = new int[src.unTriangleCount * 3u + 24u]; float num = 2f * bounds.uMin - 1f; float num2 = 2f * bounds.uMax - 1f; float num3 = 2f * bounds.vMin - 1f; float num4 = 2f * bounds.vMax - 1f; int num5 = 0; int num6 = 0; while ((long)num5 < (long)((ulong)(src.unTriangleCount * 3u))) { float x = SteamVR_Utils.Lerp(num, num2, array[num6++]); float y = SteamVR_Utils.Lerp(num3, num4, array[num6++]); array2[num5] = new Vector3(x, y, 0f); array3[num5] = num5; num5++; } int num7 = (int)(src.unTriangleCount * 3u); int num8 = num7; array2[num8++] = new Vector3(-1f, -1f, 0f); array2[num8++] = new Vector3(num, -1f, 0f); array2[num8++] = new Vector3(-1f, 1f, 0f); array2[num8++] = new Vector3(num, 1f, 0f); array2[num8++] = new Vector3(num2, -1f, 0f); array2[num8++] = new Vector3(1f, -1f, 0f); array2[num8++] = new Vector3(num2, 1f, 0f); array2[num8++] = new Vector3(1f, 1f, 0f); array2[num8++] = new Vector3(num, num3, 0f); array2[num8++] = new Vector3(num2, num3, 0f); array2[num8++] = new Vector3(num, num4, 0f); array2[num8++] = new Vector3(num2, num4, 0f); int num9 = num7; array3[num9++] = num7; array3[num9++] = num7 + 1; array3[num9++] = num7 + 2; array3[num9++] = num7 + 2; array3[num9++] = num7 + 1; array3[num9++] = num7 + 3; array3[num9++] = num7 + 4; array3[num9++] = num7 + 5; array3[num9++] = num7 + 6; array3[num9++] = num7 + 6; array3[num9++] = num7 + 5; array3[num9++] = num7 + 7; array3[num9++] = num7 + 1; array3[num9++] = num7 + 4; array3[num9++] = num7 + 8; array3[num9++] = num7 + 8; array3[num9++] = num7 + 4; array3[num9++] = num7 + 9; array3[num9++] = num7 + 10; array3[num9++] = num7 + 11; array3[num9++] = num7 + 3; array3[num9++] = num7 + 3; array3[num9++] = num7 + 11; array3[num9++] = num7 + 6; return(new Mesh { vertices = array2, triangles = array3, bounds = new Bounds(Vector3.zero, new Vector3(float.MaxValue, float.MaxValue, float.MaxValue)) }); }
public static Vector3 Lerp(Vector3 A, Vector3 B, float t) { return(new Vector3(SteamVR_Utils.Lerp(A.x, B.x, t), SteamVR_Utils.Lerp(A.y, B.y, t), SteamVR_Utils.Lerp(A.z, B.z, t))); }
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); #if (UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0) SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_WaitGetPoses); // Hack to flush render event that was queued in Update (this ensures WaitGetPoses has returned before we grab the new values). SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - Begin"); SteamVR_Camera.GetSceneTexture(cameras[0].GetComponent <Camera>().hdr).GetNativeTexturePtr(); SteamVR.Unity.EventWriteString("[UnityMain] GetNativeTexturePtr - End"); compositor.GetLastPoses(poses, gamePoses); SteamVR_Events.NewPoses.Send(poses); SteamVR_Events.NewPosesApplied.Send(); #endif } var overlay = SteamVR_Overlay.instance; if (overlay != null) { overlay.UpdateOverlay(); } RenderExternalCamera(); #if (UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0) 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(); } #endif } }
void FixedUpdate() { // We want to call this as soon after Present as possible. SteamVR_Utils.QueueEventOnRenderThread(Unity.k_nRenderEventID_PostPresentHandoff); }
public void Interpolate(SteamVR_Utils.RigidTransform to, float t) { this.pos = SteamVR_Utils.Lerp(this.pos, to.pos, t); this.rot = SteamVR_Utils.Slerp(this.rot, to.rot, t); }
private bool TestComputeIntersection(ulong handle, Transform point) { IntersectionResults results = new IntersectionResults(); return(SteamVR_Utils.ComputeIntersection(handle, point.position, point.forward, SteamVRManager.trackingSpace, ref results)); }
public static Vector2 Saturate(Vector2 A) { return(new Vector2(SteamVR_Utils.Saturate(A.x), SteamVR_Utils.Saturate(A.y))); }
protected IEnumerator DoRangeOfMotionBlend(EVRSkeletalMotionRange oldRangeOfMotion, EVRSkeletalMotionRange newRangeOfMotion, float overTime) { float startTime = Time.time; float endTime = startTime + overTime; Vector3[] oldBonePositions; Quaternion[] oldBoneRotations; Vector3[] newBonePositions; Quaternion[] newBoneRotations; while (Time.time < endTime) { yield return(null); float lerp = (Time.time - startTime) / overTime; if (skeletonBlend > 0) { skeletonAction.SetRangeOfMotion(oldRangeOfMotion); skeletonAction.UpdateValueWithoutEvents(); oldBonePositions = (Vector3[])GetBonePositions().Clone(); oldBoneRotations = (Quaternion[])GetBoneRotations().Clone(); skeletonAction.SetRangeOfMotion(newRangeOfMotion); skeletonAction.UpdateValueWithoutEvents(); newBonePositions = GetBonePositions(); newBoneRotations = GetBoneRotations(); for (int boneIndex = 0; boneIndex < bones.Length; boneIndex++) { if (bones[boneIndex] == null) { continue; } if (SteamVR_Utils.IsValid(newBoneRotations[boneIndex]) == false || SteamVR_Utils.IsValid(oldBoneRotations[boneIndex]) == false) { continue; } Vector3 blendedRangeOfMotionPosition = Vector3.Lerp(oldBonePositions[boneIndex], newBonePositions[boneIndex], lerp); Quaternion blendedRangeOfMotionRotation = Quaternion.Lerp(oldBoneRotations[boneIndex], newBoneRotations[boneIndex], lerp); if (skeletonBlend < 1) { if (blendPoser != null) { SetBonePosition(boneIndex, Vector3.Lerp(blendSnapshot.bonePositions[boneIndex], blendedRangeOfMotionPosition, skeletonBlend)); SetBoneRotation(boneIndex, Quaternion.Lerp(GetBlendPoseForBone(boneIndex, blendedRangeOfMotionRotation), blendedRangeOfMotionRotation, skeletonBlend)); } else { SetBonePosition(boneIndex, Vector3.Lerp(bones[boneIndex].localPosition, blendedRangeOfMotionPosition, skeletonBlend)); SetBoneRotation(boneIndex, Quaternion.Lerp(bones[boneIndex].localRotation, blendedRangeOfMotionRotation, skeletonBlend)); } } else { SetBonePosition(boneIndex, blendedRangeOfMotionPosition); SetBoneRotation(boneIndex, blendedRangeOfMotionRotation); } } } if (onBoneTransformsUpdated != null) { onBoneTransformsUpdated.Invoke(this, inputSource); } if (onBoneTransformsUpdatedEvent != null) { onBoneTransformsUpdatedEvent.Invoke(this, inputSource); } } rangeOfMotionBlendRoutine = null; }
protected override void OnUpdate() { #if !(UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0 || UNITY_4_5) if (poseUpdater == null) { var go = new GameObject("poseUpdater"); go.transform.parent = transform; poseUpdater = go.AddComponent <SteamVR_UpdatePoses>(); } #else if (cameras.Length == 0) { enabled = false; return; } // If our FixedUpdate rate doesn't match our render framerate, then catch the handoff here. SteamVR_Utils.QueueEventOnRenderThread(SteamVR.Unity.k_nRenderEventID_PostPresentHandoff); #endif // Force controller update in case no one else called this frame to ensure prevState gets updated. SteamVR_Controller.Update(); // Dispatch any OpenVR events. var system = OpenVR.System; if (system != null) { var vrEvent = new VREvent_t(); var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t)); for (int i = 0; i < 64; i++) { if (!system.PollNextEvent(ref vrEvent, size)) { break; } switch ((EVREventType)vrEvent.eventType) { case EVREventType.VREvent_InputFocusCaptured: // another app has taken focus (likely dashboard) SteamVR_Utils.Event.Send("input_focus", false); break; case EVREventType.VREvent_InputFocusReleased: // that app has released input focus SteamVR_Utils.Event.Send("input_focus", true); break; case EVREventType.VREvent_ShowRenderModels: SteamVR_Utils.Event.Send("hide_render_models", false); break; case EVREventType.VREvent_HideRenderModels: SteamVR_Utils.Event.Send("hide_render_models", true); break; default: var name = System.Enum.GetName(typeof(EVREventType), vrEvent.eventType); if (name != null) { SteamVR_Utils.Event.Send(name.Substring(8) /*strip VREvent_*/, vrEvent); } break; } } } // Ensure various settings to minimize latency. Application.targetFrameRate = -1; Application.runInBackground = true; // don't require companion window focus QualitySettings.maxQueuedFrames = -1; QualitySettings.vSyncCount = 0; // this applies to the companion window if (lockPhysicsUpdateRateToRenderFrequency) { var vr = SteamVR.instance; if (vr != null) { var timing = new Compositor_FrameTiming(); timing.m_nSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(Compositor_FrameTiming)); vr.compositor.GetFrameTiming(ref timing, 0); Time.fixedDeltaTime = Time.timeScale * timing.m_nNumFramePresents / SteamVR.instance.hmd_DisplayFrequency; } } }
public DelayedPose(SteamVR_Utils.RigidTransform pose) : this() { Pose = pose; }