public bool getControllerState(uint controllerIndex, ref VRControllerState_t controllerState) { controllerState.ulButtonPressed = lastControllerState.ulButtonPressed; controllerState.ulButtonTouched = lastControllerState.ulButtonTouched; controllerState.rAxis0 = lastControllerState.rAxis0; controllerState.rAxis1 = lastControllerState.rAxis1; controllerState.rAxis2 = lastControllerState.rAxis2; controllerState.rAxis3 = lastControllerState.rAxis3; controllerState.rAxis4 = lastControllerState.rAxis4; return(true); }
bool GetGripIsPressed(SteamVR vr, uint controller) { if (controller == 0) { return(false); } var state = new VRControllerState_t(); var success = vr.hmd.GetControllerState(32, ref state, 2); return((state.ulButtonPressed & SteamVR_Controller.ButtonMask.Grip) != 0); }
void Update() { var system = OpenVR.System; VRControllerState_t controllerState = default(VRControllerState_t); if (system != null && system.GetControllerState(controllerIndex, ref controllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)))) { float triggerPullPct = controllerState.rAxis1.x; _animator.Play("Trigger Pull", 1, triggerPullPct); } }
float GetTouchPadY(SteamVR vr, uint controller) { if (controller == 0) { return(0); } var state = new VRControllerState_t(); var success = vr.hmd.GetControllerState(32, ref state, 2); return(state.rAxis0.y); }
/// <summary> /// Sends full controller state as defined by arguments. /// </summary> public void SetControllerState( // Controller ID int controllerId, // Pose data HeadRelation headRelation, HandType suggestedHand, Quaternion orientation, Vector3?position, // Touchpad state [-1,1] double analogX, double analogY, // Trigger state double analogTrigger, // Button states bool isMenuPressed, bool isSystemPressed, bool isTriggerPressed, bool isGripPressed, bool isTouchpadPressed, bool isTouchpadTouched) { // See openvr.h in OpenVR SDK for mappings and masks // https://github.com/ValveSoftware/openvr/blob/master/headers/openvr.h var buttons = new VRControllerState_t() { rAxis0 = new VRControllerAxis_t((float)analogX, (float)analogY), // Touchpad rAxis1 = new VRControllerAxis_t((float)analogTrigger, 0), // Trigger rAxis2 = new VRControllerAxis_t(0, 0), rAxis3 = new VRControllerAxis_t(0, 0), rAxis4 = new VRControllerAxis_t(0, 0), ulButtonPressed = BuildButtonPressedMask(isMenuPressed, isSystemPressed, isTriggerPressed, isGripPressed, isTouchpadPressed), ulButtonTouched = BuildButtonTouchedMask(isTouchpadTouched, true), unPacketNum = ++packetNum }; var controllerState = new VRController() { ButtonState = buttons, Status = 0, ControllerId = controllerId, Position = position.HasValue ? new[] { position.Value.X, position.Value.Y, position.Value.Z } : null, Orientation = new [] { orientation.X, orientation.Y, orientation.Z, orientation.W }, HeadRelation = headRelation, SuggestedHand = suggestedHand }; WrapTimeouts(() => { Proxy.SendControllerData(controllerState); }); }
private static void SteamVr() { Console.WriteLine("Starting"); EVRInitError initError = EVRInitError.None; CVRSystem cvrSystem = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Utility); Console.WriteLine("Error: " + initError.ToString()); if (cvrSystem == null) { Console.WriteLine("Error!"); } while (true) { Thread.Sleep(1); TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; cvrSystem.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseRawAndUncalibrated, 0f, trackedDevicePose); VRControllerState_t controllerState = new VRControllerState_t(); cvrSystem.GetControllerState(1, ref controllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t))); int trigger = controllerState.rAxis1.x > 0.9f ? 1 : 0; bool topButtom = (controllerState.ulButtonPressed & (1ul << (int)EVRButtonId.k_EButton_ApplicationMenu)) != 0; TrackedDevicePose_t pose = trackedDevicePose[1]; ETrackingResult trackingResult = pose.eTrackingResult; HmdMatrix34_t hmdMatrix = pose.mDeviceToAbsoluteTracking; Position pos = new Position(hmdMatrix); Rotation rot = new Rotation(hmdMatrix); Console.WriteLine($"Position: {pos} Rotation: {rot} trigger {trigger} app {topButtom}"); foreach (Socket client in _clients.ToArray()) { try { client.Send(Encoding.ASCII.GetBytes($"S{pos.ToData()} {rot.ToData()} {trigger} {(topButtom ? 1 : 0)}E")); } catch (Exception) { _clients.Remove(client); } } } for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++) { if (cvrSystem?.IsTrackedDeviceConnected((uint)i) ?? false) { ETrackedDeviceClass deviceClass = cvrSystem.GetTrackedDeviceClass((uint)i); Console.WriteLine($"index: {i} is {deviceClass}"); } } Console.ReadLine(); OpenVR.Shutdown(); Console.WriteLine("Shut down"); Console.ReadLine(); }
/// <summary> /// Tests if a given Device just had a given button released /// </summary> /// <param name="device">The Device to test against</param> /// <param name="buttonId">The Button to test</param> /// <returns>Returns True if the given Button was just released, False otherwise</returns> public bool GetPressUp(HOTK_TrackedDevice device, EVRButtonId buttonId) { if (device == null || !device.IsValid) { return(false); } var svr = SteamVR.instance; if (svr == null) { return(false); } var c = new VRControllerState_t(); svr.hmd.GetControllerState((uint)device.Index, ref c); TrackedDeviceControllerStates state; if (!ControllerStates.TryGetValue(device, out state)) { state = new TrackedDeviceControllerStates(); ControllerStates.Add(device, state); } bool curState; if (!state.ReleasedStates.TryGetValue(buttonId, out curState)) { curState = false; state.ReleasedStates.Add(buttonId, false); } if (!curState) { if (GetPress(c, buttonId)) { state.ReleasedStates.Remove(buttonId); state.ReleasedStates.Add(buttonId, true); return(false); } } else { if (!GetPress(c, buttonId)) { state.ReleasedStates.Remove(buttonId); state.ReleasedStates.Add(buttonId, false); return(true); } } return(false); }
private static void GetConrollerState(CVRSystem system, uint index, out VRControllerState_t ctrlState) { ctrlState = default(VRControllerState_t); if (system != null) { #if VIU_STEAMVR_1_2_0_OR_NEWER system.GetControllerState(index, ref ctrlState, s_sizeOfControllerStats); #else system.GetControllerState(index, ref ctrlState); #endif } }
/// <summary> /// Sends full controller state as defined by arguments. /// </summary> public void SetControllerState( // Controller ID int controllerId, // Absolute position in meters double positionX, double positionY, double positionZ, // Rotation in degrees double yaw, double pitch, double roll, // Trackpad state [-1,1] double analogX, double analogY, // Trigger state double analogTrigger, // Button states bool isMenuPressed, bool isSystemPressed, bool isTriggerPressed) { // See openvr.h in OpenVR SDK for mappings and masks // https://github.com/ValveSoftware/openvr/blob/master/headers/openvr.h var buttons = new VRControllerState_t() { rAxis0 = new VRControllerAxis_t((float)analogX, (float)analogY), // Touchpad rAxis1 = new VRControllerAxis_t((float)analogTrigger, 0), // Trigger rAxis2 = new VRControllerAxis_t(0, 0), rAxis3 = new VRControllerAxis_t(0, 0), rAxis4 = new VRControllerAxis_t(0, 0), ulButtonPressed = BuildButtonPressedMask(isMenuPressed, isSystemPressed, isTriggerPressed), ulButtonTouched = BuildButtonTouchedMask(true, true), unPacketNum = ++packetNum }; controllerState = new VRController() { ButtonState = buttons, Status = 0, ControllerId = controllerId, OrientationMatrix = BuildControllerMatrix(positionX, positionY, positionZ, yaw, pitch, roll).FlattenAsColumnMajor() }; controllerStateChangeWaitHandle.Set(); }
public void Update() { if (Time.frameCount != prevFrameCount) { prevFrameCount = Time.frameCount; prevState = state; CVRSystem system = OpenVR.System; if (system != null) { valid = system.GetControllerStateWithPose(OmniTriggerSpace.SteamVR_Render.instance.trackingSpace, index, ref state, (uint)Marshal.SizeOf(typeof(VRControllerState_t)), ref pose); UpdateHairTrigger(); } } }
public bool GetControllerState(uint index, out VRControllerState_t state) { state = new VRControllerState_t(); //有効なデバイスか if (!IsDeviceValid(index)) { return(false); } uint size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)); return(openvr.GetControllerState(index, ref state, size)); }
public void Update() { if (Time.frameCount != this.prevFrameCount) { this.prevFrameCount = Time.frameCount; this.prevState = this.state; CVRSystem system = OpenVR.System; if (system != null) { this.valid = system.GetControllerStateWithPose(SteamVR_Render.instance.trackingSpace, this.index, ref this.state, ref this.pose); this.UpdateHairTrigger(); } } }
// Token: 0x06000DE8 RID: 3560 RVA: 0x00058868 File Offset: 0x00056A68 public void UpdateComponents(CVRRenderModels renderModels) { if (renderModels == null) { return; } Transform transform = base.transform; if (transform.childCount == 0) { return; } VRControllerState_t vrcontrollerState_t = (this.index != SteamVR_TrackedObject.EIndex.None) ? SteamVR_Controller.Input((int)this.index).GetState() : default(VRControllerState_t); if (this.nameCache == null) { this.nameCache = new Dictionary <int, string>(); } for (int i = 0; i < transform.childCount; i++) { Transform child = transform.GetChild(i); string name; if (!this.nameCache.TryGetValue(child.GetInstanceID(), out name)) { name = child.name; this.nameCache.Add(child.GetInstanceID(), name); } RenderModel_ComponentState_t renderModel_ComponentState_t = default(RenderModel_ComponentState_t); if (renderModels.GetComponentState(this.renderModelName, name, ref vrcontrollerState_t, ref this.controllerModeState, ref renderModel_ComponentState_t)) { SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentRenderModel); child.localPosition = rigidTransform.pos; child.localRotation = rigidTransform.rot; Transform transform2 = child.Find("attach"); if (transform2 != null) { SteamVR_Utils.RigidTransform rigidTransform2 = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentLocal); transform2.position = transform.TransformPoint(rigidTransform2.pos); transform2.rotation = transform.rotation * rigidTransform2.rot; } bool flag = (renderModel_ComponentState_t.uProperties & 2U) > 0U; if (flag != child.gameObject.activeSelf) { child.gameObject.SetActive(flag); } } } }
public void GetControllerTriggerState() { VRControllerState_t controllerState = new VRControllerState_t(); this.vr.GetControllerState(this.index, ref controllerState); TriggerPressed = controllerState.ulButtonTouched == 8589934592; TriggerValue = controllerState.rAxis1.x; TriggerClicked = controllerState.ulButtonPressed == 8589934592 && Math.Abs(TriggerValue - 1) < 0.001; TouchPadTouched = controllerState.ulButtonTouched == 4294967296; TouchPadClicked = controllerState.ulButtonPressed == 4294967296; TouchPadValueX = controllerState.rAxis0.x; TouchPadValueY = controllerState.rAxis0.y; AddStatesToLists(); }
public void Update() { if (OpenVR.System.GetTrackedDeviceClass(deviceIdx) != ETrackedDeviceClass.Controller) { active = false; return; } if (!OpenVR.System.GetControllerState(deviceIdx, out var controllerState)) { active = false; return; } if (active) { staleness += 1; if (controllerState.unPacketNum == currentState.unPacketNum) { return; } } if (!active) { //activate active = true; groundState = controllerState; secondPreviousState = default(VRControllerState_t); previousState = default(VRControllerState_t); } else { groundState.ulButtonPressed &= currentState.ulButtonPressed; secondPreviousState = previousState; previousState = currentState; previousStaleness = staleness; } currentState = controllerState; staleness = 0; if (WasClicked(EVRButtonId.k_EButton_ApplicationMenu)) { menuOpen = !menuOpen; } }
private IEnumerator WhileTouchingTouchpadAxis0(uint deviceIndex, Hand hand, short coroutineId) { var vr = OpenVR.System; var state = new VRControllerState_t(); var size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t)); bool started = false; Vector2 anchorPos = Vector2.zero; while (vr.GetControllerState(deviceIndex, ref state, size)) { var pos = ControllerAxisToVector2(state.rAxis0); if (started) { var deltaPos = pos - anchorPos; float magnitude = 0; Direction dir = GetLargestVectorDirection(deltaPos, ref magnitude); if (magnitude >= trackpadDirectionInterval) { anchorPos = pos; var btn = new DirectionActionsPress(hand, DirectionAction.D2, dir, true); DirectionActionPress.Send(btn); // Wait long enough for ED to recieve any keypresses yield return(KeyboardInterface.WaitForKeySent()); new DirectionActionsPress(hand, DirectionAction.D2, dir, false); DirectionActionUnpress.Send(btn); } } else { started = true; anchorPos = pos; } yield return(null); if (trackpadTouchingCoroutineId[hand] != coroutineId) { yield break; } } Debug.LogWarningFormat("Failed to get controller state for device {0}", deviceIndex); }
/// <summary> /// Tests if a given Device just had a given button is being held down /// </summary> /// <param name="device">The Device to test against</param> /// <param name="buttonId">The Button to test</param> /// <returns>Returns True if the given Button is being held down, False otherwise</returns> public bool GetPress(HOTK_TrackedDevice device, EVRButtonId buttonId) { if (device == null || !device.IsValid) { return(false); } var svr = SteamVR.instance; if (svr == null) { return(false); } var c = new VRControllerState_t(); svr.hmd.GetControllerState((uint)device.Index, ref c); return(GetPress(c, buttonId)); }
// return true if frame skipped public override bool Update() { if (Time.frameCount == updatedFrameCount) { return(true); } updatedFrameCount = Time.frameCount; var deviceIndex = m_map.GetMappedDeviceByRoleValue(m_roleValue); if (deviceIndex == updatedDeviceIndex && !ViveRole.IsValidIndex(deviceIndex)) { return(false); } updatedDeviceIndex = deviceIndex; previousState = currentState; currentState = ViveRole.IsValidIndex(deviceIndex) ? s_controllerStats[deviceIndex] : default(VRControllerState_t); this.UpdateHairTrigger(); if (GetPressDown(ControllerButton.Pad)) { padDownAxis = GetAxis(); } if (GetPressDown(ControllerButton.PadTouch)) { padTouchDownAxis = GetAxis(); } for (int i = 0; i < CONTROLLER_BUTTON_COUNT; ++i) { UpdateClickCount((ControllerButton)i); } for (int i = 0; i < CONTROLLER_BUTTON_COUNT; ++i) { InvokeEvent((ControllerButton)i); } return(false); }
public Vector2 GetAxis(EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad, bool usePrevState = false) { Update(); VRControllerState_t state = usePrevState ? previousState : currentState; var axisId = (uint)buttonId - (uint)EVRButtonId.k_EButton_Axis0; switch (axisId) { case 0: return(new Vector2(state.rAxis0.x, state.rAxis0.y)); case 1: return(new Vector2(state.rAxis1.x, state.rAxis1.y)); case 2: return(new Vector2(state.rAxis2.x, state.rAxis2.y)); case 3: return(new Vector2(state.rAxis3.x, state.rAxis3.y)); case 4: return(new Vector2(state.rAxis4.x, state.rAxis4.y)); } return(Vector2.zero); }
/// <summary> /// Gives the r-theta parameterization of the point on the touchpad that /// the user is touching. /// </summary> /// <param name="deviceIndex">The index of the controller</param> /// <param name="r">the radius [0,1]</param> /// <param name="theta">the angle made with the x-axis</param> protected void getViveTouchpadPoint(uint deviceIndex, out float r, out float theta) { VRControllerState_t controllerState = new VRControllerState_t(); VRControllerAxis_t axis = new VRControllerAxis_t(); unsafe { mScene.mHMD.GetControllerState(deviceIndex, ref controllerState, (uint)sizeof(VRControllerState_t)); } axis = controllerState.rAxis0; r = (float)Math.Sqrt(axis.x * axis.x + axis.y * axis.y); if (r > 0) { theta = (float)Math.Atan2(axis.y / r, axis.x / r); // TODO: Remove divisions? } else { theta = 0; } }
public static VRControllerState_t ControllerState(this CVRSystem hmd, int contIndex) { if (hmd == null) { throw new ArgumentNullException(nameof(hmd)); } if (contIndex < 0 || contIndex > OpenVR.k_unMaxTrackedDeviceCount) { throw new ArgumentOutOfRangeException(nameof(contIndex)); } VRControllerState_t state = new VRControllerState_t(); bool success = hmd.GetControllerState((uint)contIndex, ref state); if (!success) { throw new InvalidOperationException("Unable to retrieve controller state"); } return(state); }
protected virtual void UpdateControllerState() { lastcontrollerstate = controllerstate; //Update position. if (index > EIndex.Hmd) { ETrackingUniverseOrigin tracktype = OpenVR.Compositor.GetTrackingSpace(); TrackedDevicePose_t[] absoluteposes = new TrackedDevicePose_t[16]; openvrsystem.GetDeviceToAbsoluteTrackingPose(tracktype, 0, absoluteposes); TrackedDevicePose_t newposes = absoluteposes[(int)index]; OnNewPoses(newposes); } //We need to check for this always in case the user uses the deprecated GetVRButton methods. if (useLegacySteamVRInput) { openvrsystem.GetControllerState((uint)index, ref controllerstate, controllerstatesize); } }
void HandleTouchMove() { if (!isTouching) { return; } touch.PointerInfo.PtPixelLocation.X = _screenObject.Bounds.Left + (int)Math.Round((double)eventData.data.mouse.x); touch.PointerInfo.PtPixelLocation.Y = _screenObject.Bounds.Bottom - ((int)Math.Round((double)eventData.data.mouse.y) + touchYOffset); touch.PointerInfo.PointerFlags = PointerFlags.UPDATE | PointerFlags.INCONTACT | PointerFlags.INRANGE; VRControllerState_t cState = new VRControllerState_t(); OpenVR.System.GetControllerState(OpenVR.Overlay.GetPrimaryDashboardDevice(), ref cState, cStateSize); if (!TouchInjector.InjectTouchInput(1, new PointerTouchInfo[] { touch })) { Logger.Warning("[DESKTOP] Failed to inject touch move: " + GetLastError()); } }
private void SetControllerState(IntPtr pControllerState, uint unControllerDeviceIndex) { VRControllerState_t cs = (VRControllerState_t)Marshal.PtrToStructure(pControllerState, typeof(VRControllerState_t)); //Interface.Write("GetControllerState"); //Interface.Write(" Device index " + (int)unControllerDeviceIndex); //Interface.Write(" Packet num " + cs.unPacketNum); //Interface.Write(" Buttons pressed " + cs.ulButtonPressed); //Interface.Write(" Buttons touched " + cs.ulButtonTouched); //Interface.Write(" Axis 0 " + cs.rAxis0.x + ", " + cs.rAxis0.y); //Interface.Write(" Axis 1 " + cs.rAxis1.x + ", " + cs.rAxis1.y); //Interface.Write(" Axis 2 " + cs.rAxis2.x + ", " + cs.rAxis2.y); //Interface.Write(" Axis 3 " + cs.rAxis3.x + ", " + cs.rAxis3.y); // Interface.Write(" Axis 4 " + cs.rAxis4.x + ", " + cs.rAxis4.y); if (UserRunning && unControllerDeviceIndex == ChosenDeviceIndex) { // Interface.Write("Running"); if (ButtonType == PStrafeButtonType.Press) { cs.ulButtonPressed = cs.ulButtonPressed | (1UL << ((int)RunButton)); } cs.ulButtonTouched = cs.ulButtonTouched | (1UL << ((int)RunButton)); if (RunButton == EVRButtonId.k_EButton_SteamVR_Touchpad || RunButton == EVRButtonId.k_EButton_Axis0) { // -1 to 1 cs.rAxis0.y = 1.0f; } else if (RunButton == EVRButtonId.k_EButton_Axis1) { // 0 to 1 cs.rAxis1.x = 1.0f; } Marshal.StructureToPtr(cs, pControllerState, true); } else { } }
void HandleTouchDown() { if (isTouching) { ReleaseTouch(); } VRControllerState_t cState = new VRControllerState_t(); OpenVR.System.GetControllerState(OpenVR.Overlay.GetPrimaryDashboardDevice(), ref cState, cStateSize); touch = new PointerTouchInfo(); touch.PointerInfo.pointerType = PointerInputType.TOUCH; touch.TouchFlags = TouchFlags.NONE; touch.Orientation = 0; touch.Pressure = 32000;//(uint)(cState.rAxis3.x * 2048); touch.PointerInfo.PointerFlags = PointerFlags.DOWN | PointerFlags.INRANGE | PointerFlags.INCONTACT; touch.TouchMasks = TouchMask.PRESSURE | TouchMask.CONTACTAREA; touch.PointerInfo.PtPixelLocation.X = _screenObject.Bounds.Left + (int)Math.Round((double)eventData.data.mouse.x); touch.PointerInfo.PtPixelLocation.Y = _screenObject.Bounds.Bottom - ((int)Math.Round((double)eventData.data.mouse.y) + touchYOffset); touch.ContactArea.top = touch.PointerInfo.PtPixelLocation.Y - 3; touch.ContactArea.bottom = touch.PointerInfo.PtPixelLocation.Y + 3; touch.ContactArea.left = touch.PointerInfo.PtPixelLocation.X - 6; touch.ContactArea.right = touch.PointerInfo.PtPixelLocation.X + 3; touch.PointerInfo.PointerId = 10; if (!TouchInjector.InjectTouchInput(1, new PointerTouchInfo[] { touch })) { Logger.Warning("[DESKTOP] Failed to inject touch down: " + GetLastError()); } else { isTouching = true; } }
public static VRControllerAxis_t GetAxis(this VRControllerState_t controllerState, uint axisIdx) { switch (axisIdx) { case 0: return(controllerState.rAxis0); case 1: return(controllerState.rAxis1); case 2: return(controllerState.rAxis2); case 3: return(controllerState.rAxis3); case 4: return(controllerState.rAxis4); default: throw new IndexOutOfRangeException(); } }
void handleVRInput() { if (Time.time < _timeToActivateInput) { return; } VRControllerState_t leftControllerState = VRManager.Instance.Player.LeftController.ControllerState; VRControllerState_t rightControllerState = VRManager.Instance.Player.RightController.ControllerState; Vector2 movmentVector = leftControllerState.GetJoystick(); _owner.SetHorizontalMovement(movmentVector.x); _owner.SetVerticalMovement(movmentVector.y); bool joystickDown = (rightControllerState.ulButtonPressed & 4294967296) != 0; _owner.SetJumpKeyDown(joystickDown); if (!_damageKeyDown && rightControllerState.GetFrontTriggerValue() > 0.8f) { WeaponModel weaponModel = Accessor.GetPrivateField <FirstPersonMover, WeaponModel>("_currentWeaponModel", _owner); weaponModel.SetWeaponDamageActive(true); _damageKeyDown = true; } if (_damageKeyDown && rightControllerState.GetFrontTriggerValue() <= 0.8f) { WeaponModel weaponModel = Accessor.GetPrivateField <FirstPersonMover, WeaponModel>("_currentWeaponModel", _owner); weaponModel.SetWeaponDamageActive(false); _damageKeyDown = false; } if (_damageKeyDown) { OpenVR.System.TriggerHapticPulse(VRManager.Instance.Player.RightController.DeviceIndex, 0, 50000); } }
public void Update(CVRSystem system, int index, Matrix transform) { Index = index; if (Index < 0) { IsValid = false; m_Pose.bPoseIsValid = false; return; } m_PreviousState = m_State; IsValid = system.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, (uint)index, ref m_State, (uint)Marshal.SizeOf(typeof(VRControllerState_t)), ref m_Pose); transform = Matrix.Invert(transform); var parent = Components.Camera.Main.Transform.Parent; //if (parent != null) //transform = parent.m_WorldMatrix * transform; transform.Decompose(out m_Scale, out m_Rotation, out m_Position); }
protected override bool GetControllerState(ref VRControllerState_t controllerState) { if (!t_tracking) { return(false); } transform.position = t_position; transform.rotation = t_rotation; controllerState.rAxis0.x = t_touchpad_position.x; controllerState.rAxis0.y = t_touchpad_position.y; controllerState.ulButtonTouched = 0; controllerState.ulButtonPressed = 0; if (t_trigger) { controllerState.ulButtonPressed |= 1UL << ((int)EVRButtonId.k_EButton_SteamVR_Trigger); } if (t_grip) { controllerState.ulButtonPressed |= 1UL << ((int)EVRButtonId.k_EButton_Grip); } if (t_touchpad_touched) { controllerState.ulButtonTouched |= 1UL << ((int)EVRButtonId.k_EButton_SteamVR_Touchpad); } if (t_touchpad_pressed) { controllerState.ulButtonPressed |= 1UL << ((int)EVRButtonId.k_EButton_SteamVR_Touchpad); } if (t_menu) { controllerState.ulButtonPressed |= 1UL << ((int)EVRButtonId.k_EButton_ApplicationMenu); } return(true); }
public void Update() { if (Time.frameCount != prevFrameCount) { prevFrameCount = Time.frameCount; previousState = currentState; CVRSystem system; index = ViveRole.GetDeviceIndex(role); if (!ViveRole.IsValidIndex(index) || (system = OpenVR.System) == null || !system.GetControllerState(index, ref currentState)) { currentState = default(VRControllerState_t); } UpdateHairTrigger(); if (GetPressDown(ControllerButton.Pad)) { padDownAxis = GetAxis(); } if (GetPressDown(ControllerButton.PadTouch)) { padTouchDownAxis = GetAxis(); } for (int i = 0; i < ViveInput.CONTROLLER_BUTTON_COUNT; ++i) { UpdateClickCount((ControllerButton)i); } for (int i = 0; i < ViveInput.CONTROLLER_BUTTON_COUNT; ++i) { InvokeEvent((ControllerButton)i); } } }
public abstract bool GetComponentState(string pchRenderModelName,string pchComponentName,ref VRControllerState_t pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState);
public abstract bool GetControllerStateWithPose(TrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose);
public abstract bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState);
public override bool GetControllerStateWithPose(TrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRSystem_GetControllerStateWithPose(m_pVRSystem,eOrigin,unControllerDeviceIndex,ref pControllerState,ref pTrackedDevicePose); return result; }
public override bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRSystem_GetControllerState(m_pVRSystem,unControllerDeviceIndex,ref pControllerState); return result; }
public override bool GetComponentState(string pchRenderModelName,string pchComponentName,ref VRControllerState_t pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRRenderModels_GetComponentState(m_pVRRenderModels,pchRenderModelName,pchComponentName,ref pControllerState,ref pState,ref pComponentState); return result; }