internal override void OnUpdate()
{
if (!_enabled)
{
return;
}
// Clear the current frames; _lastSensorFrame will retain its previous value.
if (_currentSensorFrames.Count > 0)
{
_currentSensorFrames.Clear();
}
if (_connectedDevice == null)
{
return;
}
while (Time.unscaledTime >= _nextSensorUpdateTime)
{
// If it's time to emit frames, do so until we have caught up.
float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);
_nextSensorUpdateTime += deltaTime;
bool anySensorsEnabled = false;
// Update all active sensors
if (_sensorStatus[SensorId.Accelerometer])
{
UpdateAccelerometerData();
anySensorsEnabled = true;
}
if (_sensorStatus[SensorId.Gyroscope])
{
UpdateGyroscopeData();
anySensorsEnabled = true;
}
if (_sensorStatus[SensorId.Rotation])
{
UpdateRotationSensorData();
anySensorsEnabled = true;
}
// Emit a gesture if needed
bool gestureEmitted = UpdateGestureData();
if (anySensorsEnabled || gestureEmitted)
{
// Update the timestamp and delta-time and emit
_lastSensorFrame.deltaTime = deltaTime;
_lastSensorFrame.timestamp = _nextSensorUpdateTime;
_currentSensorFrames.Add(_lastSensorFrame);
OnSensorsOrGestureUpdated(_lastSensorFrame);
}
}
}
internal override void OnUpdate()
{
if (!_enabled)
{
return;
}
if (Time.unscaledTime >= _nextSensorUpdateTime)
{
_nextSensorUpdateTime += WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);
// Update all active sensors
if (_sensorStatus[SensorId.Accelerometer])
{
UpdateAccelerometerData();
}
if (_sensorStatus[SensorId.Gyroscope])
{
UpdateGyroscopeData();
}
if (_sensorStatus[SensorId.Rotation] || _sensorStatus[SensorId.GameRotation])
{
UpdateRotationSensorData();
}
UpdateGestureData();
// Update the timestamp and delta-time, then emit the frame
_lastSensorFrame.deltaTime = Time.unscaledTime - _lastSensorFrame.timestamp;
_lastSensorFrame.timestamp = Time.unscaledTime;
_currentSensorFrames.Clear();
_currentSensorFrames.Add(_lastSensorFrame);
OnSensorsUpdated(_lastSensorFrame);
}
else
{
// Otherwise, the list should be empty. _lastSensorFrame will retain its previous value.
if (_currentSensorFrames.Count > 0)
{
_currentSensorFrames.Clear();
}
}
}
internal override void OnUpdate()
{
UpdateVirtualDeviceInfo();
// Report found devices if searching.
if (_searchingForDevice && Time.unscaledTime >= _nextDeviceSearchUpdateTime)
{
_nextDeviceSearchUpdateTime += WearableConstants.DeviceSearchUpdateIntervalInSeconds;
if (_verbose)
{
Debug.Log(WearableConstants.DebugProviderFoundDevices);
}
var devices = new[] { _virtualDevice };
OnReceivedSearchDevices(devices);
}
// Handle connection states
if (_connectionPhase != ConnectionPhase.Idle &&
Time.unscaledTime >= _nextConnectionStateTime)
{
PerformDeviceConnection();
}
// Clear the current frames; _lastSensorFrame will retain its previous value.
_currentSensorFrames.Clear();
_currentGestureData.Clear();
if (_connectedDevice.HasValue)
{
// Configuration status
if (_waitingToSendConfigSuccess && Time.unscaledTime >= _sendConfigSuccessTime)
{
_waitingToSendConfigSuccess = false;
OnConfigurationSucceeded();
}
if (_waitingToSendConfigFailure && Time.unscaledTime >= _sendConfigFailureTime)
{
_waitingToSendConfigFailure = false;
OnConfigurationFailed(ConfigStatus.Failure, ConfigStatus.Failure);
}
// Device configuration requests
if (_waitingToSendConfigRequestResponse && Time.unscaledTime >= _sendConfigRequestResponseTime)
{
_waitingToSendConfigRequestResponse = false;
OnReceivedDeviceConfiguration(_config.Clone());
}
// Intent validation
if (_waitingToSendIntentValidation && Time.unscaledTime >= _sendIntentValidationTime)
{
_waitingToSendIntentValidation = false;
OnReceivedIntentValidationResponse(_intentResponse);
}
// Sensor and gesture data
while (Time.unscaledTime >= _nextSensorUpdateTime)
{
// If it's time to emit frames, do so until we have caught up.
float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_config.updateInterval);
_nextSensorUpdateTime += deltaTime;
// If the service is mock-suspended, don't update any data. Continue to iterate through this loop,
// however, so we don't fall behind when the service resumes. Drop all gestures that are pending.
if (_dynamicDeviceInfo.deviceStatus.ServiceSuspended)
{
_pendingGestures.Clear();
continue;
}
// Check if sensors need to be updated
bool anySensorsEnabled = _config.HasAnySensorsEnabled();
// Prepare the frame's timestamp for frame emission
if (anySensorsEnabled)
{
// Update the timestamp and delta-time
_lastSensorFrame.deltaTime = deltaTime;
_lastSensorFrame.timestamp = _nextSensorUpdateTime;
// Simulate movement
if (_simulatedMovementMode == MovementSimulationMode.ConstantRate)
{
// Calculate rotation, which is used by all sensors.
if (_rotationType == RotationType.Euler)
{
_rotation = Quaternion.Euler(_eulerSpinRate * _lastSensorFrame.timestamp);
}
else if (_rotationType == RotationType.AxisAngle)
{
_rotation = Quaternion.AngleAxis(
_axisAngleSpinRate.w * _lastSensorFrame.timestamp,
new Vector3(_axisAngleSpinRate.x, _axisAngleSpinRate.y, _axisAngleSpinRate.z).normalized);
}
}
else
{
_rotation = Quaternion.identity;
}
// Update all active sensors, even if motion is not simulated
if (_config.accelerometer.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.Accelerometer))
{
UpdateAccelerometerData();
}
if (_config.gyroscope.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.Gyroscope))
{
UpdateGyroscopeData();
}
if ((_config.rotationSixDof.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.RotationSixDof)) ||
(_config.rotationNineDof.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.RotationNineDof)))
{
UpdateRotationSensorData();
}
// Emit the frame
_currentSensorFrames.Add(_lastSensorFrame);
OnSensorsUpdated(_lastSensorFrame);
}
// Add any gestures simulated in the past sensor frame.
UpdateGestureData();
for (int i = 0; i < _currentGestureData.Count; i++)
{
OnGestureDetected(_currentGestureData[i].gestureId);
}
}
}
// Allow the provider base to do its own update work
base.OnUpdate();
}
internal override void OnUpdate()
{
UpdateVirtualDeviceInfo();
if (!_enabled)
{
return;
}
// Clear the current frames; _lastSensorFrame will retain its previous value.
if (_currentSensorFrames.Count > 0)
{
_currentSensorFrames.Clear();
}
if (_connectedDevice == null)
{
return;
}
while (Time.unscaledTime >= _nextSensorUpdateTime)
{
// If it's time to emit frames, do so until we have caught up.
float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);
_nextSensorUpdateTime += deltaTime;
// Check if sensors need to be updated
bool anySensorsEnabled = false;
for (int i = 0; i < WearableConstants.SensorIds.Length; i++)
{
if (_sensorStatus[WearableConstants.SensorIds[i]])
{
anySensorsEnabled = true;
break;
}
}
// Emit a gesture if needed
bool gestureEmitted = UpdateGestureData();
if (anySensorsEnabled || gestureEmitted)
{
// Update the timestamp and delta-time
_lastSensorFrame.deltaTime = deltaTime;
_lastSensorFrame.timestamp = _nextSensorUpdateTime;
}
if (anySensorsEnabled)
{
if (_simulateMovement)
{
// Calculate rotation, which is used by all sensors.
if (_rotationType == RotationType.Euler)
{
_rotation = Quaternion.Euler(_eulerSpinRate * _lastSensorFrame.timestamp);
}
else if (_rotationType == RotationType.AxisAngle)
{
_rotation = Quaternion.AngleAxis(
_axisAngleSpinRate.w * _lastSensorFrame.timestamp,
new Vector3(_axisAngleSpinRate.x, _axisAngleSpinRate.y, _axisAngleSpinRate.z).normalized);
}
}
else
{
_rotation = Quaternion.identity;
}
// Update all active sensors, even if motion is not simulated
if (_sensorStatus[SensorId.Accelerometer])
{
UpdateAccelerometerData();
}
if (_sensorStatus[SensorId.Gyroscope])
{
UpdateGyroscopeData();
}
if (_sensorStatus[SensorId.Rotation])
{
UpdateRotationSensorData();
}
}
// Emit the frame if needed
if (anySensorsEnabled || gestureEmitted)
{
_currentSensorFrames.Add(_lastSensorFrame);
OnSensorsOrGestureUpdated(_lastSensorFrame);
}
}
}
