private void UpdateButtonStates()
{
state.buttonsState = 0;
if (IsClickButtonPressed)
{
state.buttonsState |= GvrControllerButton.TouchPadButton;
}
if (IsAppButtonPressed)
{
state.buttonsState |= GvrControllerButton.App;
}
if (IsHomeButtonPressed)
{
state.buttonsState |= GvrControllerButton.System;
}
if (IsTouching)
{
state.buttonsState |= GvrControllerButton.TouchPadTouch;
}
state.SetButtonsUpDownFromPrevious(lastButtonsState);
lastButtonsState = state.buttonsState;
if (0 != (state.buttonsUp & GvrControllerButton.TouchPadTouch))
{
ClearTouchPos();
}
if (0 != (state.buttonsUp & GvrControllerButton.System))
{
Recenter();
}
}
public void ReadState(ControllerState outState, int controller_id)
{
if (controller_id != 0)
{
return;
}
lock (state) {
state.connectionState = GvrConnectionState.Connected;
if (!EmulatorManager.Instance.Connected)
{
state.connectionState = EmulatorManager.Instance.Connecting ?
GvrConnectionState.Connecting : GvrConnectionState.Disconnected;
}
state.apiStatus = EmulatorManager.Instance.Connected ? GvrControllerApiStatus.Ok :
GvrControllerApiStatus.Unavailable;
// During emulation, just assume the controller is fully charged
state.isCharging = false;
state.batteryLevel = GvrControllerBatteryLevel.Full;
state.SetButtonsUpDownFromPrevious(lastButtonsState);
lastButtonsState = state.buttonsState;
outState.CopyFrom(state);
}
state.ClearTransientState();
}
/// Resets the transient state (the state variables that represent events, and which are true
/// for only one frame).
public void ClearTransientState()
{
recentered = false;
buttonsState = 0;
buttonsDown = 0;
buttonsUp = 0;
}
public override bool ResolveTouchUp(GvrControllerButton button, TBInput.Controller controller)
{
if (button == GvrControllerButton.TouchPadButton)
{
return(GetGoogleControllerID(controller).GetButtonUp(GvrControllerButton.TouchPadTouch));
}
return(false);
}
// Runtime switching enabled only in-editor.
void Update()
{
UpdateStatusMessage();
// Scan all devices' buttons for button down, and switch the singleton pointer
// to the controller the user last clicked.
int newPointer = activeControllerPointer;
if (controllerPointers.Length > 1 && controllerPointers[1] != null)
{
// Buttons that can trigger pointer switching.
GvrControllerButton buttonMask = GvrControllerButton.App | GvrControllerButton.TouchPadButton;
GvrTrackedController trackedController1 = controllerPointers[1].GetComponent <GvrTrackedController>();
foreach (var hand in AllHands)
{
GvrControllerInputDevice device = GvrControllerInput.GetDevice(hand);
if (device.GetButtonDown(buttonMask))
{
// Match the button to our own controllerPointers list.
if (device == trackedController1.ControllerInputDevice)
{
newPointer = 1;
}
else
{
newPointer = 0;
}
break;
}
}
}
if (newPointer != activeControllerPointer)
{
activeControllerPointer = newPointer;
SetVRInputMechanism();
}
#if !RUNNING_ON_ANDROID_DEVICE
UpdateEmulatedPlatformIfPlayerSettingsChanged();
if ((isDaydream && gvrEmulatedPlatformType == EmulatedPlatformType.Daydream) ||
(!isDaydream && gvrEmulatedPlatformType == EmulatedPlatformType.Cardboard))
{
return;
}
isDaydream = (gvrEmulatedPlatformType == EmulatedPlatformType.Daydream);
SetVRInputMechanism();
#else
// Running on an Android device.
// Viewer type switched at runtime.
if (!IsDeviceDaydreamReady() || viewerPlatform == GvrSettings.ViewerPlatform)
{
return;
}
isDaydream = (GvrSettings.ViewerPlatform == GvrSettings.ViewerPlatformType.Daydream);
viewerPlatform = GvrSettings.ViewerPlatform;
SetVRInputMechanism();
#endif // !RUNNING_ON_ANDROID_DEVICE
}
public override Vector2 ResolveAxis2D(GvrControllerButton button, TBInput.Controller controller)
{
if (button == GvrControllerButton.TouchPadButton)
{
if (GetGoogleControllerID(controller).GetButton(GvrControllerButton.TouchPadTouch))
{
return(GetGoogleControllerID(controller).TouchPos);
}
}
return(Vector2.zero);
}
/// Returns true the frame after the user stops pressing down any of buttons specified
/// in `buttons` on any controller.
public static bool AnyButtonUp(GvrControllerButton buttons)
{
bool ret = false;
foreach (var hand in AllHands)
{
GvrControllerInputDevice device = GvrControllerInput.GetDevice(hand);
ret |= device.GetButtonUp(buttons);
}
return(ret);
}
private void UpdateButtonStates()
{
state.buttonsState = 0;
if (IsTouchPadButtonPressed)
{
state.buttonsState |= GvrControllerButton.TouchPadButton;
}
if (IsGripButtonPressed)
{
state.buttonsState |= GvrControllerButton.Grip;
}
if (IsTriggerButtonPressed)
{
state.buttonsState |= GvrControllerButton.Trigger;
}
if (IsAppButtonPressed)
{
state.buttonsState |= GvrControllerButton.App;
}
if (IsSystemButtonPressed)
{
state.buttonsState |= GvrControllerButton.System;
}
if (IsTouching & !scrollPause)
{
state.buttonsState |= GvrControllerButton.TouchPadTouch;
}
state.SetButtonsUpDownFromPrevious(lastButtonsState);
lastButtonsState = state.buttonsState;
if (0 != (state.buttonsUp & GvrControllerButton.TouchPadTouch))
{
ClearTouchPos();
}
if (0 != (state.buttonsUp & GvrControllerButton.System))
{
Recenter();
}
}
public void ReadState(ControllerState outState)
{
var nativeControllerState = new NativeControllerState();
ReadControllerState(out nativeControllerState);
outState.connectionState = nativeControllerState.connectionState;
outState.orientation = new Quaternion(
-nativeControllerState.orientation.y,
-nativeControllerState.orientation.z,
nativeControllerState.orientation.w,
nativeControllerState.orientation.x);
outState.gyro = new Vector3(
-nativeControllerState.gyro.x, -nativeControllerState.gyro.y, nativeControllerState.gyro.z);
outState.accel = new Vector3(
nativeControllerState.accel.x, nativeControllerState.accel.y, -nativeControllerState.accel.z);
outState.touchPos = nativeControllerState.touchPos;
outState.batteryLevel = (GvrControllerBatteryLevel)nativeControllerState.batteryLevel;
outState.isCharging = nativeControllerState.isCharging;
outState.recentered = nativeControllerState.isRecentered;
outState.buttonsState = 0;
if (nativeControllerState.appButtonState)
{
outState.buttonsState |= GvrControllerButton.App;
}
if (nativeControllerState.clickButtonState)
{
outState.buttonsState |= GvrControllerButton.TouchPadButton;
}
if (nativeControllerState.homeButtonState)
{
outState.buttonsState |= GvrControllerButton.System;
}
if (nativeControllerState.isTouching)
{
outState.buttonsState |= GvrControllerButton.TouchPadTouch;
}
outState.SetButtonsUpDownFromPrevious(prevButtonsState);
prevButtonsState = outState.buttonsState;
}
public void CopyFrom(ControllerState other)
{
connectionState = other.connectionState;
apiStatus = other.apiStatus;
orientation = other.orientation;
position = other.position;
gyro = other.gyro;
accel = other.accel;
touchPos = other.touchPos;
recentered = other.recentered;
buttonsState = other.buttonsState;
buttonsDown = other.buttonsDown;
buttonsUp = other.buttonsUp;
errorDetails = other.errorDetails;
gvrPtr = other.gvrPtr;
isCharging = other.isCharging;
batteryLevel = other.batteryLevel;
}
private void HandleButtonEvent(EmulatorButtonEvent buttonEvent)
{
GvrControllerButton buttonMask = 0;
switch (buttonEvent.code)
{
case EmulatorButtonEvent.ButtonCode.kApp:
buttonMask = GvrControllerButton.App;
break;
case EmulatorButtonEvent.ButtonCode.kHome:
buttonMask = GvrControllerButton.System;
break;
case EmulatorButtonEvent.ButtonCode.kClick:
buttonMask = GvrControllerButton.TouchPadButton;
break;
}
if (buttonMask != 0)
{
lock (state)
{
state.buttonsState &= ~buttonMask;
if (buttonEvent.down)
{
state.buttonsState |= buttonMask;
}
}
if (buttonMask == GvrControllerButton.System)
{
if (!buttonEvent.down)
{
// Finished the recentering gesture. Recenter controller.
Recenter();
}
}
}
}
public void ReadState(ControllerState outState, int controller_id)
{
if (error)
{
outState.connectionState = GvrConnectionState.Error;
outState.apiStatus = GvrControllerApiStatus.Error;
outState.errorDetails = errorDetails;
return;
}
if (api == IntPtr.Zero || statePtr == IntPtr.Zero)
{
Debug.LogError("AndroidNativeControllerProvider used after dispose.");
return;
}
gvr_controller_state_update(api, controller_id, statePtr);
outState.connectionState = ConvertConnectionState(
gvr_controller_state_get_connection_state(statePtr));
outState.apiStatus = ConvertControllerApiStatus(
gvr_controller_state_get_api_status(statePtr));
gvr_quat rawOri = gvr_controller_state_get_orientation(statePtr);
gvr_vec3 rawAccel = gvr_controller_state_get_accel(statePtr);
gvr_vec3 rawGyro = gvr_controller_state_get_gyro(statePtr);
gvr_vec3 rawPos = gvr_controller_state_get_position(statePtr);
// Convert GVR API orientation (right-handed) into Unity axis system (left-handed).
pose3d.Set(new Vector3(rawPos.x, rawPos.y, rawPos.z), new Quaternion(rawOri.x, rawOri.y, rawOri.z, rawOri.w));
pose3d.SetRightHanded(pose3d.Matrix);
outState.orientation = pose3d.Orientation;
outState.position = pose3d.Position;
// For accelerometer, we have to flip Z because the GVR API has Z pointing backwards
// and Unity has Z pointing forward.
outState.accel = new Vector3(rawAccel.x, rawAccel.y, -rawAccel.z);
// Gyro in GVR represents a right-handed angular velocity about each axis (positive means
// clockwise when sighting along axis). Since Unity uses a left-handed system, we flip the
// signs to adjust the sign of the rotational velocity (so that positive means
// counter-clockwise). In addition, since in Unity the Z axis points forward while GVR
// has Z pointing backwards, we flip the Z axis sign again. So the result is that
// we should use -X, -Y, +Z:
outState.gyro = new Vector3(-rawGyro.x, -rawGyro.y, rawGyro.z);
gvr_vec2 touchPos = gvr_controller_state_get_touch_pos(statePtr);
outState.touchPos = new Vector2(touchPos.x, touchPos.y);
int[] gvr_buttons = new int[] {
GVR_CONTROLLER_BUTTON_APP,
GVR_CONTROLLER_BUTTON_HOME,
GVR_CONTROLLER_BUTTON_CLICK,
GVR_CONTROLLER_BUTTON_RESERVED0,
GVR_CONTROLLER_BUTTON_RESERVED1,
GVR_CONTROLLER_BUTTON_RESERVED2
};
GvrControllerButton[] gvrUnityButtons = new GvrControllerButton[] {
GvrControllerButton.App,
GvrControllerButton.System,
GvrControllerButton.TouchPadButton,
GvrControllerButton.Reserved0,
GvrControllerButton.Reserved1,
GvrControllerButton.Reserved2
};
outState.buttonsState = 0;
for (int i = 0; i < gvr_buttons.Length; i++)
{
if (0 != gvr_controller_state_get_button_state(statePtr, gvr_buttons[i]))
{
outState.buttonsState |= gvrUnityButtons[i];
}
}
if (0 != gvr_controller_state_is_touching(statePtr))
{
outState.buttonsState |= GvrControllerButton.TouchPadTouch;
}
outState.SetButtonsUpDownFromPrevious(lastButtonsState[controller_id]);
lastButtonsState[controller_id] = outState.buttonsState;
outState.recentered = 0 != gvr_controller_state_get_recentered(statePtr);
outState.gvrPtr = statePtr;
if (hasBatteryMethods)
{
outState.isCharging = 0 != gvr_controller_state_get_battery_charging(statePtr);
outState.batteryLevel = (GvrControllerBatteryLevel)gvr_controller_state_get_battery_level(statePtr);
}
}
private void UpdateTriggerState()
{
if (lastUpdateFrame != Time.frameCount)
{
lastUpdateFrame = Time.frameCount;
GvrControllerButton allButtonsMask = 0;
if (ControllerInputDevice != null &&
ControllerInputDevice.SupportsPositionalTracking)
{
allButtonsMask = LEFT_BUTTON_MASK_6DOF | RIGHT_BUTTON_MASK_6DOF;
}
else
{
allButtonsMask = LEFT_BUTTON_MASK_3DOF;
}
GvrControllerButton buttonDown = 0;
GvrControllerButton buttonUp = 0;
if (Input.GetMouseButtonDown(0) || Input.GetKey(KeyCode.L) ||
Input.GetButton("Fire1") ||
Input.GetButton("Fire3") || Input.GetButton("Jump"))
{
if (Input.GetButton("Fire1"))
{
Debug.Log("1Fire1");
}
if (Input.GetButton("Fire2"))
{
Debug.Log("1Fire2");
}
if (Input.GetButton("Fire3"))
{
Debug.Log("1Fire3");
}
if (Input.GetButton("Jump"))
{
Debug.Log("1Jump");
}
if (Input.GetButton("Submit"))
{
Debug.Log("1Submit");
}
if (Input.GetButton("Cancel"))
{
Debug.Log("1Cancel");
}
if (Input.GetButtonDown("Fire1"))
{
Debug.Log("2Fire1");
}
if (Input.GetButtonDown("Fire2"))
{
Debug.Log("2Fire2");
}
if (Input.GetButtonDown("Fire3"))
{
Debug.Log("2Fire3");
}
if (Input.GetButtonDown("Jump"))
{
Debug.Log("2Jump");
}
if (Input.GetButtonDown("Submit"))
{
Debug.Log("2Submit");
}
if (Input.GetButtonDown("Cancel"))
{
Debug.Log("2Cancel");
}
buttonDown |= GvrControllerButton.TouchPadButton;
}
if (Input.GetMouseButtonUp(0) || Input.GetKey(KeyCode.V) ||
Input.GetButton("Fire1") ||
Input.GetButton("Fire3") || Input.GetButton("Jump"))
{
buttonUp |= GvrControllerButton.TouchPadButton;
}
if (ControllerInputDevice != null)
{
buttonDown |= ControllerInputDevice.ButtonsDown;
buttonUp |= ControllerInputDevice.ButtonsUp;
}
buttonDown &= allButtonsMask;
buttonUp &= allButtonsMask;
// Only allow one button down at a time. If one is down, ignore the rest.
if (triggerButton != 0)
{
buttonDown &= triggerButton;
}
else
{
// Mask off everything except the right-most bit that is set in case
// more than one button went down in the same frame.
buttonDown &= (GvrControllerButton)(-(int)buttonDown);
}
// Ignore ups from buttons whose down we ignored.
buttonUp &= triggerButton;
// Build trigger button state from filtered ups and downs to ensure
// actual (A-down, B-down, A-up, B-up) results in
// event (A-down, A-up) instead of
// event (A-down, A-up, B-down, B-up).
triggerButton |= buttonDown;
triggerButton &= ~buttonUp;
triggerButtonDown = buttonDown;
triggerButtonUp = buttonUp;
}
}
public override bool ResolveButtonUp(GvrControllerButton button, TBInput.Controller controller)
{
return(GetGoogleControllerID(controller).GetButtonUp(button));
}
/// Returns true the frame after the user stops pressing down any of the buttons specified
/// in `buttons`. For an individual button enum, every ButtonUp event is guaranteed to be
/// preceded by exactly one ButtonDown event in an earlier frame. Also, ButtonDown and
/// ButtonUp will never both be true in the same frame for an individual button. Using
/// multiple button enums OR'ed together can result in multiple ButtonUps after multiple
/// ButtonDowns.
public bool GetButtonUp(GvrControllerButton buttons)
{
Update();
return((controllerState.buttonsUp & buttons) != 0);
}
/// Returns true in the frame the user starts pressing down any of the buttons specified
/// in `buttons`. For an individual button enum, every ButtonDown event is guaranteed to be
/// followed by exactly one ButtonUp event in a later frame. Also, ButtonDown and ButtonUp
/// will never both be true in the same frame for an individual button. Using multiple button
/// enums OR'ed together can result in multiple ButtonDowns before a ButtonUp.
public bool GetButtonDown(GvrControllerButton buttons)
{
Update();
return((controllerState.buttonsDown & buttons) != 0);
}
private void UpdateTriggerState()
{
if (lastUpdateFrame != Time.frameCount)
{
lastUpdateFrame = Time.frameCount;
GvrControllerButton allButtonsMask = 0;
if (ControllerInputDevice != null &&
ControllerInputDevice.SupportsPositionalTracking)
{
allButtonsMask = LEFT_BUTTON_MASK_6DOF | RIGHT_BUTTON_MASK_6DOF;
}
else
{
allButtonsMask = LEFT_BUTTON_MASK_3DOF;
}
GvrControllerButton buttonDown = 0;
GvrControllerButton buttonUp = 0;
// Cardboard button events come through as mouse button 0 and are
// mapped to TouchPadButton.
if (Input.GetMouseButtonDown(0))
{
buttonDown |= GvrControllerButton.TouchPadButton;
}
if (Input.GetMouseButtonUp(0))
{
buttonUp |= GvrControllerButton.TouchPadButton;
}
if (ControllerInputDevice != null)
{
buttonDown |= ControllerInputDevice.ButtonsDown;
buttonUp |= ControllerInputDevice.ButtonsUp;
}
buttonDown &= allButtonsMask;
buttonUp &= allButtonsMask;
// Only allow one button down at a time. If one is down, ignore the rest.
if (triggerButton != 0)
{
buttonDown &= triggerButton;
}
else
{
// Mask off everything except the right-most bit that is set in case
// more than one button went down in the same frame.
buttonDown &= (GvrControllerButton)(-(int)buttonDown);
}
// Ignore ups from buttons whose down we ignored.
buttonUp &= triggerButton;
// Build trigger button state from filtered ups and downs to ensure
// actual (A-down, B-down, A-up, B-up) results in
// event (A-down, A-up) instead of
// event (A-down, A-up, B-down, B-up).
triggerButton |= buttonDown;
triggerButton &= ~buttonUp;
triggerButtonDown = buttonDown;
triggerButtonUp = buttonUp;
}
}
/// <summary>This MonoBehavior's OnEnable behavior.</summary>
private void OnEnable()
{
triggerButton = 0;
triggerButtonDown = 0;
triggerButtonUp = 0;
}
public void SetButtonsUpDownFromPrevious(GvrControllerButton prevButtonsState)
{
buttonsDown = ~prevButtonsState & buttonsState;
buttonsUp = prevButtonsState & ~buttonsState;
}
