public void TriggerHapticPulse(ushort durationMicroSec = 500, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
var vr = SteamVR.instance;
var axisId = (uint)buttonId - (uint)EVRButtonId.k_EButton_Axis0;
vr.hmd.TriggerHapticPulse(index, axisId, (char)durationMicroSec);
}
internal static extern IntPtr VR_IVRSystem_GetButtonIdNameFromEnum(IntPtr instancePtr, EVRButtonId eButtonId);
public bool GetPressUp(EVRButtonId buttonId)
{
return GetPressUp(1ul << (int)buttonId);
}
public override Vector2 GetAxis(bool usePrevState, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
return(m_state.GetAxis(usePrevState, buttonId));
}
public virtual Vector2 GetAxis(EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad, bool usePrevState = false)
{
return(Vector2.zero);
}
public static bool IsButtonHintActive(Hand hand, EVRButtonId button)
{
ControllerButtonHints controllerButtonHints = ControllerButtonHints.GetControllerButtonHints(hand);
return(controllerButtonHints != null && controllerButtonHints.IsButtonHintActive(button));
}
public bool GetTouchUp(EVRButtonId buttonId)
{
return(GetTouchUp(1ul << (int)buttonId));
}
public void TriggerHapticPulse(ushort durationMicroSec = 500, EVRButtonId buttonId = EVRButtonId.k_EButton_Axis0)
{
if (Controller != null)
{
if (durationMicroSec < 3000)
{
Controller.TriggerHapticPulse(durationMicroSec, buttonId);
}
else
{
Debug.LogWarning("You're trying to pulse for over 3000 microseconds, you probably don't want to do that. If you do, use NVRHand.LongHapticPulse(float seconds)");
}
}
}
private IEnumerator DoLongHapticPulse(float seconds, EVRButtonId buttonId)
{
float startTime = Time.time;
float endTime = startTime + seconds;
while (Time.time < endTime)
{
Controller.TriggerHapticPulse(100, buttonId);
yield return null;
}
}
//touchpad:
public bool IsButtonTouched(EVRButtonId button)
{
return 0 != (m_controllerState.ulButtonTouched & ((ulong)1 << (int)button));
}
public void LongHapticPulse(float seconds, EVRButtonId buttonId = EVRButtonId.k_EButton_Axis0)
{
StartCoroutine(DoLongHapticPulse(seconds, buttonId));
}
public bool WasButtonReleased(EVRButtonId button)
{
return 0 != (m_buttonReleasedAcc & ((ulong)1 << (int)button));
}
private IEnumerator DoLongHapticPulse(float seconds, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
var startTime = Time.time;
var endTime = startTime + seconds;
while (Time.time < endTime) {
Controller.TriggerHapticPulse(100, buttonId);
yield return null;
}
}
public void LongHapticPulse(float seconds, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
StartCoroutine(DoLongHapticPulse(seconds, buttonId));
}
public virtual void ButtonPressUp2(EVRButtonId button, ControllerInput controller, ControllerInput controller1)
{
}
private void ExecutePressDown(EVRButtonId id)
{
switch (id)
{
case EVRButtonId.k_EButton_ApplicationMenu:
pointerData.applicationMenuPress = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<IApplicationMenuHandler>(pointerData.applicationMenuPress, pointerData,
(x, y) => x.OnApplicationMenuPressDown(pointerData));
break;
case EVRButtonId.k_EButton_Grip:
pointerData.gripPress = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<IGripHandler>(pointerData.gripPress, pointerData,
(x, y) => x.OnGripPressDown(pointerData));
break;
case EVRButtonId.k_EButton_SteamVR_Touchpad:
pointerData.touchpadPress = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<ITouchpadHandler>(pointerData.touchpadPress, pointerData,
(x, y) => x.OnTouchpadPressDown(pointerData));
break;
case EVRButtonId.k_EButton_SteamVR_Trigger:
pointerData.triggerPress = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<ITriggerHandler>(pointerData.triggerPress, pointerData,
(x, y) => x.OnTriggerPressDown(pointerData));
break;
}
}
/// <summary>
/// Called when button is released after an object has been "grabbed".
/// </summary>
/// <param name="controller"></param>
public virtual void ButtonPressUp(EVRButtonId button, VRControllerInput controller)
{
//Empty. Overriden meothod only.
}
private void ExecutePressUp(EVRButtonId id)
{
switch (id)
{
case EVRButtonId.k_EButton_ApplicationMenu:
ExecuteEvents.Execute<IApplicationMenuHandler>(pointerData.applicationMenuPress, pointerData,
(x, y) => x.OnApplicationMenuPressUp(pointerData));
pointerData.applicationMenuPress = null;
break;
case EVRButtonId.k_EButton_Grip:
ExecuteEvents.Execute<IGripHandler>(pointerData.gripPress, pointerData,
(x, y) => x.OnGripPressUp(pointerData));
pointerData.gripPress = null;
break;
case EVRButtonId.k_EButton_SteamVR_Touchpad:
ExecuteEvents.Execute<ITouchpadHandler>(pointerData.touchpadPress, pointerData,
(x, y) => x.OnTouchpadPressUp(pointerData));
pointerData.touchpadPress = null;
break;
case EVRButtonId.k_EButton_SteamVR_Trigger:
ExecuteEvents.Execute<ITriggerHandler>(pointerData.triggerPress, pointerData,
(x, y) => x.OnTriggerPressUp(pointerData));
pointerData.triggerPress = null;
break;
}
}
public override void ButtonPressUp(EVRButtonId button, ControllerInput controller)
{
}
private void ExecuteTouchDown(EVRButtonId id)
{
switch (id)
{
case EVRButtonId.k_EButton_SteamVR_Touchpad:
pointerData.touchpadTouch = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<ITouchpadHandler>(pointerData.touchpadTouch, pointerData,
(x, y) => x.OnTouchpadTouchDown(pointerData));
break;
case EVRButtonId.k_EButton_SteamVR_Trigger:
pointerData.triggerTouch = pointerData.pointerCurrentRaycast.gameObject;
ExecuteEvents.Execute<ITriggerHandler>(pointerData.triggerTouch, pointerData,
(x, y) => x.OnTriggerTouchDown(pointerData));
break;
}
}
private void highlightButtonOnBothControllers(EVRButtonId button, string text)
{
hideAllHints();
ControllerButtonHints.ShowTextHint(leftHand.GetComponent <Hand>(), button, text);
ControllerButtonHints.ShowTextHint(rightHand.GetComponent <Hand>(), button, text);
}
private void ExecuteTouchUp(EVRButtonId id)
{
switch (id)
{
case EVRButtonId.k_EButton_SteamVR_Touchpad:
ExecuteEvents.Execute<ITouchpadHandler>(pointerData.touchpadTouch, pointerData,
(x, y) => x.OnTouchpadTouchUp(pointerData));
pointerData.touchpadTouch = null;
break;
case EVRButtonId.k_EButton_SteamVR_Trigger:
ExecuteEvents.Execute<ITriggerHandler>(pointerData.triggerTouch, pointerData,
(x, y) => x.OnTriggerTouchUp(pointerData));
pointerData.triggerTouch = null;
break;
}
}
public virtual bool GetPressUp(EVRButtonId buttonId)
{
return(false);
}
public string GetButtonIdNameFromEnum(EVRButtonId eButtonId)
{
IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId);
return Marshal.PtrToStringAnsi(result);
}
public override bool GetTouch(EVRButtonId buttonId)
{
return(GetTouch(1ul << (int)buttonId));
}
private bool GetTouchUp(EVRButtonId button)
{
return(controller.GetTouchUp(button));
}
public bool WasButtonReleased(EVRButtonId button)
{
return false;
}
private bool GetClick(EVRButtonId button)
{
return(controller.GetClick(button));
}
public bool GetTouchUp(EVRButtonId buttonId)
{
return GetTouchUp(1ul << (int)buttonId);
}
public void LongHapticPulse(float seconds, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
StartCoroutine(DoLongHapticPulse(seconds, buttonId));
}
public OVRKeyEventArgs(EVRButtonId buttonId, Vector2 axis, bool isLeft, bool isAxis, bool isTouch) : base()
{
ButtonId = buttonId; Axis = axis; IsLeft = isLeft; IsAxis = isAxis; IsTouch = isTouch;
}
public void TriggerHapticPulse(ushort durationMicroSec = 500, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
var system = OpenVR.System;
if (system != null)
{
var axisId = (uint)buttonId - (uint)EVRButtonId.k_EButton_Axis0;
system.TriggerHapticPulse(index, axisId, (char)durationMicroSec);
}
}
//-------------------------------------------------
private void CreateAndAddButtonInfo(EVRButtonId buttonID)
{
Transform buttonTransform = null;
List <MeshRenderer> buttonRenderers = new List <MeshRenderer>();
string buttonDebug = "Looking for button: " + buttonID;
EVRButtonId searchButtonID = buttonID;
if (buttonID == EVRButtonId.k_EButton_Grip && SteamVR.instance.hmd_TrackingSystemName.ToLowerInvariant().Contains("oculus"))
{
searchButtonID = EVRButtonId.k_EButton_Axis2;
}
ulong buttonMaskForID = (1ul << (int)searchButtonID);
foreach (KeyValuePair <string, ulong> componentButtonMask in componentButtonMasks)
{
if ((componentButtonMask.Value & buttonMaskForID) == buttonMaskForID)
{
buttonDebug += "\nFound component: " + componentButtonMask.Key + " " + componentButtonMask.Value;
Transform componentTransform = renderModel.FindComponent(componentButtonMask.Key);
buttonTransform = componentTransform;
buttonDebug += "\nFound componentTransform: " + componentTransform + " buttonTransform: " + buttonTransform;
buttonRenderers.AddRange(componentTransform.GetComponentsInChildren <MeshRenderer>());
}
}
buttonDebug += "\nFound " + buttonRenderers.Count + " renderers for " + buttonID;
foreach (MeshRenderer renderer in buttonRenderers)
{
buttonDebug += "\n\t" + renderer.name;
}
HintDebugLog(buttonDebug);
if (buttonTransform == null)
{
HintDebugLog("Couldn't find buttonTransform for " + buttonID);
return;
}
ButtonHintInfo hintInfo = new ButtonHintInfo();
buttonHintInfos.Add(buttonID, hintInfo);
hintInfo.componentName = buttonTransform.name;
hintInfo.renderers = buttonRenderers;
//Get the local transform for the button
hintInfo.localTransform = buttonTransform.Find(SteamVR_RenderModel.k_localTransformName);
OffsetType offsetType = OffsetType.Right;
switch (buttonID)
{
case EVRButtonId.k_EButton_SteamVR_Trigger:
{
offsetType = OffsetType.Right;
}
break;
case EVRButtonId.k_EButton_ApplicationMenu:
{
offsetType = OffsetType.Right;
}
break;
case EVRButtonId.k_EButton_System:
{
offsetType = OffsetType.Right;
}
break;
case Valve.VR.EVRButtonId.k_EButton_Grip:
{
offsetType = OffsetType.Forward;
}
break;
case Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad:
{
offsetType = OffsetType.Up;
}
break;
}
//Offset for the text end transform
switch (offsetType)
{
case OffsetType.Forward:
hintInfo.textEndOffsetDir = hintInfo.localTransform.forward;
break;
case OffsetType.Back:
hintInfo.textEndOffsetDir = -hintInfo.localTransform.forward;
break;
case OffsetType.Right:
hintInfo.textEndOffsetDir = hintInfo.localTransform.right;
break;
case OffsetType.Up:
hintInfo.textEndOffsetDir = hintInfo.localTransform.up;
break;
}
//Create the text hint object
Vector3 hintStartPos = hintInfo.localTransform.position + (hintInfo.localTransform.forward * 0.01f);
hintInfo.textHintObject = GameObject.Instantiate(textHintPrefab, hintStartPos, Quaternion.identity) as GameObject;
hintInfo.textHintObject.name = "Hint_" + hintInfo.componentName + "_Start";
hintInfo.textHintObject.transform.SetParent(textHintParent);
hintInfo.textHintObject.layer = gameObject.layer;
hintInfo.textHintObject.tag = gameObject.tag;
//Get all the relevant child objects
hintInfo.textStartAnchor = hintInfo.textHintObject.transform.Find("Start");
hintInfo.textEndAnchor = hintInfo.textHintObject.transform.Find("End");
hintInfo.canvasOffset = hintInfo.textHintObject.transform.Find("CanvasOffset");
hintInfo.line = hintInfo.textHintObject.transform.Find("Line").GetComponent <LineRenderer>();
hintInfo.textCanvas = hintInfo.textHintObject.GetComponentInChildren <Canvas>();
hintInfo.text = hintInfo.textCanvas.GetComponentInChildren <Text>();
hintInfo.textMesh = hintInfo.textCanvas.GetComponentInChildren <TextMesh>();
hintInfo.textHintObject.SetActive(false);
hintInfo.textStartAnchor.position = hintStartPos;
if (hintInfo.text != null)
{
hintInfo.text.text = hintInfo.componentName;
}
if (hintInfo.textMesh != null)
{
hintInfo.textMesh.text = hintInfo.componentName;
}
centerPosition += hintInfo.textStartAnchor.position;
// Scale hint components to match player size
hintInfo.textCanvas.transform.localScale = Vector3.Scale(hintInfo.textCanvas.transform.localScale, player.transform.localScale);
hintInfo.textStartAnchor.transform.localScale = Vector3.Scale(hintInfo.textStartAnchor.transform.localScale, player.transform.localScale);
hintInfo.textEndAnchor.transform.localScale = Vector3.Scale(hintInfo.textEndAnchor.transform.localScale, player.transform.localScale);
hintInfo.line.transform.localScale = Vector3.Scale(hintInfo.line.transform.localScale, player.transform.localScale);
}
public Vector2 GetAxis(EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
Update();
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;
}
private void CreateAndAddButtonInfo(EVRButtonId buttonID)
{
Transform transform = null;
List <MeshRenderer> list = new List <MeshRenderer>();
string text = "Looking for button: " + buttonID;
EVRButtonId evrbuttonId = buttonID;
if (buttonID == EVRButtonId.k_EButton_Grip && SteamVR.instance.hmd_TrackingSystemName.ToLowerInvariant().Contains("oculus"))
{
evrbuttonId = EVRButtonId.k_EButton_Axis2;
}
ulong num = 1UL << (int)evrbuttonId;
string text2;
foreach (KeyValuePair <string, ulong> keyValuePair in this.componentButtonMasks)
{
if ((keyValuePair.Value & num) == num)
{
text2 = text;
text = string.Concat(new object[]
{
text2,
"\nFound component: ",
keyValuePair.Key,
" ",
keyValuePair.Value
});
Transform transform2 = this.renderModel.FindComponent(keyValuePair.Key);
transform = transform2;
text2 = text;
text = string.Concat(new object[]
{
text2,
"\nFound componentTransform: ",
transform2,
" buttonTransform: ",
transform
});
list.AddRange(transform2.GetComponentsInChildren <MeshRenderer>());
}
}
text2 = text;
text = string.Concat(new object[]
{
text2,
"\nFound ",
list.Count,
" renderers for ",
buttonID
});
foreach (MeshRenderer meshRenderer in list)
{
text = text + "\n\t" + meshRenderer.name;
}
this.HintDebugLog(text);
if (transform == null)
{
this.HintDebugLog("Couldn't find buttonTransform for " + buttonID);
return;
}
ControllerButtonHints.ButtonHintInfo buttonHintInfo = new ControllerButtonHints.ButtonHintInfo();
this.buttonHintInfos.Add(buttonID, buttonHintInfo);
buttonHintInfo.componentName = transform.name;
buttonHintInfo.renderers = list;
buttonHintInfo.localTransform = transform.Find("attach");
ControllerButtonHints.OffsetType offsetType = ControllerButtonHints.OffsetType.Right;
switch (buttonID)
{
case EVRButtonId.k_EButton_System:
offsetType = ControllerButtonHints.OffsetType.Right;
break;
case EVRButtonId.k_EButton_ApplicationMenu:
offsetType = ControllerButtonHints.OffsetType.Right;
break;
case EVRButtonId.k_EButton_Grip:
offsetType = ControllerButtonHints.OffsetType.Forward;
break;
default:
if (buttonID != EVRButtonId.k_EButton_Axis0)
{
if (buttonID == EVRButtonId.k_EButton_Axis1)
{
offsetType = ControllerButtonHints.OffsetType.Right;
}
}
else
{
offsetType = ControllerButtonHints.OffsetType.Up;
}
break;
}
switch (offsetType)
{
case ControllerButtonHints.OffsetType.Up:
buttonHintInfo.textEndOffsetDir = buttonHintInfo.localTransform.up;
break;
case ControllerButtonHints.OffsetType.Right:
buttonHintInfo.textEndOffsetDir = buttonHintInfo.localTransform.right;
break;
case ControllerButtonHints.OffsetType.Forward:
buttonHintInfo.textEndOffsetDir = buttonHintInfo.localTransform.forward;
break;
case ControllerButtonHints.OffsetType.Back:
buttonHintInfo.textEndOffsetDir = -buttonHintInfo.localTransform.forward;
break;
}
Vector3 position = buttonHintInfo.localTransform.position + buttonHintInfo.localTransform.forward * 0.01f;
buttonHintInfo.textHintObject = UnityEngine.Object.Instantiate <GameObject>(this.textHintPrefab, position, Quaternion.identity);
buttonHintInfo.textHintObject.name = "Hint_" + buttonHintInfo.componentName + "_Start";
buttonHintInfo.textHintObject.transform.SetParent(this.textHintParent);
buttonHintInfo.textHintObject.layer = base.gameObject.layer;
buttonHintInfo.textHintObject.tag = base.gameObject.tag;
buttonHintInfo.textStartAnchor = buttonHintInfo.textHintObject.transform.Find("Start");
buttonHintInfo.textEndAnchor = buttonHintInfo.textHintObject.transform.Find("End");
buttonHintInfo.canvasOffset = buttonHintInfo.textHintObject.transform.Find("CanvasOffset");
buttonHintInfo.line = buttonHintInfo.textHintObject.transform.Find("Line").GetComponent <LineRenderer>();
buttonHintInfo.textCanvas = buttonHintInfo.textHintObject.GetComponentInChildren <Canvas>();
buttonHintInfo.text = buttonHintInfo.textCanvas.GetComponentInChildren <Text>();
buttonHintInfo.textMesh = buttonHintInfo.textCanvas.GetComponentInChildren <TextMesh>();
buttonHintInfo.textHintObject.SetActive(false);
buttonHintInfo.textStartAnchor.position = position;
if (buttonHintInfo.text != null)
{
buttonHintInfo.text.text = buttonHintInfo.componentName;
}
if (buttonHintInfo.textMesh != null)
{
buttonHintInfo.textMesh.text = buttonHintInfo.componentName;
}
this.centerPosition += buttonHintInfo.textStartAnchor.position;
buttonHintInfo.textCanvas.transform.localScale = Vector3.Scale(buttonHintInfo.textCanvas.transform.localScale, this.player.transform.localScale);
buttonHintInfo.textStartAnchor.transform.localScale = Vector3.Scale(buttonHintInfo.textStartAnchor.transform.localScale, this.player.transform.localScale);
buttonHintInfo.textEndAnchor.transform.localScale = Vector3.Scale(buttonHintInfo.textEndAnchor.transform.localScale, this.player.transform.localScale);
buttonHintInfo.line.transform.localScale = Vector3.Scale(buttonHintInfo.line.transform.localScale, this.player.transform.localScale);
}
public void TriggerHapticPulse(ushort durationMicroSec = 500, EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
trackedController.peripheral.DpnupWriteDeviceFeedback(DPNP_VALUE_TYPE.DPNP_VALUE_TYPE_FEEDBACK_MOTOR - DPNP_VALUE_TYPE.DPNP_VALUE_TYPE_FEEDBACK, durationMicroSec / 1000.0f);
}
/************CON ESTO SE LLAMAN LOS METODOS DE LA INTERACCION DEPENDIENDO DEL BOTON PRESIONADO*************/
public override void ButtonPressDown(EVRButtonId button, ControllerInput controller)
{
thisScreen.SetActive(false);
nxtScreen.SetActive(true);
}
private bool GetPress(EVRButtonId id)
{
return(SteamVR_Controller.Input(index).GetPressDown(id) ||
SteamVR_Controller.Input(index).GetPress(id));
}
public bool GetPressDown(EVRButtonId buttonId)
{
return(GetPressDown(1ul << (int)buttonId));
}
private bool GetTouch(EVRButtonId id)
{
return(SteamVR_Controller.Input(index).GetTouchDown(id) ||
SteamVR_Controller.Input(index).GetTouch(id));
}
public void LongHapticPulse(float seconds, EVRButtonId buttonId = EVRButtonId.k_EButton_Axis0)
{
StartCoroutine(DoLongHapticPulse(seconds, buttonId));
}
public OVRKeyEventArgs(EVRButtonId buttonId, Vector2 axis, bool isLeft, bool isTouch) : base()
{
this.buttonId = buttonId; this.axis = axis; this.isLeft = isLeft; this.isAxis = isTouch;
}
public override bool GetTouchUp(EVRButtonId buttonId)
{
return(m_state.GetTouchUp(buttonId));
}
/// <summary>
///
/// </summary>
/// <param name="eventStr">press, pressandhold, unpress, touch, touchandhold, untouch</param>
/// <param name="id"></param>
/// <param name="btnId"></param>
/// <param name="holdT"></param>
public int ButtonEvent(string eventStr, int id, EVRButtonId btnId, int holdT)
{
return(_fnButtonEvent(_self, ToByte(eventStr), id, (int)btnId, holdT));
}
public override Vector2 GetAxis(EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad, bool usePrevState = false)
{
return(m_state.GetAxis(buttonId, usePrevState));
}
public string GetButtonIdNameFromEnum(EVRButtonId eButtonId)
{
IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId);
return (string) Marshal.PtrToStructure(result, typeof(string));
}
public virtual bool GetTouchUp(EVRButtonId buttonId)
{
return(false);
}
public static bool IsTouched(this VRControllerState_t controllerState, EVRButtonId buttonId)
{
return((controllerState.ulButtonTouched & (1ul << (int)buttonId)) != 0);
}
public override bool GetPressUp(EVRButtonId buttonId)
{
return(GetPressUp(1ul << (int)buttonId));
}
public KeyEventArgs(EVRButtonId buttonId, float axisX, float axisY, bool isLeft) : base()
{
ButtonId = buttonId; AxisX = axisX; AxisY = axisY; IsLeft = isLeft;
}
public abstract string GetButtonIdNameFromEnum(EVRButtonId eButtonId);
public Vector2 GetAxis(EVRButtonId buttonId = EVRButtonId.k_EButton_SteamVR_Touchpad)
{
Update();
var axisId = (uint)buttonId - (uint)EVRButtonId.k_EButton_Axis0;
return new Vector2(state.rAxis[axisId].x, state.rAxis[axisId].y);
}
public override string GetButtonIdNameFromEnum(EVRButtonId eButtonId)
{
CheckIfUsable();
IntPtr result = VRNativeEntrypoints.VR_IVRSystem_GetButtonIdNameFromEnum(m_pVRSystem,eButtonId);
return (string) Marshal.PtrToStructure(result, typeof(string));
}
public bool WasButtonPressed(EVRButtonId button)
{
return false;
}
