From d0d5ac8dd12385abb5cd1e9f95d0db97e65590e4 Mon Sep 17 00:00:00 2001 From: SamGondelman Date: Thu, 10 Aug 2017 15:32:58 -0700 Subject: [PATCH] switch to stl wherever possible, use bitset instead of unsigned ints --- interface/src/raypick/JointRayPick.cpp | 4 +- interface/src/raypick/JointRayPick.h | 6 +- interface/src/raypick/LaserPointer.cpp | 44 +++---- interface/src/raypick/LaserPointer.h | 21 +-- interface/src/raypick/LaserPointerManager.cpp | 84 ++++++------ interface/src/raypick/LaserPointerManager.h | 24 ++-- .../LaserPointerScriptingInterface.cpp | 12 +- .../raypick/LaserPointerScriptingInterface.h | 2 +- interface/src/raypick/MouseRayPick.cpp | 2 +- interface/src/raypick/MouseRayPick.h | 2 +- interface/src/raypick/RayPick.cpp | 2 +- interface/src/raypick/RayPick.h | 76 ++++++++++- interface/src/raypick/RayPickManager.cpp | 120 +++++++++--------- interface/src/raypick/RayPickManager.h | 66 ++++------ interface/src/raypick/StaticRayPick.cpp | 2 +- interface/src/raypick/StaticRayPick.h | 2 +- 16 files changed, 268 insertions(+), 201 deletions(-) diff --git a/interface/src/raypick/JointRayPick.cpp b/interface/src/raypick/JointRayPick.cpp index 6803700e4b..48ab908201 100644 --- a/interface/src/raypick/JointRayPick.cpp +++ b/interface/src/raypick/JointRayPick.cpp @@ -13,7 +13,7 @@ #include "DependencyManager.h" #include "avatar/AvatarManager.h" -JointRayPick::JointRayPick(const QString& jointName, const glm::vec3& posOffset, const glm::vec3& dirOffset, const uint16_t filter, const float maxDistance, const bool enabled) : +JointRayPick::JointRayPick(const std::string& jointName, const glm::vec3& posOffset, const glm::vec3& dirOffset, const RayPickFilter& filter, const float maxDistance, const bool enabled) : RayPick(filter, maxDistance, enabled), _jointName(jointName), _posOffset(posOffset), @@ -23,7 +23,7 @@ JointRayPick::JointRayPick(const QString& jointName, const glm::vec3& posOffset, const PickRay JointRayPick::getPickRay(bool& valid) const { auto myAvatar = DependencyManager::get()->getMyAvatar(); - int jointIndex = myAvatar->getJointIndex(_jointName); + int jointIndex = myAvatar->getJointIndex(QString::fromStdString(_jointName)); bool useAvatarHead = _jointName == "Avatar"; const int INVALID_JOINT = -1; if (jointIndex != INVALID_JOINT || useAvatarHead) { diff --git a/interface/src/raypick/JointRayPick.h b/interface/src/raypick/JointRayPick.h index 0631372bdb..3cd622fbbe 100644 --- a/interface/src/raypick/JointRayPick.h +++ b/interface/src/raypick/JointRayPick.h @@ -13,17 +13,15 @@ #include "RayPick.h" -#include - class JointRayPick : public RayPick { public: - JointRayPick(const QString& jointName, const glm::vec3& posOffset, const glm::vec3& dirOffset, const uint16_t filter, const float maxDistance = 0.0f, const bool enabled = false); + JointRayPick(const std::string& jointName, const glm::vec3& posOffset, const glm::vec3& dirOffset, const RayPickFilter& filter, const float maxDistance = 0.0f, const bool enabled = false); const PickRay getPickRay(bool& valid) const override; private: - QString _jointName; + std::string _jointName; glm::vec3 _posOffset; glm::vec3 _dirOffset; diff --git a/interface/src/raypick/LaserPointer.cpp b/interface/src/raypick/LaserPointer.cpp index 9dc1bdd72e..0e1d384e5d 100644 --- a/interface/src/raypick/LaserPointer.cpp +++ b/interface/src/raypick/LaserPointer.cpp @@ -13,7 +13,7 @@ #include "Application.h" #include "avatar/AvatarManager.h" -LaserPointer::LaserPointer(const QVariantMap& rayProps, const QHash& renderStates, QHash>& defaultRenderStates, +LaserPointer::LaserPointer(const QVariantMap& rayProps, const RenderStateMap& renderStates, const DefaultRenderStateMap& defaultRenderStates, const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled) : _renderingEnabled(enabled), _renderStates(renderStates), @@ -24,14 +24,14 @@ LaserPointer::LaserPointer(const QVariantMap& rayProps, const QHash()->createRayPick(rayProps); - for (QString& state : _renderStates.keys()) { - if (!enabled || state != _currentRenderState) { - disableRenderState(_renderStates[state]); + for (auto& state : _renderStates) { + if (!enabled || state.first != _currentRenderState) { + disableRenderState(state.second); } } - for (QString& state : _defaultRenderStates.keys()) { - if (!enabled || state != _currentRenderState) { - disableRenderState(_defaultRenderStates[state].second); + for (auto& state : _defaultRenderStates) { + if (!enabled || state.first != _currentRenderState) { + disableRenderState(state.second.second); } } } @@ -39,12 +39,12 @@ LaserPointer::LaserPointer(const QVariantMap& rayProps, const QHash()->removeRayPick(_rayPickUID); - for (RenderState& renderState : _renderStates) { - renderState.deleteOverlays(); - } - for (QPair& renderState : _defaultRenderStates) { + for (auto& renderState : _renderStates) { renderState.second.deleteOverlays(); } + for (auto& renderState : _defaultRenderStates) { + renderState.second.second.deleteOverlays(); + } } void LaserPointer::enable() { @@ -55,29 +55,29 @@ void LaserPointer::enable() { void LaserPointer::disable() { DependencyManager::get()->disableRayPick(_rayPickUID); _renderingEnabled = false; - if (!_currentRenderState.isEmpty()) { - if (_renderStates.contains(_currentRenderState)) { + if (!_currentRenderState.empty()) { + if (_renderStates.find(_currentRenderState) != _renderStates.end()) { disableRenderState(_renderStates[_currentRenderState]); } - if (_defaultRenderStates.contains(_currentRenderState)) { + if (_defaultRenderStates.find(_currentRenderState) != _defaultRenderStates.end()) { disableRenderState(_defaultRenderStates[_currentRenderState].second); } } } -void LaserPointer::setRenderState(const QString& state) { - if (!_currentRenderState.isEmpty() && state != _currentRenderState) { - if (_renderStates.contains(_currentRenderState)) { +void LaserPointer::setRenderState(const std::string& state) { + if (!_currentRenderState.empty() && state != _currentRenderState) { + if (_renderStates.find(_currentRenderState) != _renderStates.end()) { disableRenderState(_renderStates[_currentRenderState]); } - if (_defaultRenderStates.contains(_currentRenderState)) { + if (_defaultRenderStates.find(_currentRenderState) != _defaultRenderStates.end()) { disableRenderState(_defaultRenderStates[_currentRenderState].second); } } _currentRenderState = state; } -void LaserPointer::editRenderState(const QString& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) { +void LaserPointer::editRenderState(const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) { updateRenderStateOverlay(_renderStates[state].getStartID(), startProps); updateRenderStateOverlay(_renderStates[state].getPathID(), pathProps); updateRenderStateOverlay(_renderStates[state].getEndID(), endProps); @@ -181,13 +181,13 @@ void LaserPointer::disableRenderState(const RenderState& renderState) { void LaserPointer::update() { RayPickResult prevRayPickResult = DependencyManager::get()->getPrevRayPickResult(_rayPickUID); - if (_renderingEnabled && !_currentRenderState.isEmpty() && _renderStates.contains(_currentRenderState) && prevRayPickResult.type != IntersectionType::NONE) { + if (_renderingEnabled && !_currentRenderState.empty() && _renderStates.find(_currentRenderState) != _renderStates.end() && prevRayPickResult.type != IntersectionType::NONE) { updateRenderState(_renderStates[_currentRenderState], prevRayPickResult.type, prevRayPickResult.distance, prevRayPickResult.objectID, false); disableRenderState(_defaultRenderStates[_currentRenderState].second); - } else if (_renderingEnabled && !_currentRenderState.isEmpty() && _defaultRenderStates.contains(_currentRenderState)) { + } else if (_renderingEnabled && !_currentRenderState.empty() && _defaultRenderStates.find(_currentRenderState) != _defaultRenderStates.end()) { disableRenderState(_renderStates[_currentRenderState]); updateRenderState(_defaultRenderStates[_currentRenderState].second, IntersectionType::NONE, _defaultRenderStates[_currentRenderState].first, QUuid(), true); - } else if (!_currentRenderState.isEmpty()) { + } else if (!_currentRenderState.empty()) { disableRenderState(_renderStates[_currentRenderState]); disableRenderState(_defaultRenderStates[_currentRenderState].second); } diff --git a/interface/src/raypick/LaserPointer.h b/interface/src/raypick/LaserPointer.h index 946b01d3ba..aaa9dad83f 100644 --- a/interface/src/raypick/LaserPointer.h +++ b/interface/src/raypick/LaserPointer.h @@ -48,7 +48,11 @@ private: class LaserPointer { public: - LaserPointer(const QVariantMap& rayProps, const QHash& renderStates, QHash>& defaultRenderStates, + + typedef std::unordered_map RenderStateMap; + typedef std::unordered_map> DefaultRenderStateMap; + + LaserPointer(const QVariantMap& rayProps, const RenderStateMap& renderStates, const DefaultRenderStateMap& defaultRenderStates, const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled); ~LaserPointer(); @@ -57,9 +61,9 @@ public: void disable(); const RayPickResult getPrevRayPickResult() { return DependencyManager::get()->getPrevRayPickResult(_rayPickUID); } - void setRenderState(const QString& state); + void setRenderState(const std::string& state); // You cannot use editRenderState to change the overlay type of any part of the laser pointer. You can only edit the properties of the existing overlays. - void editRenderState(const QString& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps); + void editRenderState(const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps); void setIgnoreEntities(const QScriptValue& ignoreEntities) { DependencyManager::get()->setIgnoreEntities(_rayPickUID, ignoreEntities); } void setIncludeEntities(const QScriptValue& includeEntities) { DependencyManager::get()->setIncludeEntities(_rayPickUID, includeEntities); } @@ -68,25 +72,26 @@ public: void setIgnoreAvatars(const QScriptValue& ignoreAvatars) { DependencyManager::get()->setIgnoreAvatars(_rayPickUID, ignoreAvatars); } void setIncludeAvatars(const QScriptValue& includeAvatars) { DependencyManager::get()->setIncludeAvatars(_rayPickUID, includeAvatars); } - void setLockEndUUID(QUuid objectID, const bool isOverlay) { _objectLockEnd = QPair(objectID, isOverlay); } + void setLockEndUUID(QUuid objectID, const bool isOverlay) { _objectLockEnd = std::pair(objectID, isOverlay); } void update(); private: bool _renderingEnabled; - QString _currentRenderState { "" }; - QHash _renderStates; - QHash> _defaultRenderStates; + std::string _currentRenderState { "" }; + RenderStateMap _renderStates; + DefaultRenderStateMap _defaultRenderStates; bool _faceAvatar; bool _centerEndY; bool _lockEnd; - QPair _objectLockEnd { QPair(QUuid(), false)}; + std::pair _objectLockEnd { std::pair(QUuid(), false)}; QUuid _rayPickUID; void updateRenderStateOverlay(const OverlayID& id, const QVariant& props); void updateRenderState(const RenderState& renderState, const IntersectionType type, const float distance, const QUuid& objectID, const bool defaultState); void disableRenderState(const RenderState& renderState); + }; #endif // hifi_LaserPointer_h diff --git a/interface/src/raypick/LaserPointerManager.cpp b/interface/src/raypick/LaserPointerManager.cpp index 33f292b255..da20068cba 100644 --- a/interface/src/raypick/LaserPointerManager.cpp +++ b/interface/src/raypick/LaserPointerManager.cpp @@ -11,85 +11,87 @@ #include "LaserPointerManager.h" #include "RayPick.h" -QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const QHash& renderStates, QHash>& defaultRenderStates, +QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const LaserPointer::RenderStateMap& renderStates, const LaserPointer::DefaultRenderStateMap& defaultRenderStates, const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled) { std::shared_ptr laserPointer = std::make_shared(rayProps, renderStates, defaultRenderStates, faceAvatar, centerEndY, lockEnd, enabled); if (!laserPointer->getRayUID().isNull()) { - QWriteLocker lock(&_addLock); + WriteLock lock(_addLock); QUuid id = QUuid::createUuid(); - _laserPointersToAdd.enqueue(QPair>(id, laserPointer)); + _laserPointersToAdd.push(std::pair>(id, laserPointer)); return id; } return QUuid(); } void LaserPointerManager::removeLaserPointer(const QUuid uid) { - QWriteLocker lock(&_removeLock); - _laserPointersToRemove.enqueue(uid); + WriteLock lock(_removeLock); + _laserPointersToRemove.push(uid); } void LaserPointerManager::enableLaserPointer(const QUuid uid) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->enable(); } } void LaserPointerManager::disableLaserPointer(const QUuid uid) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->disable(); } } -void LaserPointerManager::setRenderState(QUuid uid, const QString & renderState) { - QReadLocker lock(&_containsLock); +void LaserPointerManager::setRenderState(QUuid uid, const std::string& renderState) { + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setRenderState(renderState); } } -void LaserPointerManager::editRenderState(QUuid uid, const QString& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) { - QReadLocker lock(&_containsLock); +void LaserPointerManager::editRenderState(QUuid uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) { + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->editRenderState(state, startProps, pathProps, endProps); } } const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QReadLocker laserLock(_laserPointerLocks[uid].get()); + ReadLock laserLock(*_laserPointerLocks[uid]); return _laserPointers[uid]->getPrevRayPickResult(); } return RayPickResult(); } void LaserPointerManager::update() { - for (QUuid uid : _laserPointers.keys()) { + for (QUuid& uid : _laserPointers.keys()) { // This only needs to be a read lock because update won't change any of the properties that can be modified from scripts - QReadLocker laserLock(_laserPointerLocks[uid].get()); + ReadLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->update(); } - QWriteLocker containsLock(&_containsLock); + WriteLock containsLock(_containsLock); { - QWriteLocker lock(&_addLock); - while (!_laserPointersToAdd.isEmpty()) { - QPair> laserPointerToAdd = _laserPointersToAdd.dequeue(); + WriteLock lock(_addLock); + while (!_laserPointersToAdd.empty()) { + std::pair> laserPointerToAdd = _laserPointersToAdd.front(); + _laserPointersToAdd.pop(); _laserPointers[laserPointerToAdd.first] = laserPointerToAdd.second; - _laserPointerLocks[laserPointerToAdd.first] = std::make_shared(); + _laserPointerLocks[laserPointerToAdd.first] = std::make_shared(); } } { - QWriteLocker lock(&_removeLock); - while (!_laserPointersToRemove.isEmpty()) { - QUuid uid = _laserPointersToRemove.dequeue(); + WriteLock lock(_removeLock); + while (!_laserPointersToRemove.empty()) { + QUuid uid = _laserPointersToRemove.front(); + _laserPointersToRemove.pop(); _laserPointers.remove(uid); _laserPointerLocks.remove(uid); } @@ -97,57 +99,57 @@ void LaserPointerManager::update() { } void LaserPointerManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIgnoreEntities(ignoreEntities); } } void LaserPointerManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIncludeEntities(includeEntities); } } void LaserPointerManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIgnoreOverlays(ignoreOverlays); } } void LaserPointerManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIncludeOverlays(includeOverlays); } } void LaserPointerManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIgnoreAvatars(ignoreAvatars); } } void LaserPointerManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setIncludeAvatars(includeAvatars); } } void LaserPointerManager::setLockEndUUID(QUuid uid, QUuid objectID, const bool isOverlay) { - QReadLocker lock(&_containsLock); + ReadLock lock(_containsLock); if (_laserPointers.contains(uid)) { - QWriteLocker laserLock(_laserPointerLocks[uid].get()); + WriteLock laserLock(*_laserPointerLocks[uid]); _laserPointers[uid]->setLockEndUUID(objectID, isOverlay); } } diff --git a/interface/src/raypick/LaserPointerManager.h b/interface/src/raypick/LaserPointerManager.h index 002b8ce38e..5e33ac77d8 100644 --- a/interface/src/raypick/LaserPointerManager.h +++ b/interface/src/raypick/LaserPointerManager.h @@ -11,9 +11,8 @@ #ifndef hifi_LaserPointerManager_h #define hifi_LaserPointerManager_h -#include -#include #include +#include #include #include "LaserPointer.h" @@ -23,13 +22,13 @@ class RayPickResult; class LaserPointerManager { public: - QUuid createLaserPointer(const QVariantMap& rayProps, const QHash& renderStates, QHash>& defaultRenderStates, + QUuid createLaserPointer(const QVariantMap& rayProps, const LaserPointer::RenderStateMap& renderStates, const LaserPointer::DefaultRenderStateMap& defaultRenderStates, const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled); void removeLaserPointer(const QUuid uid); void enableLaserPointer(const QUuid uid); void disableLaserPointer(const QUuid uid); - void setRenderState(QUuid uid, const QString& renderState); - void editRenderState(QUuid uid, const QString& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps); + void setRenderState(QUuid uid, const std::string& renderState); + void editRenderState(QUuid uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps); const RayPickResult getPrevRayPickResult(const QUuid uid); void setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities); @@ -45,12 +44,15 @@ public: private: QHash> _laserPointers; - QHash> _laserPointerLocks; - QReadWriteLock _addLock; - QQueue>> _laserPointersToAdd; - QReadWriteLock _removeLock; - QQueue _laserPointersToRemove; - QReadWriteLock _containsLock; + QHash> _laserPointerLocks; + std::shared_mutex _addLock; + std::queue>> _laserPointersToAdd; + std::shared_mutex _removeLock; + std::queue _laserPointersToRemove; + std::shared_mutex _containsLock; + + typedef std::lock_guard WriteLock; + typedef std::shared_lock ReadLock; }; diff --git a/interface/src/raypick/LaserPointerScriptingInterface.cpp b/interface/src/raypick/LaserPointerScriptingInterface.cpp index 78a62d0ed8..9b7f18d436 100644 --- a/interface/src/raypick/LaserPointerScriptingInterface.cpp +++ b/interface/src/raypick/LaserPointerScriptingInterface.cpp @@ -40,30 +40,30 @@ QUuid LaserPointerScriptingInterface::createLaserPointer(const QVariant& propert enabled = propertyMap["enabled"].toBool(); } - QHash renderStates; + LaserPointer::RenderStateMap renderStates; if (propertyMap["renderStates"].isValid()) { QList renderStateVariants = propertyMap["renderStates"].toList(); for (QVariant& renderStateVariant : renderStateVariants) { if (renderStateVariant.isValid()) { QVariantMap renderStateMap = renderStateVariant.toMap(); if (renderStateMap["name"].isValid()) { - QString name = renderStateMap["name"].toString(); + std::string name = renderStateMap["name"].toString().toStdString(); renderStates[name] = buildRenderState(renderStateMap); } } } } - QHash> defaultRenderStates; + LaserPointer::DefaultRenderStateMap defaultRenderStates; if (propertyMap["defaultRenderStates"].isValid()) { QList renderStateVariants = propertyMap["defaultRenderStates"].toList(); for (QVariant& renderStateVariant : renderStateVariants) { if (renderStateVariant.isValid()) { QVariantMap renderStateMap = renderStateVariant.toMap(); if (renderStateMap["name"].isValid() && renderStateMap["distance"].isValid()) { - QString name = renderStateMap["name"].toString(); + std::string name = renderStateMap["name"].toString().toStdString(); float distance = renderStateMap["distance"].toFloat(); - defaultRenderStates[name] = QPair(distance, buildRenderState(renderStateMap)); + defaultRenderStates[name] = std::pair(distance, buildRenderState(renderStateMap)); } } } @@ -90,7 +90,7 @@ void LaserPointerScriptingInterface::editRenderState(QUuid uid, const QString& r endProps = propMap["end"]; } - qApp->getLaserPointerManager().editRenderState(uid, renderState, startProps, pathProps, endProps); + qApp->getLaserPointerManager().editRenderState(uid, renderState.toStdString(), startProps, pathProps, endProps); } const RenderState LaserPointerScriptingInterface::buildRenderState(const QVariantMap& propMap) { diff --git a/interface/src/raypick/LaserPointerScriptingInterface.h b/interface/src/raypick/LaserPointerScriptingInterface.h index 70d2e9a1fd..7866a5da51 100644 --- a/interface/src/raypick/LaserPointerScriptingInterface.h +++ b/interface/src/raypick/LaserPointerScriptingInterface.h @@ -28,7 +28,7 @@ public slots: Q_INVOKABLE void disableLaserPointer(QUuid uid) { qApp->getLaserPointerManager().disableLaserPointer(uid); } Q_INVOKABLE void removeLaserPointer(QUuid uid) { qApp->getLaserPointerManager().removeLaserPointer(uid); } Q_INVOKABLE void editRenderState(QUuid uid, const QString& renderState, const QVariant& properties); - Q_INVOKABLE void setRenderState(QUuid uid, const QString& renderState) { qApp->getLaserPointerManager().setRenderState(uid, renderState); } + Q_INVOKABLE void setRenderState(QUuid uid, const QString& renderState) { qApp->getLaserPointerManager().setRenderState(uid, renderState.toStdString()); } Q_INVOKABLE RayPickResult getPrevRayPickResult(QUuid uid) { return qApp->getLaserPointerManager().getPrevRayPickResult(uid); } Q_INVOKABLE void setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) { qApp->getLaserPointerManager().setIgnoreEntities(uid, ignoreEntities); } diff --git a/interface/src/raypick/MouseRayPick.cpp b/interface/src/raypick/MouseRayPick.cpp index 39dcb74090..de59fde88d 100644 --- a/interface/src/raypick/MouseRayPick.cpp +++ b/interface/src/raypick/MouseRayPick.cpp @@ -14,7 +14,7 @@ #include "Application.h" #include "display-plugins/CompositorHelper.h" -MouseRayPick::MouseRayPick(const uint16_t filter, const float maxDistance, const bool enabled) : +MouseRayPick::MouseRayPick(const RayPickFilter& filter, const float maxDistance, const bool enabled) : RayPick(filter, maxDistance, enabled) { } diff --git a/interface/src/raypick/MouseRayPick.h b/interface/src/raypick/MouseRayPick.h index 84d1c86e24..848a5de336 100644 --- a/interface/src/raypick/MouseRayPick.h +++ b/interface/src/raypick/MouseRayPick.h @@ -16,7 +16,7 @@ class MouseRayPick : public RayPick { public: - MouseRayPick(const uint16_t filter, const float maxDistance = 0.0f, const bool enabled = false); + MouseRayPick(const RayPickFilter& filter, const float maxDistance = 0.0f, const bool enabled = false); const PickRay getPickRay(bool& valid) const override; }; diff --git a/interface/src/raypick/RayPick.cpp b/interface/src/raypick/RayPick.cpp index e807ef23ff..70170a8f85 100644 --- a/interface/src/raypick/RayPick.cpp +++ b/interface/src/raypick/RayPick.cpp @@ -10,7 +10,7 @@ // #include "RayPick.h" -RayPick::RayPick(const uint16_t filter, const float maxDistance, const bool enabled) : +RayPick::RayPick(const RayPickFilter& filter, const float maxDistance, const bool enabled) : _filter(filter), _maxDistance(maxDistance), _enabled(enabled) diff --git a/interface/src/raypick/RayPick.h b/interface/src/raypick/RayPick.h index 48841b9518..e108145d55 100644 --- a/interface/src/raypick/RayPick.h +++ b/interface/src/raypick/RayPick.h @@ -17,17 +17,87 @@ #include "EntityItemID.h" #include "ui/overlays/Overlay.h" +class RayPickFilter { +public: + enum FlagBit { + PICK_NOTHING = 0, + PICK_ENTITIES, + PICK_OVERLAYS, + PICK_AVATARS, + PICK_HUD, + + PICK_COURSE, // if not set, does precise intersection, otherwise, doesn't + + PICK_INCLUDE_INVISIBLE, // if not set, will not intersect invisible elements, otherwise, intersects both visible and invisible elements + PICK_INCLUDE_NONCOLLIDABLE, // if not set, will not intersect noncollidable elements, otherwise, intersects both collidable and noncollidable elements + + // NOT YET IMPLEMENTED + PICK_ALL_INTERSECTIONS, // if not set, returns closest intersection, otherwise, returns list of all intersections + + NUM_FLAGS, // Not a valid flag + }; + typedef std::bitset Flags; + + // The key is the Flags + Flags _flags; + + RayPickFilter() : _flags(PICK_NOTHING) {} + RayPickFilter(const Flags& flags) : _flags(flags) {} + + bool operator== (const RayPickFilter& rhs) const { return _flags == rhs._flags; } + bool operator!= (const RayPickFilter& rhs) const { return _flags != rhs._flags; } + + bool doesPickNothing() const { return _flags[PICK_NOTHING]; } + bool doesPickEntities() const { return _flags[PICK_ENTITIES]; } + bool doesPickOverlays() const { return _flags[PICK_OVERLAYS]; } + bool doesPickAvatars() const { return _flags[PICK_AVATARS]; } + bool doesPickHUD() const { return _flags[PICK_HUD]; } + + bool doesPickCourse() const { return _flags[PICK_COURSE]; } + bool doesPickInvisible() const { return _flags[PICK_INCLUDE_INVISIBLE]; } + bool doesPickNonCollidable() const { return _flags[PICK_INCLUDE_NONCOLLIDABLE]; } + + bool doesWantAllIntersections() const { return _flags[PICK_ALL_INTERSECTIONS]; } + + // Helpers for RayPickManager + Flags getEntityFlags() const { + Flags toReturn(PICK_ENTITIES); + if (doesPickInvisible()) { + toReturn |= Flags(PICK_INCLUDE_INVISIBLE); + } + if (doesPickNonCollidable()) { + toReturn |= Flags(PICK_INCLUDE_NONCOLLIDABLE); + } + return toReturn; + } + Flags getOverlayFlags() const { + Flags toReturn(PICK_OVERLAYS); + if (doesPickInvisible()) { + toReturn |= Flags(PICK_INCLUDE_INVISIBLE); + } + if (doesPickNonCollidable()) { + toReturn |= Flags(PICK_INCLUDE_NONCOLLIDABLE); + } + return toReturn; + } + Flags getAvatarFlags() const { return Flags(PICK_AVATARS); } + Flags getHUDFlags() const { return Flags(PICK_HUD); } + + static unsigned int getBitMask(FlagBit bit) { return 1 << bit; } + +}; + class RayPick { public: - RayPick(const uint16_t filter, const float maxDistance, const bool enabled); + RayPick(const RayPickFilter& filter, const float maxDistance, const bool enabled); virtual const PickRay getPickRay(bool& valid) const = 0; void enable() { _enabled = true; } void disable() { _enabled = false; } - const uint16_t& getFilter() { return _filter; } + const RayPickFilter& getFilter() { return _filter; } const float& getMaxDistance() { return _maxDistance; } const bool& isEnabled() { return _enabled; } const RayPickResult& getPrevRayPickResult() { return _prevResult; } @@ -48,7 +118,7 @@ public: void setIncludeAvatars(const QScriptValue& includeAvatars) { _includeAvatars = qVectorEntityItemIDFromScriptValue(includeAvatars); } private: - uint16_t _filter; + RayPickFilter _filter; float _maxDistance; bool _enabled; RayPickResult _prevResult; diff --git a/interface/src/raypick/RayPickManager.cpp b/interface/src/raypick/RayPickManager.cpp index f7f22a66bb..0fe7fdb823 100644 --- a/interface/src/raypick/RayPickManager.cpp +++ b/interface/src/raypick/RayPickManager.cpp @@ -10,8 +10,6 @@ // #include "RayPickManager.h" -#include "RayPick.h" - #include "Application.h" #include "EntityScriptingInterface.h" #include "ui/overlays/Overlays.h" @@ -23,8 +21,8 @@ #include "StaticRayPick.h" #include "MouseRayPick.h" -bool RayPickManager::checkAndCompareCachedResults(QPair& ray, RayPickCache& cache, RayPickResult& res, unsigned int mask) { - if (cache.contains(ray) && cache[ray].contains(mask)) { +bool RayPickManager::checkAndCompareCachedResults(QPair& ray, RayPickCache& cache, RayPickResult& res, const RayPickFilter::Flags& mask) { + if (cache.contains(ray) && cache[ray].find(mask) != cache[ray].end()) { if (cache[ray][mask].distance < res.distance) { res = cache[ray][mask]; } @@ -33,7 +31,7 @@ bool RayPickManager::checkAndCompareCachedResults(QPair& r return false; } -void RayPickManager::cacheResult(const bool intersects, const RayPickResult& resTemp, unsigned int mask, RayPickResult& res, QPair& ray, RayPickCache& cache) { +void RayPickManager::cacheResult(const bool intersects, const RayPickResult& resTemp, const RayPickFilter::Flags& mask, RayPickResult& res, QPair& ray, RayPickCache& cache) { if (intersects) { cache[ray][mask] = resTemp; if (resTemp.distance < res.distance) { @@ -48,7 +46,7 @@ void RayPickManager::update() { RayPickCache results; for (auto& uid : _rayPicks.keys()) { std::shared_ptr rayPick = _rayPicks[uid]; - if (!rayPick->isEnabled() || rayPick->getFilter() == RayPickMask::PICK_NOTHING || rayPick->getMaxDistance() < 0.0f) { + if (!rayPick->isEnabled() || rayPick->getFilter().doesPickNothing() || rayPick->getMaxDistance() < 0.0f) { continue; } @@ -62,12 +60,12 @@ void RayPickManager::update() { QPair rayKey = QPair(ray.origin, ray.direction); RayPickResult res; - if (rayPick->getFilter() & RayPickMask::PICK_ENTITIES) { + if (rayPick->getFilter().doesPickEntities()) { RayToEntityIntersectionResult entityRes; bool fromCache = true; - unsigned int invisible = rayPick->getFilter() & RayPickMask::PICK_INCLUDE_INVISIBLE; - unsigned int noncollidable = rayPick->getFilter() & RayPickMask::PICK_INCLUDE_NONCOLLIDABLE; - unsigned int entityMask = RayPickMask::PICK_ENTITIES | invisible | noncollidable; + bool invisible = rayPick->getFilter().doesPickInvisible(); + bool noncollidable = rayPick->getFilter().doesPickNonCollidable(); + RayPickFilter::Flags entityMask = rayPick->getFilter().getEntityFlags(); if (!checkAndCompareCachedResults(rayKey, results, res, entityMask)) { entityRes = DependencyManager::get()->findRayIntersection(ray, true, rayPick->getIncludeEntites(), rayPick->getIgnoreEntites(), !invisible, !noncollidable); fromCache = false; @@ -79,12 +77,12 @@ void RayPickManager::update() { } } - if (rayPick->getFilter() & RayPickMask::PICK_OVERLAYS) { + if (rayPick->getFilter().doesPickOverlays()) { RayToOverlayIntersectionResult overlayRes; bool fromCache = true; - unsigned int invisible = rayPick->getFilter() & RayPickMask::PICK_INCLUDE_INVISIBLE; - unsigned int noncollidable = rayPick->getFilter() & RayPickMask::PICK_INCLUDE_NONCOLLIDABLE; - unsigned int overlayMask = RayPickMask::PICK_OVERLAYS | invisible | noncollidable; + bool invisible = rayPick->getFilter().doesPickInvisible(); + bool noncollidable = rayPick->getFilter().doesPickNonCollidable(); + RayPickFilter::Flags overlayMask = rayPick->getFilter().getOverlayFlags(); if (!checkAndCompareCachedResults(rayKey, results, res, overlayMask)) { overlayRes = qApp->getOverlays().findRayIntersection(ray, true, rayPick->getIncludeOverlays(), rayPick->getIgnoreOverlays(), !invisible, !noncollidable); fromCache = false; @@ -96,22 +94,24 @@ void RayPickManager::update() { } } - if (rayPick->getFilter() & RayPickMask::PICK_AVATARS) { - if (!checkAndCompareCachedResults(rayKey, results, res, RayPickMask::PICK_AVATARS)) { + if (rayPick->getFilter().doesPickAvatars()) { + RayPickFilter::Flags avatarMask = rayPick->getFilter().getAvatarFlags(); + if (!checkAndCompareCachedResults(rayKey, results, res, avatarMask)) { RayToAvatarIntersectionResult avatarRes = DependencyManager::get()->findRayIntersection(ray, rayPick->getIncludeAvatars(), rayPick->getIgnoreAvatars()); - cacheResult(avatarRes.intersects, RayPickResult(IntersectionType::AVATAR, avatarRes.avatarID, avatarRes.distance, avatarRes.intersection), RayPickMask::PICK_AVATARS, res, rayKey, results); + cacheResult(avatarRes.intersects, RayPickResult(IntersectionType::AVATAR, avatarRes.avatarID, avatarRes.distance, avatarRes.intersection), avatarMask, res, rayKey, results); } } // Can't intersect with HUD in desktop mode - if (rayPick->getFilter() & RayPickMask::PICK_HUD && DependencyManager::get()->isHMDMode()) { - if (!checkAndCompareCachedResults(rayKey, results, res, RayPickMask::PICK_HUD)) { + if (rayPick->getFilter().doesPickHUD() && DependencyManager::get()->isHMDMode()) { + RayPickFilter::Flags hudMask = rayPick->getFilter().getHUDFlags(); + if (!checkAndCompareCachedResults(rayKey, results, res, hudMask)) { glm::vec3 hudRes = DependencyManager::get()->calculateRayUICollisionPoint(ray.origin, ray.direction); - cacheResult(true, RayPickResult(IntersectionType::HUD, 0, glm::distance(ray.origin, hudRes), hudRes), RayPickMask::PICK_HUD, res, rayKey, results); + cacheResult(true, RayPickResult(IntersectionType::HUD, 0, glm::distance(ray.origin, hudRes), hudRes), hudMask, res, rayKey, results); } } - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); if (rayPick->getMaxDistance() == 0.0f || (rayPick->getMaxDistance() > 0.0f && res.distance < rayPick->getMaxDistance())) { rayPick->setRayPickResult(res); } else { @@ -119,20 +119,22 @@ void RayPickManager::update() { } } - QWriteLocker containsLock(&_containsLock); + WriteLock containsLock(_containsLock); { - QWriteLocker lock(&_addLock); - while (!_rayPicksToAdd.isEmpty()) { - QPair> rayPickToAdd = _rayPicksToAdd.dequeue(); + WriteLock lock(_addLock); + while (!_rayPicksToAdd.empty()) { + std::pair> rayPickToAdd = _rayPicksToAdd.front(); + _rayPicksToAdd.pop(); _rayPicks[rayPickToAdd.first] = rayPickToAdd.second; - _rayPickLocks[rayPickToAdd.first] = std::make_shared(); + _rayPickLocks[rayPickToAdd.first] = std::make_shared(); } } { - QWriteLocker lock(&_removeLock); - while (!_rayPicksToRemove.isEmpty()) { - QUuid uid = _rayPicksToRemove.dequeue(); + WriteLock lock(_removeLock); + while (!_rayPicksToRemove.empty()) { + QUuid uid = _rayPicksToRemove.front(); + _rayPicksToRemove.pop(); _rayPicks.remove(uid); _rayPickLocks.remove(uid); } @@ -145,9 +147,9 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) { enabled = rayProps["enabled"].toBool(); } - uint16_t filter = 0; + RayPickFilter filter = RayPickFilter(); if (rayProps["filter"].isValid()) { - filter = rayProps["filter"].toUInt(); + filter = RayPickFilter(rayProps["filter"].toUInt()); } float maxDistance = 0.0f; @@ -156,7 +158,7 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) { } if (rayProps["joint"].isValid()) { - QString jointName = rayProps["joint"].toString(); + std::string jointName = rayProps["joint"].toString().toStdString(); if (jointName != "Mouse") { // x = upward, y = forward, z = lateral @@ -170,14 +172,14 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) { dirOffset = vec3FromVariant(rayProps["dirOffset"]); } - QWriteLocker lock(&_addLock); + WriteLock lock(_addLock); QUuid id = QUuid::createUuid(); - _rayPicksToAdd.enqueue(QPair>(id, std::make_shared(jointName, posOffset, dirOffset, filter, maxDistance, enabled))); + _rayPicksToAdd.push(std::pair>(id, std::make_shared(jointName, posOffset, dirOffset, filter, maxDistance, enabled))); return id; } else { - QWriteLocker lock(&_addLock); + WriteLock lock(_addLock); QUuid id = QUuid::createUuid(); - _rayPicksToAdd.enqueue(QPair>(id, std::make_shared(filter, maxDistance, enabled))); + _rayPicksToAdd.push(std::pair>(id, std::make_shared(filter, maxDistance, enabled))); return id; } } else if (rayProps["position"].isValid()) { @@ -188,9 +190,9 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) { direction = vec3FromVariant(rayProps["direction"]); } - QWriteLocker lock(&_addLock); + WriteLock lock(_addLock); QUuid id = QUuid::createUuid(); - _rayPicksToAdd.enqueue(QPair>(id, std::make_shared(position, direction, filter, maxDistance, enabled))); + _rayPicksToAdd.push(std::pair>(id, std::make_shared(position, direction, filter, maxDistance, enabled))); return id; } @@ -198,28 +200,28 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) { } void RayPickManager::removeRayPick(const QUuid uid) { - QWriteLocker lock(&_removeLock); - _rayPicksToRemove.enqueue(uid); + WriteLock lock(_removeLock); + _rayPicksToRemove.push(uid); } void RayPickManager::enableRayPick(const QUuid uid) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker rayPickLock(_rayPickLocks[uid].get()); + WriteLock rayPickLock(*_rayPickLocks[uid]); _rayPicks[uid]->enable(); } } void RayPickManager::disableRayPick(const QUuid uid) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker rayPickLock(_rayPickLocks[uid].get()); + WriteLock rayPickLock(*_rayPickLocks[uid]); _rayPicks[uid]->disable(); } } const PickRay RayPickManager::getPickRay(const QUuid uid) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { bool valid; PickRay pickRay = _rayPicks[uid]->getPickRay(valid); @@ -231,58 +233,58 @@ const PickRay RayPickManager::getPickRay(const QUuid uid) { } const RayPickResult RayPickManager::getPrevRayPickResult(const QUuid uid) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QReadLocker lock(_rayPickLocks[uid].get()); + ReadLock lock(*_rayPickLocks[uid]); return _rayPicks[uid]->getPrevRayPickResult(); } return RayPickResult(); } void RayPickManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIgnoreEntities(ignoreEntities); } } void RayPickManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIncludeEntities(includeEntities); } } void RayPickManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIgnoreOverlays(ignoreOverlays); } } void RayPickManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIncludeOverlays(includeOverlays); } } void RayPickManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIgnoreAvatars(ignoreAvatars); } } void RayPickManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) { - QReadLocker containsLock(&_containsLock); + ReadLock containsLock(_containsLock); if (_rayPicks.contains(uid)) { - QWriteLocker lock(_rayPickLocks[uid].get()); + WriteLock lock(*_rayPickLocks[uid]); _rayPicks[uid]->setIncludeAvatars(includeAvatars); } } \ No newline at end of file diff --git a/interface/src/raypick/RayPickManager.h b/interface/src/raypick/RayPickManager.h index 592541e7cf..9055e060ef 100644 --- a/interface/src/raypick/RayPickManager.h +++ b/interface/src/raypick/RayPickManager.h @@ -11,35 +11,20 @@ #ifndef hifi_RayPickManager_h #define hifi_RayPickManager_h -#include -#include -#include +#include "RayPick.h" + #include +#include #include #include "RegisteredMetaTypes.h" #include "DependencyManager.h" -class RayPick; +#include +#include + class RayPickResult; -enum RayPickMask { - PICK_NOTHING = 0, - PICK_ENTITIES = 1 << 0, - PICK_OVERLAYS = 1 << 1, - PICK_AVATARS = 1 << 2, - PICK_HUD = 1 << 3, - - // NOT YET IMPLEMENTED - PICK_BOUNDING_BOX = 1 << 4, // if not set, picks again physics mesh (can't pick against graphics mesh, yet) - - PICK_INCLUDE_INVISIBLE = 1 << 5, // if not set, will not intersect invisible elements, otherwise, intersects both visible and invisible elements - PICK_INCLUDE_NONCOLLIDABLE = 1 << 6, // if not set, will not intersect noncollidable elements, otherwise, intersects both collidable and noncollidable elements - - // NOT YET IMPLEMENTED - PICK_ALL_INTERSECTIONS = 1 << 7 // if not set, returns closest intersection, otherwise, returns list of all intersections -}; - class RayPickManager : public QObject, public Dependency { Q_OBJECT Q_PROPERTY(unsigned int PICK_NOTHING READ PICK_NOTHING CONSTANT) @@ -78,34 +63,37 @@ public slots: private: QHash> _rayPicks; - QHash> _rayPickLocks; - QReadWriteLock _addLock; - QQueue>> _rayPicksToAdd; - QReadWriteLock _removeLock; - QQueue _rayPicksToRemove; - QReadWriteLock _containsLock; + QHash> _rayPickLocks; + std::shared_mutex _addLock; + std::queue>> _rayPicksToAdd; + std::shared_mutex _removeLock; + std::queue _rayPicksToRemove; + std::shared_mutex _containsLock; - typedef QHash, QHash> RayPickCache; + typedef QHash, std::unordered_map> RayPickCache; // Returns true if this ray exists in the cache, and if it does, update res if the cached result is closer - bool checkAndCompareCachedResults(QPair& ray, RayPickCache& cache, RayPickResult& res, unsigned int mask); - void cacheResult(const bool intersects, const RayPickResult& resTemp, unsigned int mask, RayPickResult& res, QPair& ray, RayPickCache& cache); + bool checkAndCompareCachedResults(QPair& ray, RayPickCache& cache, RayPickResult& res, const RayPickFilter::Flags& mask); + void cacheResult(const bool intersects, const RayPickResult& resTemp, const RayPickFilter::Flags& mask, RayPickResult& res, QPair& ray, RayPickCache& cache); - unsigned int PICK_NOTHING() { return RayPickMask::PICK_NOTHING; } - unsigned int PICK_ENTITIES() { return RayPickMask::PICK_ENTITIES; } - unsigned int PICK_OVERLAYS() { return RayPickMask::PICK_OVERLAYS; } - unsigned int PICK_AVATARS() { return RayPickMask::PICK_AVATARS; } - unsigned int PICK_HUD() { return RayPickMask::PICK_HUD; } - unsigned int PICK_BOUNDING_BOX() { return RayPickMask::PICK_BOUNDING_BOX; } - unsigned int PICK_INCLUDE_INVISIBLE() { return RayPickMask::PICK_INCLUDE_INVISIBLE; } - unsigned int PICK_INCLUDE_NONCOLLIDABLE() { return RayPickMask::PICK_INCLUDE_NONCOLLIDABLE; } - unsigned int PICK_ALL_INTERSECTIONS() { return RayPickMask::PICK_ALL_INTERSECTIONS; } + unsigned int PICK_NOTHING() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_NOTHING); } + unsigned int PICK_ENTITIES() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_ENTITIES); } + unsigned int PICK_OVERLAYS() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_OVERLAYS); } + unsigned int PICK_AVATARS() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_AVATARS); } + unsigned int PICK_HUD() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_HUD); } + unsigned int PICK_BOUNDING_BOX() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_COURSE); } + unsigned int PICK_INCLUDE_INVISIBLE() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_INCLUDE_INVISIBLE); } + unsigned int PICK_INCLUDE_NONCOLLIDABLE() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_INCLUDE_NONCOLLIDABLE); } + unsigned int PICK_ALL_INTERSECTIONS() { return RayPickFilter::getBitMask(RayPickFilter::FlagBit::PICK_ALL_INTERSECTIONS); } unsigned int INTERSECTED_NONE() { return IntersectionType::NONE; } unsigned int INTERSECTED_ENTITY() { return IntersectionType::ENTITY; } unsigned int INTERSECTED_OVERLAY() { return IntersectionType::OVERLAY; } unsigned int INTERSECTED_AVATAR() { return IntersectionType::AVATAR; } unsigned int INTERSECTED_HUD() { return IntersectionType::HUD; } + typedef std::lock_guard WriteLock; + typedef std::shared_lock ReadLock; + }; #endif // hifi_RayPickManager_h \ No newline at end of file diff --git a/interface/src/raypick/StaticRayPick.cpp b/interface/src/raypick/StaticRayPick.cpp index 43088150ad..89bcddb3df 100644 --- a/interface/src/raypick/StaticRayPick.cpp +++ b/interface/src/raypick/StaticRayPick.cpp @@ -10,7 +10,7 @@ // #include "StaticRayPick.h" -StaticRayPick::StaticRayPick(const glm::vec3& position, const glm::vec3& direction, const uint16_t filter, const float maxDistance, const bool enabled) : +StaticRayPick::StaticRayPick(const glm::vec3& position, const glm::vec3& direction, const RayPickFilter& filter, const float maxDistance, const bool enabled) : RayPick(filter, maxDistance, enabled), _pickRay(position, direction) { diff --git a/interface/src/raypick/StaticRayPick.h b/interface/src/raypick/StaticRayPick.h index 05ff4ef397..fc09ee6a27 100644 --- a/interface/src/raypick/StaticRayPick.h +++ b/interface/src/raypick/StaticRayPick.h @@ -16,7 +16,7 @@ class StaticRayPick : public RayPick { public: - StaticRayPick(const glm::vec3& position, const glm::vec3& direction, const uint16_t filter, const float maxDistance = 0.0f, const bool enabled = false); + StaticRayPick(const glm::vec3& position, const glm::vec3& direction, const RayPickFilter& filter, const float maxDistance = 0.0f, const bool enabled = false); const PickRay getPickRay(bool& valid) const override;