Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-20 11:45:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

just kidding shared_mutexes are c++17

Browse source
This commit is contained in:
SamGondelman 2017-08-11 10:07:20 -07:00
parent 4c55849290
commit f058781f49
4 changed files with 69 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
interface/src/raypick/LaserPointerManager.cpp
View file

@ -15,7 +15,7 @@ QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const
const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled) {
std::shared_ptr<LaserPointer> laserPointer = std::make_shared<LaserPointer>(rayProps, renderStates, defaultRenderStates, faceAvatar, centerEndY, lockEnd, enabled);
if (!laserPointer->getRayUID().isNull()) {
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
QUuid id = QUuid::createUuid();
_laserPointersToAdd.push(std::pair<QUuid, std::shared_ptr<LaserPointer>>(id, laserPointer));
return id;
@ -24,46 +24,46 @@ QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const
}
void LaserPointerManager::removeLaserPointer(const QUuid uid) {
WriteLock lock(_removeLock);
QWriteLocker lock(&_removeLock);
_laserPointersToRemove.push(uid);
}
void LaserPointerManager::enableLaserPointer(const QUuid uid) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->enable();
}
}
void LaserPointerManager::disableLaserPointer(const QUuid uid) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->disable();
}
}
void LaserPointerManager::setRenderState(QUuid uid, const std::string& renderState) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setRenderState(renderState);
}
}
void LaserPointerManager::editRenderState(QUuid uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->editRenderState(state, startProps, pathProps, endProps);
}
}
const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
ReadLock laserLock(*_laserPointerLocks[uid]);
QReadLocker laserLock(_laserPointerLocks[uid].get());
return _laserPointers[uid]->getPrevRayPickResult();
}
return RayPickResult();
@ -72,23 +72,23 @@ const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
void LaserPointerManager::update() {
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
ReadLock laserLock(*_laserPointerLocks[uid]);
QReadLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->update();
}
WriteLock containsLock(_containsLock);
QWriteLocker containsLock(&_containsLock);
{
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
while (!_laserPointersToAdd.empty()) {
std::pair<QUuid, std::shared_ptr<LaserPointer>> laserPointerToAdd = _laserPointersToAdd.front();
_laserPointersToAdd.pop();
_laserPointers[laserPointerToAdd.first] = laserPointerToAdd.second;
_laserPointerLocks[laserPointerToAdd.first] = std::make_shared<std::shared_mutex>();
_laserPointerLocks[laserPointerToAdd.first] = std::make_shared<QReadWriteLock>();
}
}
{
WriteLock lock(_removeLock);
QWriteLocker lock(&_removeLock);
while (!_laserPointersToRemove.empty()) {
QUuid uid = _laserPointersToRemove.front();
_laserPointersToRemove.pop();
@ -99,57 +99,57 @@ void LaserPointerManager::update() {
}
void LaserPointerManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIgnoreEntities(ignoreEntities);
}
}
void LaserPointerManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIncludeEntities(includeEntities);
}
}
void LaserPointerManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIgnoreOverlays(ignoreOverlays);
}
}
void LaserPointerManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIncludeOverlays(includeOverlays);
}
}
void LaserPointerManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIgnoreAvatars(ignoreAvatars);
}
}
void LaserPointerManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setIncludeAvatars(includeAvatars);
}
}
void LaserPointerManager::setLockEndUUID(QUuid uid, QUuid objectID, const bool isOverlay) {
ReadLock lock(_containsLock);
QReadLocker lock(&_containsLock);
if (_laserPointers.contains(uid)) {
WriteLock laserLock(*_laserPointerLocks[uid]);
QWriteLocker laserLock(_laserPointerLocks[uid].get());
_laserPointers[uid]->setLockEndUUID(objectID, isOverlay);
}
}

13
interface/src/raypick/LaserPointerManager.h
View file

@ -12,8 +12,8 @@
#define hifi_LaserPointerManager_h
#include <memory>
#include <shared_mutex>
#include <glm/glm.hpp>
#include <QReadWriteLock>
#include "LaserPointer.h"
@ -44,15 +44,12 @@ public:
private:
QHash<QUuid, std::shared_ptr<LaserPointer>> _laserPointers;
QHash<QUuid, std::shared_ptr<std::shared_mutex>> _laserPointerLocks;
std::shared_mutex _addLock;
QHash<QUuid, std::shared_ptr<QReadWriteLock>> _laserPointerLocks;
QReadWriteLock _addLock;
std::queue<std::pair<QUuid, std::shared_ptr<LaserPointer>>> _laserPointersToAdd;
std::shared_mutex _removeLock;
QReadWriteLock _removeLock;
std::queue<QUuid> _laserPointersToRemove;
std::shared_mutex _containsLock;
typedef std::lock_guard<std::shared_mutex> WriteLock;
typedef std::shared_lock<std::shared_mutex> ReadLock;
QReadWriteLock _containsLock;
};

56
interface/src/raypick/RayPickManager.cpp
View file

