mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-29 17:23:12 +02:00
245 lines
9.4 KiB
C++
245 lines
9.4 KiB
C++
//
|
|
// ControllerScriptingInterface.cpp
|
|
// interface/src/scripting
|
|
//
|
|
// Created by Brad Hefta-Gaub on 12/17/13.
|
|
// Copyright 2013 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "ControllerScriptingInterface.h"
|
|
|
|
#include <avatar/AvatarManager.h>
|
|
#include <avatar/MyAvatar.h>
|
|
#include <HandData.h>
|
|
#include <HFBackEvent.h>
|
|
#include <plugins/PluginManager.h>
|
|
|
|
#include "Application.h"
|
|
#include "devices/MotionTracker.h"
|
|
|
|
// TODO: this needs to be removed, as well as any related controller-specific information
|
|
#include <input-plugins/SixenseManager.h>
|
|
|
|
void ControllerScriptingInterface::handleMetaEvent(HFMetaEvent* event) {
|
|
if (event->type() == HFActionEvent::startType()) {
|
|
emit actionStartEvent(static_cast<HFActionEvent&>(*event));
|
|
} else if (event->type() == HFActionEvent::endType()) {
|
|
emit actionEndEvent(static_cast<HFActionEvent&>(*event));
|
|
} else if (event->type() == HFBackEvent::startType()) {
|
|
emit backStartEvent();
|
|
} else if (event->type() == HFBackEvent::endType()) {
|
|
emit backEndEvent();
|
|
}
|
|
}
|
|
|
|
const PalmData* ControllerScriptingInterface::getPrimaryPalm() const {
|
|
int leftPalmIndex, rightPalmIndex;
|
|
|
|
const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
|
|
handData->getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
|
|
|
|
if (rightPalmIndex != -1) {
|
|
return &handData->getPalms()[rightPalmIndex];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int ControllerScriptingInterface::getNumberOfActivePalms() const {
|
|
const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
|
|
int numberOfPalms = handData->getNumPalms();
|
|
int numberOfActivePalms = 0;
|
|
for (int i = 0; i < numberOfPalms; i++) {
|
|
if (getPalm(i)->isActive()) {
|
|
numberOfActivePalms++;
|
|
}
|
|
}
|
|
return numberOfActivePalms;
|
|
}
|
|
|
|
const PalmData* ControllerScriptingInterface::getPalm(int palmIndex) const {
|
|
const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
|
|
return &handData->getPalms()[palmIndex];
|
|
}
|
|
|
|
const PalmData* ControllerScriptingInterface::getActivePalm(int palmIndex) const {
|
|
const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
|
|
int numberOfPalms = handData->getNumPalms();
|
|
int numberOfActivePalms = 0;
|
|
for (int i = 0; i < numberOfPalms; i++) {
|
|
if (getPalm(i)->isActive()) {
|
|
if (numberOfActivePalms == palmIndex) {
|
|
return &handData->getPalms()[i];
|
|
}
|
|
numberOfActivePalms++;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool ControllerScriptingInterface::isKeyCaptured(QKeyEvent* event) const {
|
|
return isKeyCaptured(KeyEvent(*event));
|
|
}
|
|
|
|
bool ControllerScriptingInterface::isKeyCaptured(const KeyEvent& event) const {
|
|
// if we've captured some combination of this key it will be in the map
|
|
return _capturedKeys.contains(event.key, event);
|
|
}
|
|
|
|
void ControllerScriptingInterface::captureKeyEvents(const KeyEvent& event) {
|
|
// if it's valid
|
|
if (event.isValid) {
|
|
// and not already captured
|
|
if (!isKeyCaptured(event)) {
|
|
// then add this KeyEvent record to the captured combos for this key
|
|
_capturedKeys.insert(event.key, event);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ControllerScriptingInterface::releaseKeyEvents(const KeyEvent& event) {
|
|
if (event.isValid) {
|
|
// and not already captured
|
|
if (isKeyCaptured(event)) {
|
|
_capturedKeys.remove(event.key, event);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ControllerScriptingInterface::isJoystickCaptured(int joystickIndex) const {
|
|
return _capturedJoysticks.contains(joystickIndex);
|
|
}
|
|
|
|
void ControllerScriptingInterface::captureJoystick(int joystickIndex) {
|
|
if (!isJoystickCaptured(joystickIndex)) {
|
|
_capturedJoysticks.insert(joystickIndex);
|
|
}
|
|
}
|
|
|
|
void ControllerScriptingInterface::releaseJoystick(int joystickIndex) {
|
|
if (isJoystickCaptured(joystickIndex)) {
|
|
_capturedJoysticks.remove(joystickIndex);
|
|
}
|
|
}
|
|
|
|
glm::vec2 ControllerScriptingInterface::getViewportDimensions() const {
|
|
return qApp->getUiSize();
|
|
}
|
|
|
|
controller::InputController::Pointer ControllerScriptingInterface::createInputController(const QString& deviceName, const QString& tracker) {
|
|
// This is where we retreive the Device Tracker category and then the sub tracker within it
|
|
auto icIt = _inputControllers.find(0);
|
|
if (icIt != _inputControllers.end()) {
|
|
return (*icIt).second;
|
|
}
|
|
|
|
|
|
// Look for device
|
|
DeviceTracker::ID deviceID = DeviceTracker::getDeviceID(deviceName.toStdString());
|
|
if (deviceID < 0) {
|
|
deviceID = 0;
|
|
}
|
|
// TODO in this current implementation, we just pick the device assuming there is one (normally the Leapmotion)
|
|
// in the near future we need to change that to a real mapping between the devices and the deviceName
|
|
// ALso we need to expand the spec so we can fall back on the "default" controller per categories
|
|
|
|
if (deviceID >= 0) {
|
|
// TODO here again the assumption it's the LeapMotion and so it's a MOtionTracker, this would need to be changed to support different types of devices
|
|
MotionTracker* motionTracker = dynamic_cast< MotionTracker* > (DeviceTracker::getDevice(deviceID));
|
|
if (motionTracker) {
|
|
MotionTracker::Index trackerID = motionTracker->findJointIndex(tracker.toStdString());
|
|
if (trackerID >= 0) {
|
|
controller::InputController::Pointer inputController = std::make_shared<InputController>(deviceID, trackerID, this);
|
|
controller::InputController::Key key = inputController->getKey();
|
|
_inputControllers.insert(InputControllerMap::value_type(key, inputController));
|
|
return inputController;
|
|
}
|
|
}
|
|
}
|
|
|
|
return controller::InputController::Pointer();
|
|
}
|
|
|
|
void ControllerScriptingInterface::releaseInputController(controller::InputController::Pointer input) {
|
|
_inputControllers.erase(input->getKey());
|
|
}
|
|
|
|
void ControllerScriptingInterface::update() {
|
|
static float last = secTimestampNow();
|
|
float now = secTimestampNow();
|
|
float delta = now - last;
|
|
last = now;
|
|
|
|
DependencyManager::get<UserInputMapper>()->update(delta);
|
|
|
|
bool jointsCaptured = false;
|
|
for (auto inputPlugin : PluginManager::getInstance()->getInputPlugins()) {
|
|
if (inputPlugin->isActive()) {
|
|
inputPlugin->pluginUpdate(delta, jointsCaptured);
|
|
if (inputPlugin->isJointController()) {
|
|
jointsCaptured = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto entry : _inputControllers) {
|
|
entry.second->update();
|
|
}
|
|
|
|
controller::ScriptingInterface::update();
|
|
}
|
|
|
|
InputController::InputController(int deviceTrackerId, int subTrackerId, QObject* parent) :
|
|
_deviceTrackerId(deviceTrackerId),
|
|
_subTrackerId(subTrackerId),
|
|
_isActive(false)
|
|
{
|
|
}
|
|
|
|
void InputController::update() {
|
|
_isActive = false;
|
|
|
|
// TODO for now the InputController is only supporting a JointTracker from a MotionTracker
|
|
MotionTracker* motionTracker = dynamic_cast< MotionTracker*> (DeviceTracker::getDevice(_deviceTrackerId));
|
|
if (motionTracker) {
|
|
if ((int)_subTrackerId < motionTracker->numJointTrackers()) {
|
|
const MotionTracker::JointTracker* joint = motionTracker->getJointTracker(_subTrackerId);
|
|
|
|
if (joint->isActive()) {
|
|
joint->getAbsFrame().getTranslation(_eventCache.absTranslation);
|
|
joint->getAbsFrame().getRotation(_eventCache.absRotation);
|
|
joint->getLocFrame().getTranslation(_eventCache.locTranslation);
|
|
joint->getLocFrame().getRotation(_eventCache.locRotation);
|
|
|
|
_isActive = true;
|
|
//emit spatialEvent(_eventCache);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const unsigned int INPUTCONTROLLER_KEY_DEVICE_OFFSET = 16;
|
|
const unsigned int INPUTCONTROLLER_KEY_DEVICE_MASK = 16;
|
|
|
|
InputController::Key InputController::getKey() const {
|
|
return (((_deviceTrackerId & INPUTCONTROLLER_KEY_DEVICE_MASK) << INPUTCONTROLLER_KEY_DEVICE_OFFSET) | _subTrackerId);
|
|
}
|
|
|
|
|
|
void ControllerScriptingInterface::emitKeyPressEvent(QKeyEvent* event) { emit keyPressEvent(KeyEvent(*event)); }
|
|
void ControllerScriptingInterface::emitKeyReleaseEvent(QKeyEvent* event) { emit keyReleaseEvent(KeyEvent(*event)); }
|
|
|
|
void ControllerScriptingInterface::emitMouseMoveEvent(QMouseEvent* event, unsigned int deviceID) { emit mouseMoveEvent(MouseEvent(*event, deviceID)); }
|
|
void ControllerScriptingInterface::emitMousePressEvent(QMouseEvent* event, unsigned int deviceID) { emit mousePressEvent(MouseEvent(*event, deviceID)); }
|
|
void ControllerScriptingInterface::emitMouseDoublePressEvent(QMouseEvent* event, unsigned int deviceID) { emit mouseDoublePressEvent(MouseEvent(*event, deviceID)); }
|
|
void ControllerScriptingInterface::emitMouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) { emit mouseReleaseEvent(MouseEvent(*event, deviceID)); }
|
|
|
|
void ControllerScriptingInterface::emitTouchBeginEvent(const TouchEvent& event) { emit touchBeginEvent(event); }
|
|
void ControllerScriptingInterface::emitTouchEndEvent(const TouchEvent& event) { emit touchEndEvent(event); }
|
|
void ControllerScriptingInterface::emitTouchUpdateEvent(const TouchEvent& event) { emit touchUpdateEvent(event); }
|
|
|
|
void ControllerScriptingInterface::emitWheelEvent(QWheelEvent* event) { emit wheelEvent(*event); }
|
|
|