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