@ -111,7 +111,7 @@ void RayPickManager::update() {
}
}
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
if (rayPick->getMaxDistance() == 0.0f || (rayPick->getMaxDistance() > 0.0f && res.distance < rayPick->getMaxDistance())) {
rayPick->setRayPickResult(res);
} else {
@ -119,19 +119,19 @@ void RayPickManager::update() {
}
}
WriteLock containsLock(_containsLock);
QWriteLocker containsLock(&_containsLock);
{
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
while (!_rayPicksToAdd.empty()) {
std::pair<QUuid, std::shared_ptr<RayPick>> rayPickToAdd = _rayPicksToAdd.front();
_rayPicksToAdd.pop();
_rayPicks[rayPickToAdd.first] = rayPickToAdd.second;
_rayPickLocks[rayPickToAdd.first] = std::make_shared<std::shared_mutex>();
_rayPickLocks[rayPickToAdd.first] = std::make_shared<QReadWriteLock>();
}
}
{
WriteLock lock(_removeLock);
QWriteLocker lock(&_removeLock);
while (!_rayPicksToRemove.empty()) {
QUuid uid = _rayPicksToRemove.front();
_rayPicksToRemove.pop();
@ -172,12 +172,12 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
dirOffset = vec3FromVariant(rayProps["dirOffset"]);
}
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
QUuid id = QUuid::createUuid();
_rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<JointRayPick>(jointName, posOffset, dirOffset, filter, maxDistance, enabled)));
return id;
} else {
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
QUuid id = QUuid::createUuid();
_rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<MouseRayPick>(filter, maxDistance, enabled)));
return id;
@ -190,7 +190,7 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
direction = vec3FromVariant(rayProps["direction"]);
}
WriteLock lock(_addLock);
QWriteLocker lock(&_addLock);
QUuid id = QUuid::createUuid();
_rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<StaticRayPick>(position, direction, filter, maxDistance, enabled)));
return id;
@ -200,28 +200,28 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
}
void RayPickManager::removeRayPick(const QUuid uid) {
WriteLock lock(_removeLock);
QWriteLocker lock(&_removeLock);
_rayPicksToRemove.push(uid);
}
void RayPickManager::enableRayPick(const QUuid uid) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock rayPickLock(*_rayPickLocks[uid]);
QWriteLocker rayPickLock(_rayPickLocks[uid].get());
_rayPicks[uid]->enable();
}
}
void RayPickManager::disableRayPick(const QUuid uid) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock rayPickLock(*_rayPickLocks[uid]);
QWriteLocker rayPickLock(_rayPickLocks[uid].get());
_rayPicks[uid]->disable();
}
}
const PickRay RayPickManager::getPickRay(const QUuid uid) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
bool valid;
PickRay pickRay = _rayPicks[uid]->getPickRay(valid);
@ -233,58 +233,58 @@ const PickRay RayPickManager::getPickRay(const QUuid uid) {
}
const RayPickResult RayPickManager::getPrevRayPickResult(const QUuid uid) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
ReadLock lock(*_rayPickLocks[uid]);
QReadLocker lock(_rayPickLocks[uid].get());
return _rayPicks[uid]->getPrevRayPickResult();
}
return RayPickResult();
}
void RayPickManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIgnoreEntities(ignoreEntities);
}
}
void RayPickManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIncludeEntities(includeEntities);
}
}
void RayPickManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIgnoreOverlays(ignoreOverlays);
}
}
void RayPickManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIncludeOverlays(includeOverlays);
}
}
void RayPickManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIgnoreAvatars(ignoreAvatars);
}
}
void RayPickManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
ReadLock containsLock(_containsLock);
QReadLocker containsLock(&_containsLock);
if (_rayPicks.contains(uid)) {
WriteLock lock(*_rayPickLocks[uid]);
QWriteLocker lock(_rayPickLocks[uid].get());
_rayPicks[uid]->setIncludeAvatars(includeAvatars);
}
}

13
interface/src/raypick/RayPickManager.h
View file

@ -14,8 +14,8 @@
#include "RayPick.h"
#include <memory>
#include <shared_mutex>
#include <QtCore/QObject>
#include <QReadWriteLock>
#include "RegisteredMetaTypes.h"
#include "DependencyManager.h"
@ -63,12 +63,12 @@ public slots:
private:
QHash<QUuid, std::shared_ptr<RayPick>> _rayPicks;
QHash<QUuid, std::shared_ptr<std::shared_mutex>> _rayPickLocks;
std::shared_mutex _addLock;
QHash<QUuid, std::shared_ptr<QReadWriteLock>> _rayPickLocks;
QReadWriteLock _addLock;
std::queue<std::pair<QUuid, std::shared_ptr<RayPick>>> _rayPicksToAdd;
std::shared_mutex _removeLock;
QReadWriteLock _removeLock;
std::queue<QUuid> _rayPicksToRemove;
std::shared_mutex _containsLock;
QReadWriteLock _containsLock;
typedef QHash<QPair<glm::vec3, glm::vec3>, std::unordered_map<RayPickFilter::Flags, RayPickResult>> RayPickCache;
@ -91,9 +91,6 @@ private:
unsigned int INTERSECTED_AVATAR() { return IntersectionType::AVATAR; }
unsigned int INTERSECTED_HUD() { return IntersectionType::HUD; }
typedef std::lock_guard<std::shared_mutex> WriteLock;
typedef std::shared_lock<std::shared_mutex> ReadLock;
};
#endif // hifi_RayPickManager_h