public static void UpdateTrackableDevicePosition() { VRControllerState_t controllerState = new VRControllerState_t(); var size = (uint)Marshal.SizeOf(typeof(VRControllerState_t)); HmdVector3_t position = new HmdVector3_t(); HmdQuaternion_t quaternion = new HmdQuaternion_t(); uint LeftControllerIndex = OpenVR.System.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.LeftHand), RightControllerIndex = OpenVR.System.GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole.RightHand); OpenVR.System.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 1 / Program.DataFrameRate, TrackedDevicePose_t); if (TrackedDevicePose_t[0].bPoseIsValid) { GetPosition(TrackedDevicePose_t[0].mDeviceToAbsoluteTracking, ref position); GetRotation(TrackedDevicePose_t[0].mDeviceToAbsoluteTracking, ref quaternion); VREventCallback.NewPoseEvent(VREventCallback.DeviceType.HMD, position, quaternion); } OpenVR.System.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, LeftControllerIndex, ref controllerState, size, ref LeftControllerPose); if (LeftControllerPose.bPoseIsValid) { GetPosition(LeftControllerPose.mDeviceToAbsoluteTracking, ref position); GetRotation(LeftControllerPose.mDeviceToAbsoluteTracking, ref quaternion); VREventCallback.NewPoseEvent(VREventCallback.DeviceType.LeftController, position, quaternion); } OpenVR.System.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, RightControllerIndex, ref controllerState, size, ref RightControllerPose); if (RightControllerPose.bPoseIsValid) { GetPosition(RightControllerPose.mDeviceToAbsoluteTracking, ref position); GetRotation(RightControllerPose.mDeviceToAbsoluteTracking, ref quaternion); VREventCallback.NewPoseEvent(VREventCallback.DeviceType.RightController, position, quaternion); } }
// Use this for initialization void Start() { var rect = new HmdQuad_t(); if (!SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect)) { return; } // Could do without that var cornersVR = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; corners = new Vector3[cornersVR.Length]; for (int i = 0; i < cornersVR.Length; i++) { var c = cornersVR[i]; corners[i] = new Vector3(c.v0, 0.01f, c.v2); } // Make sure this is always the case minX = -Mathf.Abs(corners[0].x); maxX = Mathf.Abs(corners[0].x); minZ = -Mathf.Abs(corners[0].z); maxZ = Mathf.Abs(corners[0].z); music = transform.GetComponent <AudioSource>(); mixer = music.outputAudioMixerGroup.audioMixer; // Debugging text = GetComponentInChildren <TextMesh>(); }
public HmdVector3_t GetRotationEuler(HmdMatrix34_t matrix) { try { HmdVector3_t v = new HmdVector3_t(); float r2d = 180 / (float)Math.PI; if (matrix.m0 == 1 || matrix.m0 == -1) { v.v0 = -((-((float)Math.Atan2(matrix.m2, matrix.m11)) * r2d)); v.v1 = 0; v.v2 = 0; } else { v.v0 = -(((-(float)Math.Atan2(matrix.m8, matrix.m0)) * r2d)); v.v1 = -(((float)Math.Atan2(matrix.m6, matrix.m5)) * r2d); v.v2 = (((float)Math.Asin(matrix.m4)) * r2d); } return(v); } catch (Exception ex) { HmdVector3_t vt = new HmdVector3_t(); vt.v0 = 0.0f; vt.v1 = 0.0f; vt.v2 = 0.0f; return(vt); } }
void GetCollisionBoundsMesh() { List <Vector3> _vertices = new List <Vector3>(); foreach (HmdQuad_t quad in pCollisionQuadsBuffer1) { HmdVector3_t vCorners0 = quad.vCorners0; HmdVector3_t vCorners1 = quad.vCorners1; HmdVector3_t vCorners2 = quad.vCorners2; HmdVector3_t vCorners3 = quad.vCorners3; _vertices.Add(new Vector3(vCorners0.v0, vCorners0.v1, vCorners0.v2)); _vertices.Add(new Vector3(vCorners1.v0, vCorners1.v1, vCorners1.v2)); _vertices.Add(new Vector3(vCorners2.v0, vCorners2.v1, vCorners2.v2)); _vertices.Add(new Vector3(vCorners3.v0, vCorners3.v1, vCorners3.v2)); } vertices1 = _vertices.ToArray(); _vertices.Clear(); foreach (HmdQuad_t quad in pCollisionQuadsBuffer2) { HmdVector3_t vCorners0 = quad.vCorners0; HmdVector3_t vCorners1 = quad.vCorners1; HmdVector3_t vCorners2 = quad.vCorners2; HmdVector3_t vCorners3 = quad.vCorners3; _vertices.Add(new Vector3(vCorners0.v0, vCorners0.v1, vCorners0.v2)); _vertices.Add(new Vector3(vCorners1.v0, vCorners1.v1, vCorners1.v2)); _vertices.Add(new Vector3(vCorners2.v0, vCorners2.v1, vCorners2.v2)); _vertices.Add(new Vector3(vCorners3.v0, vCorners3.v1, vCorners3.v2)); } vertices2 = _vertices.ToArray(); }
private Vector3 GetVector3FromHmdVector(HmdVector3_t hmdVector3) { Vector3 output = new Vector3(hmdVector3.v0, hmdVector3.v1, hmdVector3.v2); print(output); return(output); }
public static DeviceState GetControllerPose(int controllerIndex, out Matrix pose, out Vector3 velocity, out Vector3 angVelocity) { var currentIndex = 0; pose = Matrix.Identity; velocity = Vector3.Zero; angVelocity = Vector3.Zero; for (uint index = 0; index < DevicePoses.Length; index++) { if (Valve.VR.OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.Controller) { if (currentIndex == controllerIndex) { HmdMatrix34_t openVRPose = DevicePoses[index].mDeviceToAbsoluteTracking; pose.M11 = openVRPose.m0; pose.M21 = openVRPose.m1; pose.M31 = openVRPose.m2; pose.M41 = openVRPose.m3; pose.M12 = openVRPose.m4; pose.M22 = openVRPose.m5; pose.M32 = openVRPose.m6; pose.M42 = openVRPose.m7; pose.M13 = openVRPose.m8; pose.M23 = openVRPose.m9; pose.M33 = openVRPose.m10; pose.M43 = openVRPose.m11; HmdVector3_t vel = DevicePoses[index].vVelocity; velocity.X = vel.v0; velocity.Y = vel.v1; velocity.Z = vel.v2; HmdVector3_t avel = DevicePoses[index].vAngularVelocity; angVelocity.X = avel.v0; angVelocity.Y = avel.v1; angVelocity.Z = avel.v2; var state = DeviceState.Invalid; if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid) { state = DeviceState.Valid; } else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange) { state = DeviceState.OutOfRange; } return(state); } currentIndex++; } } return(DeviceState.Invalid); }
public void ApplyPlacement() { var rect = new HmdQuad_t(); if (SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect)) { var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; Bounds playareaBounds = new Bounds(Vector3.zero, new Vector3(Mathf.Abs(corners[0].v0 - corners[1].v0), 0, Mathf.Abs(corners[0].v2 - corners[3].v2))); Vector3 closestPt = playareaBounds.ClosestPoint(playarea.InverseTransformPoint(transform.position)); transform.position = playarea.TransformPoint(closestPt); } }
private void OnNewPoses(TrackedDevicePose_t[] poses) { //Obtain hmd IMU position, accelerometer & gyroscope data HmdMatrix34_t pos = poses [0].mDeviceToAbsoluteTracking; string position = "Position : " + pos.m0 + ":" + pos.m1 + ":" + pos.m2; HmdVector3_t gyro = poses [0].vAngularVelocity; string gyroscope = "Gyro : " + gyro.v0 + ":" + gyro.v1 + ":" + gyro.v2; HmdVector3_t acc = poses[0].vVelocity; string acceleration = "Acceleration : " + acc.v0 + ":" + acc.v1 + ":" + acc.v2; //Debug.Log (position + " " + gyroscope + " " + acceleration); //------------------------------------------------------------------------------ }
// This will resize the given object to match the player play area void Start() { var rect = new HmdQuad_t(); if (SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect)) { var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; Vector3 scale = transform.localScale; var width = Mathf.Abs(corners[0].v0 - corners[1].v0) / meshWidth * scale.x; var length = Mathf.Abs(corners[0].v2 - corners[3].v2) / meshHeight * scale.y; scale.Set(length, width, scale.z); transform.localScale = scale; } }
public InputPoseActionData_t PoseFetchEventResult() { var size = (uint)Marshal.SizeOf(typeof(InputPoseActionData_t)); OpenVR.Input.GetPoseActionData(ActionHandle, ETrackingUniverseOrigin.TrackingUniverseStanding, 1 / Program.DataFrameRate, ref Pose, size, controller.ControllerHandle); if (Pose.pose.bDeviceIsConnected == true && Pose.pose.bPoseIsValid == true) { HmdVector3_t position = new HmdVector3_t(); HmdQuaternion_t quaternion = new HmdQuaternion_t(); TrackableDeviceInfo.GetPosition(Pose.pose.mDeviceToAbsoluteTracking, ref position); TrackableDeviceInfo.GetRotation(Pose.pose.mDeviceToAbsoluteTracking, ref quaternion); VREventCallback.NewPoseEvent(controller.ControllerType, (PoseControllerEvent)this, position, quaternion); } return(Pose); }
public ControllerEvent() { switch (EventType()) { case EventTypeEmun.Digital: Digital = new InputDigitalActionData_t(); break; case EventTypeEmun.Analog: Analog = new InputAnalogActionData_t(); break; case EventTypeEmun.Pose: Pose = new InputPoseActionData_t(); Position = new HmdVector3_t(); break; } }
public static DeviceState GetTrackerPose(int trackerIndex, ref Matrix pose, ref Vector3 velocity, ref Vector3 angVelocity) { var index = trackerIndex; HmdMatrix34_t openVRPose = DevicePoses[index].mDeviceToAbsoluteTracking; pose.M11 = openVRPose.m0; pose.M21 = openVRPose.m1; pose.M31 = openVRPose.m2; pose.M41 = openVRPose.m3; pose.M12 = openVRPose.m4; pose.M22 = openVRPose.m5; pose.M32 = openVRPose.m6; pose.M42 = openVRPose.m7; pose.M13 = openVRPose.m8; pose.M23 = openVRPose.m9; pose.M33 = openVRPose.m10; pose.M43 = openVRPose.m11; HmdVector3_t vel = DevicePoses[index].vVelocity; velocity.X = vel.v0; velocity.Y = vel.v1; velocity.Z = vel.v2; HmdVector3_t avel = DevicePoses[index].vAngularVelocity; angVelocity.X = avel.v0; angVelocity.Y = avel.v1; angVelocity.Z = avel.v2; var state = DeviceState.Invalid; if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid) { state = DeviceState.Valid; } else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange) { state = DeviceState.OutOfRange; } return(state); }
public void resize() { var rect = new HmdQuad_t(); if (!GetBounds(size, ref rect)) { return; } var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; vertices = new Vector3[corners.Length * 2]; for (int i = 0; i < corners.Length; i++) { var c = corners[i]; vertices[i] = new Vector3(c.v0, 0.01f, c.v2); vector3Size.Value = (new Vector3(c.v0, 0f, c.v2)); } }
private void BuildMesh() { var rect = new HmdQuad_t(); GetBounds(ref rect); var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; vertices = new Vector3[corners.Length * 2]; for (int i = 0; i < corners.Length; i++) { var c = corners[i]; vertices[i] = new Vector3(c.v0, 0.01f, c.v2); } for (int i = 0; i < corners.Length; i++) { vertices[corners.Length + i] = vertices[i]; } }
public Vector3[] GetRectangle() { var rect = new HmdQuad_t(); if (!GetBounds(size, ref rect)) { return(null); } var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; vertices = new Vector3[corners.Length * 2]; for (int i = 0; i < corners.Length; i++) { var c = corners[i]; vertices[i] = new Vector3(c.v0, 0.01f, c.v2); } return(vertices); }
public void resizePlatform() { var rect = new HmdQuad_t(); if (!SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect)) { Debug.LogError("VRACMAN ERROR: Failed to get Calibrated Play Area bounds! Make sure you have tracking first, and that your space is calibrated."); return; } var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; Vector3 chapScale = transform.localScale; chapScale.x = Mathf.Abs(corners[0].v0 - corners[1].v0) / 10; chapScale.z = Mathf.Abs(corners[0].v2 - corners[3].v2) / 10; transform.localScale = chapScale; Platform.transform.localScale = chapScale; bounds = Platform.GetComponentInChildren <MeshFilter>().mesh.bounds; minx = bounds.min.x; maxx = bounds.max.x; miny = bounds.min.y; minz = bounds.min.z; maxz = bounds.max.z; }
private bool generateInterior(HmdQuad_t rect, HmdVector3_t[] corners, List <Vector3> vertices, List <Vector2> uvs, out int[] faces) { int vertexOffset = vertices.Count; for (int i = 0; i < corners.Length; i++) { HmdVector3_t c = corners[i]; vertices.Add(new Vector3(c.v0, c.v1, c.v2)); } faces = new int[] { vertexOffset, vertexOffset + 1, vertexOffset + 3, vertexOffset + 1, vertexOffset + 2, vertexOffset + 3 }; uvs.Add(new Vector2(rect.vCorners0.v0, rect.vCorners0.v2)); uvs.Add(new Vector2(rect.vCorners1.v0, rect.vCorners1.v2)); uvs.Add(new Vector2(rect.vCorners2.v0, rect.vCorners2.v2)); uvs.Add(new Vector2(rect.vCorners3.v0, rect.vCorners3.v2)); return(true); }
public override bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRCompositor_ComputeOverlayIntersection(m_pVRCompositor,ref pSettings,fAspectRatio,eOrigin,vSource,vDirection,ref pvecIntersectionUV,ref pvecIntersectionTrackingSpace); return result; }
public static void ToVector3(ref HmdVector3_t vector, out Vector3 result) { result.X = vector.v0; result.Y = vector.v1; result.Z = vector.v2; }
/// Converts from SteamVR axis conventions and units to Unity static private Vector3 UnityFromSteamVr(HmdVector3_t v) { return(new Vector3(v.v0, v.v1, v.v2) * App.METERS_TO_UNITS); }
public void BuildMesh() { var rect = new HmdQuad_t(); if (!GetBounds(size, ref rect)) { return; } var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; vertices = new Vector3[corners.Length * 2]; for (int i = 0; i < corners.Length; i++) { var c = corners[i]; vertices[i] = new Vector3(c.v0, 0.01f, c.v2); } if (borderThickness == 0.0f) { GetComponent <MeshFilter>().mesh = null; return; } for (int i = 0; i < corners.Length; i++) { int next = (i + 1) % corners.Length; int prev = (i + corners.Length - 1) % corners.Length; var nextSegment = (vertices[next] - vertices[i]).normalized; var prevSegment = (vertices[prev] - vertices[i]).normalized; var vert = vertices[i]; vert += Vector3.Cross(nextSegment, Vector3.up) * borderThickness; vert += Vector3.Cross(prevSegment, Vector3.down) * borderThickness; vertices[corners.Length + i] = vert; } var triangles = new int[] { 0, 4, 1, 1, 4, 5, 1, 5, 2, 2, 5, 6, 2, 6, 3, 3, 6, 7, 3, 7, 0, 0, 7, 4 }; var uv = new Vector2[] { new Vector2(0.0f, 0.0f), new Vector2(1.0f, 0.0f), new Vector2(0.0f, 0.0f), new Vector2(1.0f, 0.0f), new Vector2(0.0f, 1.0f), new Vector2(1.0f, 1.0f), new Vector2(0.0f, 1.0f), new Vector2(1.0f, 1.0f) }; var colors = new Color[] { color, color, color, color, new Color(color.r, color.g, color.b, 0.0f), new Color(color.r, color.g, color.b, 0.0f), new Color(color.r, color.g, color.b, 0.0f), new Color(color.r, color.g, color.b, 0.0f) }; var mesh = new Mesh(); GetComponent <MeshFilter>().mesh = mesh; mesh.vertices = vertices; mesh.uv = uv; mesh.colors = colors; mesh.triangles = triangles; var renderer = GetComponent <MeshRenderer>(); renderer.material = new Material(Shader.Find("Sprites/Default")); renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off; renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; renderer.receiveShadows = false; renderer.lightProbeUsage = LightProbeUsage.Off; }
public static Vector3 Convert(this HmdVector3_t vec) { return(new Vector3(vec.v0, vec.v1, vec.v2)); }
public abstract bool ComputeOverlayIntersection(ref Compositor_OverlaySettings pSettings,float fAspectRatio,TrackingUniverseOrigin eOrigin,HmdVector3_t vSource,HmdVector3_t vDirection,ref HmdVector2_t pvecIntersectionUV,ref HmdVector3_t pvecIntersectionTrackingSpace);
private void Worker() { Thread.CurrentThread.IsBackground = true; // General var deviceTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform(); var notificationTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform(); var animationTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform(); var width = 1f; var height = 1f; var properties = new Payload.CustomProperties(); var anchorIndex = uint.MaxValue; var useWorldDeviceTransform = false; // Follow var follow = new Payload.Follow(); var originTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform(); var targetTransform = EasyOpenVRSingleton.Utils.GetEmptyTransform(); var followLerp = 0.0; var followTween = Tween.GetFunc(0); var followIsLerping = false; // General Animation var stage = AnimationStage.Idle; var hz = 60; // This default should never really be used as it reads Hz from headset. var msPerFrame = 1000 / hz; long timeStarted; var animationCount = 0; float animationSeconds = 0; // Easing var transition = new Payload.Transition(); var easeInCount = 0; var stayCount = 0; var easeOutCount = 0; var easeInLimit = 0; var stayLimit = 0; var easeOutLimit = 0; var tween = Tween.GetFunc(0); // Cycling var animateYaw = new Cycler(); var animatePitch = new Cycler(); var animateRoll = new Cycler(); var animateZ = new Cycler(); var animateY = new Cycler(); var animateX = new Cycler(); var animateScale = new Cycler(); var animateOpacity = new Cycler(); while (true) { timeStarted = DateTime.Now.Ticks; bool skip = false; if (_payload == null) // Get new payload { _requestForNewPayload?.Invoke(); skip = true; Thread.Sleep(100); } else if (stage == AnimationStage.Idle) { #region init // Initialize things that stay the same during the whole animation stage = AnimationStage.LoadingImage; properties = _payload.customProperties; useWorldDeviceTransform = properties.anchorType != 0 && properties.attachToAnchor && (properties.ignoreAnchorYaw || properties.ignoreAnchorPitch || properties.ignoreAnchorRoll); follow = properties.follow; followTween = Tween.GetFunc(follow.tweenType); var hmdHz = (int)Math.Round(_vr.GetFloatTrackedDeviceProperty(0, ETrackedDeviceProperty.Prop_DisplayFrequency_Float)); hz = properties.animationHz > 0 ? properties.animationHz : hmdHz; msPerFrame = 1000 / hz; // Set anchor switch (properties.anchorType) { case 1: var anchorIndexArr = _vr.GetIndexesForTrackedDeviceClass(ETrackedDeviceClass.HMD); if (anchorIndexArr.Length > 0) { anchorIndex = anchorIndexArr[0]; } break; case 2: anchorIndex = _vr.GetIndexForControllerRole(ETrackedControllerRole.LeftHand); break; case 3: anchorIndex = _vr.GetIndexForControllerRole(ETrackedControllerRole.RightHand); break; } bool LoadImage() { Debug.WriteLine($"Creating texture on UI thread with {_payload.customProperties.textAreas.Length} text areas"); if (!(_texture is null)) { _texture = null; } _texture = _payload.imageData?.Length > 0 ? Texture.LoadImageBase64(_payload.imageData, _payload.customProperties.textAreas) : Texture.LoadImageFile(_payload.imagePath); if (_texture is null) { Debug.WriteLine("Failed to load texture"); _responseAtError?.Invoke(_sessionId, _payload.customProperties.nonce, "Failed to load image into texture"); stage = AnimationStage.Idle; properties = null; animationCount = 0; _elapsedTime = 0; _payload = null; return(false); } else { stage = AnimationStage.Animating; Debug.WriteLine($"[{_texture.TextureId}]: {_texture.TextureDepth}"); Debug.WriteLine($"Texture created on UI thread, {_texture.Width}x{_texture.Height}"); return(true); } } // Size of overlay var loadedImage = false; if (Dispatcher.CurrentDispatcher != MainController.UiDispatcher) { Debug.WriteLine("Running animator on Dispatcher."); MainController.UiDispatcher.Invoke(() => { loadedImage = LoadImage(); }); } else { Debug.WriteLine("Running animator on GUI thread already."); loadedImage = LoadImage(); } if (!loadedImage) { continue; } // var size = _texture.Load(_payload.imageData, properties.textAreas); width = properties.widthM; // height = width / size.v0 * size.v1; // Debug.WriteLine($"Texture width: {size.v0}, height: {size.v1}"); // Animation limits easeInCount = ( properties.transitions.Length > 0 ? properties.transitions[0].durationMs : 100 ) / msPerFrame; stayCount = properties.durationMs / msPerFrame; easeOutCount = ( properties.transitions.Length >= 2 ? properties.transitions[1].durationMs : properties.transitions.Length > 0 ? properties.transitions[0].durationMs : 100 ) / msPerFrame; easeInLimit = easeInCount; stayLimit = easeInLimit + stayCount; easeOutLimit = stayLimit + easeOutCount; // Debug.WriteLine($"{easeInCount}, {stayCount}, {easeOutCount} - {easeInLimit}, {stayLimit}, {easeOutLimit}"); // Pose deviceTransform = properties.anchorType == 0 ? EasyOpenVRSingleton.Utils.GetEmptyTransform() : _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking; if (!properties.attachToAnchor) { // Restrict rotation if necessary HmdVector3_t hmdEuler = deviceTransform.EulerAngles(); if (properties.ignoreAnchorYaw) { hmdEuler.v1 = 0; } if (properties.ignoreAnchorPitch) { hmdEuler.v0 = 0; } if (properties.ignoreAnchorRoll) { hmdEuler.v2 = 0; } deviceTransform = deviceTransform.FromEuler(hmdEuler); } originTransform = deviceTransform; targetTransform = deviceTransform; // Animations animateYaw.Reset(); animatePitch.Reset(); animateRoll.Reset(); animateZ.Reset(); animateY.Reset(); animateX.Reset(); animateScale.Reset(); animateOpacity.Reset(); if (properties.animations.Length > 0) { foreach (var anim in properties.animations) { switch (anim.property) { case 0: break; case 1: animateYaw = new Cycler(anim); break; case 2: animatePitch = new Cycler(anim); break; case 3: animateRoll = new Cycler(anim); break; case 4: animateZ = new Cycler(anim); break; case 5: animateY = new Cycler(anim); break; case 6: animateX = new Cycler(anim); break; case 7: animateScale = new Cycler(anim); break; case 8: animateOpacity = new Cycler(anim); break; } } } #endregion } if (!skip && stage != AnimationStage.Idle && stage != AnimationStage.LoadingImage) // Animate { // Animation stage if (animationCount < easeInLimit) { stage = AnimationStage.EasingIn; } else if (animationCount >= stayLimit) { stage = AnimationStage.EasingOut; } else { stage = follow.enabled || properties.animations.Length > 0 || useWorldDeviceTransform ? AnimationStage.Animating : AnimationStage.Staying; } animationSeconds = (float)animationCount / (float)hz; #region stage inits if (animationCount == 0) { // Init EaseIn transition = properties.transitions.Length > 0 ? properties.transitions[0] : new Payload.Transition(); tween = Tween.GetFunc(transition.tweenType); } if (animationCount == stayLimit) { // Init EaseOut if (properties.transitions.Length >= 2) { transition = properties.transitions[1]; tween = Tween.GetFunc(transition.tweenType); } } #endregion // Setup and normalized progression ratio var transitionRatio = 1f; if (stage == AnimationStage.EasingIn) { transitionRatio = ((float)animationCount / easeInCount); } else if (stage == AnimationStage.EasingOut) { transitionRatio = 1f - ((float)animationCount - stayLimit + 1) / easeOutCount; // +1 because we moved where we increment animationCount } transitionRatio = tween(transitionRatio); var ratioReversed = 1f - transitionRatio; // Transform if (stage != AnimationStage.Staying || animationCount == easeInLimit) // Only performs animation on first frame of Staying stage. // Debug.WriteLine($"{animationCount} - {Enum.GetName(typeof(AnimationStage), stage)} - {Math.Round(ratio*100)/100}"); { var translate = new HmdVector3_t() { v0 = properties.xDistanceM + (transition.xDistanceM * ratioReversed) + animateX.GetRatio(animationSeconds), v1 = properties.yDistanceM + (transition.yDistanceM * ratioReversed) + animateY.GetRatio(animationSeconds), v2 = -properties.zDistanceM - (transition.zDistanceM * ratioReversed) - animateZ.GetRatio(animationSeconds) }; #region Follow // Follow if (follow.enabled && follow.durationMs > 0 && properties.anchorType != 0 && !properties.attachToAnchor) { var currentPose = properties.anchorType == 0 ? EasyOpenVRSingleton.Utils.GetEmptyTransform() : _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking; var angleBetween = EasyOpenVRSingleton.Utils.AngleBetween(deviceTransform, currentPose); if (angleBetween > follow.triggerAngle && !followIsLerping) { followIsLerping = true; if (!properties.attachToAnchor) { // Restrict rotation if necessary HmdVector3_t hmdEuler = currentPose.EulerAngles(); if (properties.ignoreAnchorYaw) { hmdEuler.v1 = 0; } if (properties.ignoreAnchorRoll) { hmdEuler.v2 = 0; } if (properties.ignoreAnchorPitch) { hmdEuler.v0 = 0; } currentPose = currentPose.FromEuler(hmdEuler); } targetTransform = currentPose; } if (followIsLerping) { followLerp += msPerFrame / follow.durationMs; if (followLerp > 1.0) { deviceTransform = targetTransform; originTransform = targetTransform; followLerp = 0.0; followIsLerping = false; } else { deviceTransform = originTransform.Lerp(targetTransform, followTween((float)followLerp)); } } } #endregion // Build transform with origin, transitions and animations animationTransform = (properties.attachToAnchor || properties.anchorType == 0) ? EasyOpenVRSingleton.Utils.GetEmptyTransform() : deviceTransform; if (properties.anchorType == 0) { // World related, so all rotations are local to the overlay animationTransform = animationTransform .Translate(translate) .RotateY(-properties.yawDeg + transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds)) .RotateX(properties.pitchDeg + transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds)) .RotateZ(properties.rollDeg + transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds)); } else if (useWorldDeviceTransform) { // Device related but using world coordinates, local overlay rotation and allows for rotation cancellation var anchorTransform = _vr.GetDeviceToAbsoluteTrackingPose()[anchorIndex == uint.MaxValue ? 0 : anchorIndex].mDeviceToAbsoluteTracking; HmdVector3_t hmdAnchorEuler = anchorTransform.EulerAngles(); if (properties.ignoreAnchorYaw) { hmdAnchorEuler.v1 = 0; } if (properties.ignoreAnchorPitch) { hmdAnchorEuler.v0 = 0; } if (properties.ignoreAnchorRoll) { hmdAnchorEuler.v2 = 0; } animationTransform = anchorTransform.FromEuler(hmdAnchorEuler) .Translate(translate) .RotateY(-properties.yawDeg + transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds)) .RotateX(properties.pitchDeg + transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds)) .RotateZ(properties.rollDeg + transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds)); } else { // Device related, so all rotations are at the origin of the device animationTransform = animationTransform // Properties .RotateY(-properties.yawDeg) .RotateX(properties.pitchDeg) .RotateZ(properties.rollDeg) .Translate(translate) // Transitions .RotateY(transition.yawDeg * ratioReversed + animateYaw.GetRatio(animationSeconds)) .RotateX(transition.pitchDeg * ratioReversed + animatePitch.GetRatio(animationSeconds)) .RotateZ(transition.rollDeg * ratioReversed + animateRoll.GetRatio(animationSeconds)); } _vr.SetOverlayTransform( _overlayHandle, animationTransform, (properties.attachToAnchor && !useWorldDeviceTransform) ? anchorIndex : uint.MaxValue ); var transitionOpacityRatio = (transition.opacityPer + (transitionRatio * (1f - transition.opacityPer))); _vr.SetOverlayAlpha(_overlayHandle, // the transition part becomes 0-1, times the property that sets the maximum, and we just add the animation value. (transitionOpacityRatio) * properties.opacityPer + animateOpacity.GetRatio(animationSeconds) ); var transitionWidthRatio = (transition.scalePer + (transitionRatio * (1f - transition.scalePer))); _vr.SetOverlayWidth(_overlayHandle, Math.Max(0, width * transitionWidthRatio + (animateScale.GetRatio(animationSeconds) * width)) ); } // Do not make overlay visible until we have applied all the movements etc, only needs to happen the first frame. if (animationCount == 0) { _vr.SetOverlayVisibility(_overlayHandle, true); } animationCount++; // We're done if (animationCount >= easeOutLimit) { stage = AnimationStage.Finished; } if (stage == AnimationStage.Finished) { Debug.WriteLine("DONE!"); _vr.SetOverlayVisibility(_overlayHandle, false); stage = AnimationStage.Idle; _responseAtCompletion?.Invoke(_sessionId, properties.nonce); properties = null; animationCount = 0; _elapsedTime = 0; _payload = null; _texture = null; } } if (_shouldShutdown) // Finish // _texture.Delete(); // TODO: Watch for possible instability here depending on what is going on timing-wise... { _texture = null; OpenVR.Overlay.DestroyOverlay(_overlayHandle); Thread.CurrentThread.Abort(); } var timeSpent = (int)Math.Round((double)(DateTime.Now.Ticks - timeStarted) / TimeSpan.TicksPerMillisecond); Thread.Sleep(Math.Max(1, msPerFrame - timeSpent)); // Animation time per frame adjusted by the time it took to animate. } }
Vector3 fromHmdVector3_t(HmdVector3_t hmdVector3_T) { return(new Vector3(hmdVector3_T.v0, hmdVector3_T.v1, hmdVector3_T.v2)); }
private async void ParseTrackingFrame() { try { for (uint id = 0; id < OpenVR.k_unMaxTrackedDeviceCount; id++) { if (vr_pointer != null) { TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; if (!vr_pointer.IsTrackedDeviceConnected(id)) { continue; } VRControllerState_t controllState = new VRControllerState_t(); ETrackedDeviceClass trackedDeviceClass = vr_pointer.GetTrackedDeviceClass(id); switch (trackedDeviceClass) { case ETrackedDeviceClass.Controller: vr_pointer.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, id, ref controllState, OpenVR.k_unMaxTrackedDeviceCount, ref trackedDevicePose[id]); HmdVector3_t position = GetPosition(trackedDevicePose[id].mDeviceToAbsoluteTracking); // devicePose->mDeviceToAbsoluteTracking); HmdVector3_t rotation = GetRotationEuler(trackedDevicePose[id].mDeviceToAbsoluteTracking); int positionControllerX = (int)position.v0; int positionControllerY = (int)position.v1; int positionControllerZ = (int)position.v2 * (-1); int rotationControllerX = (int)rotation.v0 + 180; int rotationControllerY = (int)rotation.v1; int rotationControllerZ = (int)rotation.v2; if (ControlViewModel.teleporOffset[0] != -1) { ControlViewModel.transOffSetControllerX = ControlViewModel.teleporOffset[0]; ControlViewModel.transOffSetControllerY = ControlViewModel.teleporOffset[1]; ControlViewModel.transOffSetControllerZ = ControlViewModel.teleporOffset[2]; ControlViewModel.rotOffSetControllerZ = ControlViewModel.teleporOffset[3]; } ETrackedControllerRole result = vr_pointer.GetControllerRoleForTrackedDeviceIndex(id); if (result != ETrackedControllerRole.LeftHand && lastController != ETrackedControllerRole.LeftHand) { RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController); } if (result != ETrackedControllerRole.RightHand && lastController != ETrackedControllerRole.RightHand) { RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController); } switch (result) { case ETrackedControllerRole.Invalid: break; case ETrackedControllerRole.LeftHand: if (communicationProtocolUdp == false) { MessageBuffer mb2 = new MessageBuffer(); someThingTracked = true; int type = 101; mb2.add(type); mb2.add(userId); int handid = 1; mb2.add(handid); mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX); mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY); mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ); mb2.add(rotationControllerX); mb2.add(rotationControllerY); mb2.add(rotationControllerZ); mb2.add(ControlViewModel.rotOffSetControllerZ); RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.LeftController); Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE); lock (tcpSocketManager.send_msg(msg)) { tcpSocketManager.send_msg(msg); } Thread.Sleep(20); break; } break; case ETrackedControllerRole.RightHand: if (communicationProtocolUdp == false) { MessageBuffer mb2 = new MessageBuffer(); someThingTracked = true; int type = 101; mb2.add(type); mb2.add(userId); int handid = 2; mb2.add(handid); mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX); mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY); mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ); mb2.add(rotationControllerX); mb2.add(rotationControllerY); mb2.add(rotationControllerZ); mb2.add(ControlViewModel.rotOffSetControllerZ); Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE); RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.RightController); lock (tcpSocketManager.send_msg(msg)) { tcpSocketManager.send_msg(msg); } Thread.Sleep(20); break; } break; } break; } } } } catch (Exception e) { log.Warn("ParseTrackingFrame in Controller Tracking wurde beendet!" + e); RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController); RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController); } }
public void BuildMesh() { HmdQuad_t rect = new HmdQuad_t(); if (!GetBounds(size, ref rect)) { return; } HmdVector3_t[] corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; vertices = new Vector3[4]; for (int i = 0; i < corners.Length; i++) { HmdVector3_t c = corners[i]; vertices[i] = new Vector3(c.v0, c.v1, c.v2); } List <Vector3> verticesList = new List <Vector3>(); List <Vector2> uvList = new List <Vector2>(); int[] facesInterior; int[] facesExterior; int[] facesBoundaryTop; int[] facesBoundarySides; generateInterior(rect, corners, verticesList, uvList, out facesInterior); generateExterior(rect, corners, verticesList, uvList, out facesExterior); generateBoundaryTop(rect, corners, verticesList, uvList, out facesBoundaryTop); generateBoundarySides(rect, corners, verticesList, uvList, out facesBoundarySides); Mesh mesh = new Mesh(); GetComponent <MeshFilter>().mesh = mesh; mesh.vertices = verticesList.ToArray(); mesh.uv = uvList.ToArray(); mesh.subMeshCount = 4; mesh.SetTriangles(facesInterior, 0); mesh.SetTriangles(facesExterior, 1); mesh.SetTriangles(facesBoundaryTop, 2); mesh.SetTriangles(facesBoundarySides, 3); Material matDefault = null; if (interiorMaterial == null || exteriorMaterial == null || boundarySidesMaterial == null || boundaryTopMaterial == null) { matDefault = getDefaultMaterial(); } Material matInterior = interiorMaterial != null ? interiorMaterial : matDefault; Material matExterior = exteriorMaterial != null ? exteriorMaterial : matDefault; Material matBoundaryTop = boundaryTopMaterial != null ? boundaryTopMaterial : matDefault; Material matBoundarySides = boundarySidesMaterial != null ? boundarySidesMaterial : matDefault; MeshRenderer renderer = GetComponent <MeshRenderer>(); renderer.materials = new Material[] { matInterior, matExterior, matBoundaryTop, matBoundarySides }; }
public void BuildAreaMesh() { var rect = new HmdQuad_t(); if (!GetBounds(playAreaSize, ref rect)) { return; } var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 }; Vector3[] vertices = new Vector3[corners.Length * 2]; for (int i = 0; i < corners.Length; i++) { var c = corners[i]; vertices[i] = new Vector3(c.v0, 0.01f, c.v2); } if (borderThickness == 0.0f) { GetComponent <MeshFilter>().mesh = null; return; } for (int i = 0; i < corners.Length; i++) { int next = (i + 1) % corners.Length; int prev = (i + corners.Length - 1) % corners.Length; var nextSegment = (vertices[next] - vertices[i]).normalized; var prevSegment = (vertices[prev] - vertices[i]).normalized; var vert = vertices[i]; vert += Vector3.Cross(nextSegment, Vector3.up) * borderThickness; vert += Vector3.Cross(prevSegment, Vector3.down) * borderThickness; vertices[corners.Length + i] = vert; } var triangles = new int[] { 0, 1, 4, 1, 5, 4, 1, 2, 5, 2, 6, 5, 2, 3, 6, 3, 7, 6, 3, 0, 7, 0, 4, 7 }; var uv = new Vector2[] { new Vector2(0.0f, 0.0f), new Vector2(1.0f, 0.0f), new Vector2(0.0f, 0.0f), new Vector2(1.0f, 0.0f), new Vector2(0.0f, 1.0f), new Vector2(1.0f, 1.0f), new Vector2(0.0f, 1.0f), new Vector2(1.0f, 1.0f) }; var colors = new Color[] { Color.white, Color.white, Color.white, Color.white, new Color(1.0f, 1.0f, 1.0f, 0.0f), new Color(1.0f, 1.0f, 1.0f, 0.0f), new Color(1.0f, 1.0f, 1.0f, 0.0f), new Color(1.0f, 1.0f, 1.0f, 0.0f) }; var mesh = new Mesh(); GetComponent <MeshFilter>().mesh = mesh; mesh.vertices = vertices; mesh.uv = uv; mesh.colors = colors; mesh.triangles = triangles; var renderer = GetComponent <MeshRenderer>(); renderer.sharedMaterial = _material; renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off; renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; renderer.receiveShadows = false; #if !(UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0) renderer.lightProbeUsage = LightProbeUsage.Off; #else renderer.useLightProbes = false; #endif }
public void BuildMesh() { HmdQuad_t hmdQuad_t = default(HmdQuad_t); if (!SteamVR_PlayArea.GetBounds(this.size, ref hmdQuad_t)) { return; } HmdVector3_t[] array = new HmdVector3_t[] { hmdQuad_t.vCorners0, hmdQuad_t.vCorners1, hmdQuad_t.vCorners2, hmdQuad_t.vCorners3 }; this.vertices = new Vector3[array.Length * 2]; for (int i = 0; i < array.Length; i++) { HmdVector3_t hmdVector3_t = array[i]; this.vertices[i] = new Vector3(hmdVector3_t.v0, 0.01f, hmdVector3_t.v2); } if (this.borderThickness == 0f) { base.GetComponent <MeshFilter>().mesh = null; return; } for (int j = 0; j < array.Length; j++) { int num = (j + 1) % array.Length; int num2 = (j + array.Length - 1) % array.Length; Vector3 normalized = (this.vertices[num] - this.vertices[j]).normalized; Vector3 normalized2 = (this.vertices[num2] - this.vertices[j]).normalized; Vector3 vector = this.vertices[j]; vector += Vector3.Cross(normalized, Vector3.up) * this.borderThickness; vector += Vector3.Cross(normalized2, Vector3.down) * this.borderThickness; this.vertices[array.Length + j] = vector; } int[] triangles = new int[] { 0, 4, 1, 1, 4, 5, 1, 5, 2, 2, 5, 6, 2, 6, 3, 3, 6, 7, 3, 7, 0, 0, 7, 4 }; Vector2[] uv = new Vector2[] { new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 1f), new Vector2(1f, 1f) }; Color[] colors = new Color[] { this.color, this.color, this.color, this.color, new Color(this.color.r, this.color.g, this.color.b, 0f), new Color(this.color.r, this.color.g, this.color.b, 0f), new Color(this.color.r, this.color.g, this.color.b, 0f), new Color(this.color.r, this.color.g, this.color.b, 0f) }; Mesh mesh = new Mesh(); base.GetComponent <MeshFilter>().mesh = mesh; mesh.vertices = this.vertices; mesh.uv = uv; mesh.colors = colors; mesh.triangles = triangles; MeshRenderer component = base.GetComponent <MeshRenderer>(); component.material = new Material(Shader.Find("Sprites/Default")); component.reflectionProbeUsage = ReflectionProbeUsage.Off; component.shadowCastingMode = ShadowCastingMode.Off; component.receiveShadows = false; component.lightProbeUsage = LightProbeUsage.Off; }
public Vec3(HmdVector3_t point = new HmdVector3_t()) { x = point.v0; y = point.v1; z = point.v2; }
private Vector3 ToVector3(HmdVector3_t vector) { return(new Vector3(vector.v0, vector.v1, vector.v2)); }
public static Vector3 ToVelocityVector(this HmdVector3_t hmdVector) { return(new Vector3(hmdVector.v0, hmdVector.v1, hmdVector.v2)); }