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;
}
