public void UpdateData()
{
#if UNITY_ANDROID && !UNITY_EDITOR
// Running on Android device.
// Update controller state.
GvrBasePointer pointer = GvrPointerInputModule.Pointer;
bool isPointerAvailable = pointer != null && pointer.IsAvailable;
if (isPointerAvailable)
{
GvrControllerInputDevice controllerInputDevice = pointer.ControllerInputDevice;
if (controllerInputDevice != null && controllerInputDevice.State == GvrConnectionState.Connected)
{
bool pressed = controllerInputDevice.GetButton(GvrControllerButton.TouchPadButton);
gvr_keyboard_update_button_state(keyboard_context, kGvrControllerButtonClick, pressed);
// Update touch state
Vector2 touch_pos = controllerInputDevice.TouchPos;
IntPtr touch_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(touch_pos));
Marshal.StructureToPtr(touch_pos, touch_ptr, true);
bool isTouching = controllerInputDevice.GetButton(GvrControllerButton.TouchPadTouch);
gvr_keyboard_update_controller_touch(keyboard_context, isTouching, touch_ptr);
GvrBasePointer.PointerRay pointerRay = pointer.GetRayForDistance(currentDistance);
Vector3 startPoint = pointerRay.ray.origin;
// Need to flip Z for native library
startPoint.z *= -1;
IntPtr start_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(startPoint));
Marshal.StructureToPtr(startPoint, start_ptr, true);
Vector3 endPoint = pointerRay.ray.GetPoint(pointerRay.distance);
// Need to flip Z for native library
endPoint.z *= -1;
IntPtr end_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(endPoint));
Marshal.StructureToPtr(endPoint, end_ptr, true);
Vector3 hit = Vector3.one;
IntPtr hit_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(Vector3.zero));
Marshal.StructureToPtr(Vector3.zero, hit_ptr, true);
gvr_keyboard_update_controller_ray(keyboard_context, start_ptr, end_ptr, hit_ptr);
hit = (Vector3)Marshal.PtrToStructure(hit_ptr, typeof(Vector3));
hit.z *= -1;
Marshal.FreeHGlobal(touch_ptr);
Marshal.FreeHGlobal(hit_ptr);
Marshal.FreeHGlobal(end_ptr);
Marshal.FreeHGlobal(start_ptr);
}
}
#endif // UNITY_ANDROID && !UNITY_EDITOR
// Get time stamp.
gvr_clock_time_point time = gvr_get_time_point_now();
time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
// Update frame data.
GvrKeyboardSetFrameData(keyboard_context, time);
GL.IssuePluginEvent(renderEventFunction, advanceID);
}
private void UpdateDeviceInput()
{
IVRModuleDeviceState prevState;
IVRModuleDeviceStateRW currState;
EnsureValidDeviceState(RIGHT_HAND_INDEX, out prevState, out currState);
if (currState.isConnected)
{
var appPressed = m_rightDevice.GetButton(GvrControllerButton.App);
var systemPressed = m_rightDevice.GetButton(GvrControllerButton.System);
var padPressed = m_rightDevice.GetButton(GvrControllerButton.TouchPadButton);
var padTouched = m_rightDevice.GetButton(GvrControllerButton.TouchPadTouch);
var padAxis = m_rightDevice.TouchPos;
currState.SetButtonPress(VRModuleRawButton.Touchpad, padPressed);
currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, appPressed);
currState.SetButtonPress(VRModuleRawButton.System, systemPressed);
currState.SetButtonTouch(VRModuleRawButton.Touchpad, padTouched);
currState.SetAxisValue(VRModuleRawAxis.TouchpadX, padAxis.x);
currState.SetAxisValue(VRModuleRawAxis.TouchpadY, padAxis.y);
if (VIUSettings.daydreamSyncPadPressToTrigger)
{
currState.SetButtonPress(VRModuleRawButton.Trigger, padPressed);
currState.SetButtonTouch(VRModuleRawButton.Trigger, padTouched);
currState.SetAxisValue(VRModuleRawAxis.Trigger, padPressed ? 1f : 0f);
}
}
EnsureValidDeviceState(LEFT_HAND_INDEX, out prevState, out currState);
if (currState.isConnected)
{
var appPressed = m_leftDevice.GetButton(GvrControllerButton.App);
var systemPressed = m_leftDevice.GetButton(GvrControllerButton.System);
var padPressed = m_leftDevice.GetButton(GvrControllerButton.TouchPadButton);
var padTouched = m_leftDevice.GetButton(GvrControllerButton.TouchPadTouch);
var padAxis = m_leftDevice.TouchPos;
currState.SetButtonPress(VRModuleRawButton.Touchpad, padPressed);
currState.SetButtonPress(VRModuleRawButton.ApplicationMenu, appPressed);
currState.SetButtonPress(VRModuleRawButton.System, systemPressed);
currState.SetButtonTouch(VRModuleRawButton.Touchpad, padTouched);
currState.SetAxisValue(VRModuleRawAxis.TouchpadX, padAxis.x);
currState.SetAxisValue(VRModuleRawAxis.TouchpadY, padAxis.y);
if (VIUSettings.daydreamSyncPadPressToTrigger)
{
currState.SetButtonPress(VRModuleRawButton.Trigger, padPressed);
currState.SetButtonTouch(VRModuleRawButton.Trigger, padTouched);
currState.SetAxisValue(VRModuleRawAxis.Trigger, padPressed ? 1f : 0f);
}
}
}
void Update()
{
if (VRDevice.OculusGo) //On OculusGo, use the controller's trigger to recalibrate
{
OVRInput.Update();
if (OVRInput.Get(oculusGoRecenterButton))
{
Recenter();
}
if (OVRInput.Get(oculusGoQuitButton))
{
Application.Quit();
}
}
else if (VRDevice.MirageSolo) //On Mirage Solo, use the controller's click button
{
bool overrideTouch = false;
bool overrideQuit = false;
GvrControllerInputDevice device = GvrControllerInput.GetDevice(GvrControllerHand.Dominant);
if (device == null)
{
device = GvrControllerInput.GetDevice(GvrControllerHand.NonDominant);
if (device == null)
{
Haze.Logger.LogError("Daydream Input API Status: " + GvrControllerInput.ApiStatus);
Haze.Logger.LogError("ErrorDetails: " + GvrControllerInput.ErrorDetails);
}
}
if ((device != null && device.GetButton(mirageRecenterButton)) || overrideTouch)
{
Recenter();
}
if ((device != null && device.GetButton(mirageQuitButton)) || overrideQuit)
{
Application.Quit();
}
}
else if (VRDevice.GearVR) //On GearVR, double-tap to recalibrate
{
if (firstTap > 0) //we've tapped a first time!
{
if (Input.GetMouseButtonDown(0))
{
//that's it, double-tapped.
Recenter();
firstTap = 0;
}
firstTap -= Time.deltaTime;
}
else if (Input.GetMouseButtonUp(0))
{
firstTap = 0.3f; //you have .3 seconds to tap once more for double tap!
}
}
}
private void Rotate(GvrControllerInputDevice device)
{
if (device.GetButton(GvrControllerButton.TouchPadTouch) && !device.GetButton(GvrControllerButton.TouchPadButton))
{
if (prevTouchPos == Vector2.zero)
{
prevTouchPos = device.TouchPos;
}
else
{
swipeDelta = device.TouchPos - prevTouchPos;
prevTouchPos = device.TouchPos;
if (!hasSwiped && swipeDelta.magnitude >= SwipeThreshold)
{
targetRotation += RotationAmount * swipeDelta.x / Mathf.Abs(swipeDelta.x);
if (targetRotation > 360)
{
targetRotation -= 360;
}
else if (targetRotation < 0)
{
targetRotation += 360;
}
var quat = transform.rotation;
var temp = quat.eulerAngles;
temp.y = targetRotation;
quat.eulerAngles = temp;
networkManager.RaiseEvent(NetworkManager.EventCode.PlayerRotationChanged, quat);
hasSwiped = true;
}
}
}
else
{
prevTouchPos = Vector2.zero;
hasSwiped = false;
}
var eulerAngles = transform.eulerAngles;
eulerAngles.y = Mathf.Lerp(eulerAngles.y, targetRotation, Time.deltaTime * 5);
transform.eulerAngles = eulerAngles;
}
// Update is called once per frame
void Update()
{
if (controller.GetButtonDown(GvrControllerButton.App))
{
timer = 0;
}
else if (controller.GetButton(GvrControllerButton.App))
{
timer += Time.deltaTime;
if (timer >= APP_LONG_PRESS_DURATION && !actionComplete)
{
// Do "long press" actions here
menuActive = !menuActive;
menu.transform.position = camera.transform.position + camera.transform.forward * 0.75f;
menu.transform.rotation = camera.transform.rotation;
menu.SetActive(menuActive);
actionComplete = true;
}
}
else if (controller.GetButtonUp(GvrControllerButton.App))
{
actionComplete = false;
}
}
void Update()
{
/*
* input (a vector2 representing the touchpad surface, used
* to drive the walking animation.
* when not touching control surface : (0,0)
* when touching: Normalized vector with xpos of 1 = full forward.
*
*/
Vector2 input = new Vector2(0, 0);
if (device != null)
{
if (device.GetButton(GvrControllerButton.TouchPadTouch))
{
input = device.TouchPos;
}
else
{
input.Set(0, 0);
}
}
/*
* Now drive the player with that input.
*/
transform.Rotate(0, input.x * rotateSpeed, 0);
Vector3 forward = transform.TransformDirection(Vector3.forward);
float curSpeed = speed * input.y;
transform.position += transform.forward * Time.deltaTime * input.y * speed;
}
/// Returns true while the user holds down any of buttons specified in `buttons` on
/// any controller.
public static bool AnyButton(GvrControllerButton buttons)
{
bool ret = false;
foreach (var hand in AllHands)
{
GvrControllerInputDevice device = GvrControllerInput.GetDevice(hand);
ret |= device.GetButton(buttons);
}
return(ret);
}
// Retrieve controller parameters from a Daydream controller.
private void GetDaydreamControllerStatus(GameObject controllerObject, bool isLeft, out bool trigger, out Vector3 direction, out bool touchpad, out Vector2 touchposition, out bool backButton)
{
trigger = false;
direction = new Vector3(0, 0, 0);
touchpad = false;
touchposition = new Vector2(0, 0);
backButton = false;
GvrTrackedController track = controllerObject.GetComponent <GvrTrackedController> ();
if (track != null)
{
GvrControllerInputDevice inputDevice = track.ControllerInputDevice;
if (inputDevice != null)
{
trigger = inputDevice.GetButton(GvrControllerButton.TouchPadButton);
backButton = inputDevice.GetButton(GvrControllerButton.App);
direction = controllerObject.transform.forward;
touchpad = inputDevice.GetButton(GvrControllerButton.TouchPadTouch);
touchposition = inputDevice.TouchPos;
}
}
}
public override void OnUpdate(GameController gameController)
{
if (controller.GetButton(GvrControllerButton.TouchPadButton))
{
throwController.UpdateDiscVelocity(controller);
}
else if (controller.GetButtonUp(GvrControllerButton.TouchPadButton))
{
if (throwController.ReleaseDisc(controller))
{
gameController.SetState(State.DISC_IN_PLAY);
}
else
{
gameController.SetState(State.PRE_THROW);
}
}
}
// Update is called once per frame
void Update()
{
if (_pointingAt)
{
// While touching the pad pan the map
if (_dominantController.GetButton(GvrControllerButton.TouchPadTouch))
{
Vector2 touchPos = _dominantController.TouchPos;
if (_previousTouchState)
{
_translate = new Vector3();
Vector2 orientationDelta = touchPos - _previousTouch;
_translate.x += orientationDelta.x * panFactor;
_translate.z += orientationDelta.y * panFactor;
this.transform.Translate(_translate);
}
_previousTouchState = true;
_previousTouch = touchPos;
}
// When the pad is let go recenter the map
if (_dominantController.GetButtonUp(GvrControllerButton.TouchPadTouch))
{
Recenter();
_previousTouch = _dominantController.TouchPos;
_previousTouchState = false;
}
// When the button is clicked zoom in
if (_dominantController.GetButtonDown(GvrControllerButton.TouchPadButton)) // Using event instead
{
}
// When the app button is clicked zoom out
if (_dominantController.GetButtonDown(GvrControllerButton.App)) // TODO: Change to double click
{
ZoomOut();
}
}
CullSiteMarkers();
}
