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

replace ids with unsigned ints

Browse source
This commit is contained in:
SamGondelman 2017-10-31 17:07:48 -07:00
parent 3c779f1528
commit 64665c87b2
21 changed files with 176 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
interface/src/Application.cpp
View file

@ -1821,7 +1821,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
// Setup the mouse ray pick and related operators
DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickID(DependencyManager::get<PickManager>()->addPick(PickQuery::Ray, std::make_shared<MouseRayPick>(
PickFilter(PickScriptingInterface::PICK_ENTITIES() | PickScriptingInterface::PICK_INCLUDE_NONCOLLIDABLE()), 0.0f, true)));
DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickResultOperator([&](QUuid rayPickID) {
DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickResultOperator([&](unsigned int rayPickID) {
RayToEntityIntersectionResult entityResult;
entityResult.intersects = false;
QVariantMap result = DependencyManager::get<PickManager>()->getPrevPickResult(rayPickID);
@ -1837,7 +1837,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
}
return entityResult;
});
DependencyManager::get<EntityTreeRenderer>()->setSetPrecisionPickingOperator([&](QUuid rayPickID, bool value) {
DependencyManager::get<EntityTreeRenderer>()->setSetPrecisionPickingOperator([&](unsigned int rayPickID, bool value) {
DependencyManager::get<PickManager>()->setPrecisionPicking(rayPickID, value);
});

3
interface/src/raypick/LaserPointer.cpp
View file

@ -282,7 +282,6 @@ RenderState LaserPointer::buildRenderState(const QVariantMap& propMap) {
}
PointerEvent LaserPointer::buildPointerEvent(const PickedObject& target, const QVariantMap& pickResult) const {
uint32_t id = 0;
glm::vec3 intersection = vec3FromVariant(pickResult["intersection"]);
glm::vec3 surfaceNormal = vec3FromVariant(pickResult["surfaceNormal"]);
QVariantMap searchRay = pickResult["searchRay"].toMap();
@ -304,7 +303,7 @@ PointerEvent LaserPointer::buildPointerEvent(const PickedObject& target, const Q
} else if (target.type == HUD) {
pos2D = DependencyManager::get<PickManager>()->calculatePos2DFromHUD(intersection);
}
return PointerEvent(PointerEvent::Move, id, pos2D, intersection, surfaceNormal, direction, PointerEvent::NoButtons);
return PointerEvent(PointerEvent::Move, 0, pos2D, intersection, surfaceNormal, direction, PointerEvent::NoButtons);
}
glm::vec3 LaserPointer::intersectRayWithXYPlane(const glm::vec3& origin, const glm::vec3& direction, const glm::vec3& point, const glm::quat rotation, const glm::vec3& registration) const {

8
interface/src/raypick/LaserPointerScriptingInterface.cpp
View file

@ -14,17 +14,17 @@
#include "RegisteredMetaTypes.h"
#include "PointerScriptingInterface.h"
void LaserPointerScriptingInterface::setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreItems) const {
void LaserPointerScriptingInterface::setIgnoreItems(unsigned int uid, const QScriptValue& ignoreItems) const {
DependencyManager::get<PointerManager>()->setIgnoreItems(uid, qVectorQUuidFromScriptValue(ignoreItems));
}
void LaserPointerScriptingInterface::setIncludeItems(const QUuid& uid, const QScriptValue& includeItems) const {
void LaserPointerScriptingInterface::setIncludeItems(unsigned int uid, const QScriptValue& includeItems) const {
DependencyManager::get<PointerManager>()->setIncludeItems(uid, qVectorQUuidFromScriptValue(includeItems));
}
QUuid LaserPointerScriptingInterface::createLaserPointer(const QVariant& properties) const {
unsigned int LaserPointerScriptingInterface::createLaserPointer(const QVariant& properties) const {
return DependencyManager::get<PointerScriptingInterface>()->createLaserPointer(properties);
}
void LaserPointerScriptingInterface::editRenderState(const QUuid& uid, const QString& renderState, const QVariant& properties) const {
void LaserPointerScriptingInterface::editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const {
DependencyManager::get<PointerScriptingInterface>()->editRenderState(uid, renderState, properties);
}

24
interface/src/raypick/LaserPointerScriptingInterface.h
View file

@ -21,20 +21,20 @@ class LaserPointerScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public slots:
Q_INVOKABLE QUuid createLaserPointer(const QVariant& properties) const;
Q_INVOKABLE void enableLaserPointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->enablePointer(uid); }
Q_INVOKABLE void disableLaserPointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->disablePointer(uid); }
Q_INVOKABLE void removeLaserPointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->removePointer(uid); }
Q_INVOKABLE void editRenderState(const QUuid& uid, const QString& renderState, const QVariant& properties) const;
Q_INVOKABLE void setRenderState(const QUuid& uid, const QString& renderState) const { DependencyManager::get<PointerManager>()->setRenderState(uid, renderState.toStdString()); }
Q_INVOKABLE QVariantMap getPrevRayPickResult(QUuid uid) const { return DependencyManager::get<PointerManager>()->getPrevPickResult(uid); }
Q_INVOKABLE unsigned int createLaserPointer(const QVariant& properties) const;
Q_INVOKABLE void enableLaserPointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->enablePointer(uid); }
Q_INVOKABLE void disableLaserPointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->disablePointer(uid); }
Q_INVOKABLE void removeLaserPointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->removePointer(uid); }
Q_INVOKABLE void editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const;
Q_INVOKABLE void setRenderState(unsigned int uid, const QString& renderState) const { DependencyManager::get<PointerManager>()->setRenderState(uid, renderState.toStdString()); }
Q_INVOKABLE QVariantMap getPrevRayPickResult(unsigned int uid) const { return DependencyManager::get<PointerManager>()->getPrevPickResult(uid); }
Q_INVOKABLE void setPrecisionPicking(const QUuid& uid, bool precisionPicking) const { DependencyManager::get<PointerManager>()->setPrecisionPicking(uid, precisionPicking); }
Q_INVOKABLE void setLaserLength(const QUuid& uid, float laserLength) const { DependencyManager::get<PointerManager>()->setLength(uid, laserLength); }
Q_INVOKABLE void setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreEntities) const;
Q_INVOKABLE void setIncludeItems(const QUuid& uid, const QScriptValue& includeEntities) const;
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking) const { DependencyManager::get<PointerManager>()->setPrecisionPicking(uid, precisionPicking); }
Q_INVOKABLE void setLaserLength(unsigned int uid, float laserLength) const { DependencyManager::get<PointerManager>()->setLength(uid, laserLength); }
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities) const;
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities) const;
Q_INVOKABLE void setLockEndUUID(const QUuid& uid, const QUuid& objectID, bool isOverlay) const { DependencyManager::get<PointerManager>()->setLockEndUUID(uid, objectID, isOverlay); }
Q_INVOKABLE void setLockEndUUID(unsigned int uid, const QUuid& objectID, bool isOverlay) const { DependencyManager::get<PointerManager>()->setLockEndUUID(uid, objectID, isOverlay); }
};

22
interface/src/raypick/PickScriptingInterface.cpp
View file

@ -20,16 +20,16 @@
#include <pointers/Pick.h>
#include <ScriptEngine.h>
QUuid PickScriptingInterface::createPick(const PickQuery::PickType type, const QVariant& properties) {
unsigned int PickScriptingInterface::createPick(const PickQuery::PickType type, const QVariant& properties) {
switch (type) {
case PickQuery::PickType::Ray:
return createRayPick(properties);
default:
return QUuid();
return 0;
}
}
QUuid PickScriptingInterface::createRayPick(const QVariant& properties) {
unsigned int PickScriptingInterface::createRayPick(const QVariant& properties) {
QVariantMap propMap = properties.toMap();
bool enabled = false;
@ -78,34 +78,34 @@ QUuid PickScriptingInterface::createRayPick(const QVariant& properties) {
return DependencyManager::get<PickManager>()->addPick(PickQuery::Ray, std::make_shared<StaticRayPick>(position, direction, filter, maxDistance, enabled));
}
return QUuid();
return 0;
}
void PickScriptingInterface::enablePick(const QUuid& uid) {
void PickScriptingInterface::enablePick(unsigned int uid) {
DependencyManager::get<PickManager>()->enablePick(uid);
}
void PickScriptingInterface::disablePick(const QUuid& uid) {
void PickScriptingInterface::disablePick(unsigned int uid) {
DependencyManager::get<PickManager>()->disablePick(uid);
}
void PickScriptingInterface::removePick(const QUuid& uid) {
void PickScriptingInterface::removePick(unsigned int uid) {
DependencyManager::get<PickManager>()->removePick(uid);
}
QVariantMap PickScriptingInterface::getPrevPickResult(const QUuid& uid) {
QVariantMap PickScriptingInterface::getPrevPickResult(unsigned int uid) {
return DependencyManager::get<PickManager>()->getPrevPickResult(uid);
}
void PickScriptingInterface::setPrecisionPicking(const QUuid& uid, const bool precisionPicking) {
void PickScriptingInterface::setPrecisionPicking(unsigned int uid, const bool precisionPicking) {
DependencyManager::get<PickManager>()->setPrecisionPicking(uid, precisionPicking);
}
void PickScriptingInterface::setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreItems) {
void PickScriptingInterface::setIgnoreItems(unsigned int uid, const QScriptValue& ignoreItems) {
DependencyManager::get<PickManager>()->setIgnoreItems(uid, qVectorQUuidFromScriptValue(ignoreItems));
}
void PickScriptingInterface::setIncludeItems(const QUuid& uid, const QScriptValue& includeItems) {
void PickScriptingInterface::setIncludeItems(unsigned int uid, const QScriptValue& includeItems) {
DependencyManager::get<PickManager>()->setIncludeItems(uid, qVectorQUuidFromScriptValue(includeItems));
}

18
interface/src/raypick/PickScriptingInterface.h
View file

@ -33,20 +33,20 @@ class PickScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public:
QUuid createRayPick(const QVariant& properties);
unsigned int createRayPick(const QVariant& properties);
void registerMetaTypes(QScriptEngine* engine);
public slots:
Q_INVOKABLE QUuid createPick(const PickQuery::PickType type, const QVariant& properties);
Q_INVOKABLE void enablePick(const QUuid& uid);
Q_INVOKABLE void disablePick(const QUuid& uid);
Q_INVOKABLE void removePick(const QUuid& uid);
Q_INVOKABLE QVariantMap getPrevPickResult(const QUuid& uid);
Q_INVOKABLE unsigned int createPick(const PickQuery::PickType type, const QVariant& properties);
Q_INVOKABLE void enablePick(unsigned int uid);
Q_INVOKABLE void disablePick(unsigned int uid);
Q_INVOKABLE void removePick(unsigned int uid);
Q_INVOKABLE QVariantMap getPrevPickResult(unsigned int uid);
Q_INVOKABLE void setPrecisionPicking(const QUuid& uid, const bool precisionPicking);
Q_INVOKABLE void setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreEntities);
Q_INVOKABLE void setIncludeItems(const QUuid& uid, const QScriptValue& includeEntities);
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, const bool precisionPicking);
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities);
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities);
static constexpr unsigned int PICK_NOTHING() { return 0; }
static constexpr unsigned int PICK_ENTITIES() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_ENTITIES); }

12
interface/src/raypick/PointerScriptingInterface.cpp
View file

@ -14,23 +14,23 @@
#include "Application.h"
#include "LaserPointer.h"
void PointerScriptingInterface::setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreItems) const {
void PointerScriptingInterface::setIgnoreItems(unsigned int uid, const QScriptValue& ignoreItems) const {
DependencyManager::get<PointerManager>()->setIgnoreItems(uid, qVectorQUuidFromScriptValue(ignoreItems));
}
void PointerScriptingInterface::setIncludeItems(const QUuid& uid, const QScriptValue& includeItems) const {
void PointerScriptingInterface::setIncludeItems(unsigned int uid, const QScriptValue& includeItems) const {
DependencyManager::get<PointerManager>()->setIncludeItems(uid, qVectorQUuidFromScriptValue(includeItems));
}
QUuid PointerScriptingInterface::createPointer(const PickQuery::PickType& type, const QVariant& properties) const {
unsigned int PointerScriptingInterface::createPointer(const PickQuery::PickType& type, const QVariant& properties) const {
switch (type) {
case PickQuery::PickType::Ray:
return createLaserPointer(properties);
default:
return QUuid();
return 0;
}
}
QUuid PointerScriptingInterface::createLaserPointer(const QVariant& properties) const {
unsigned int PointerScriptingInterface::createLaserPointer(const QVariant& properties) const {
QVariantMap propertyMap = properties.toMap();
bool faceAvatar = false;
@ -114,7 +114,7 @@ QUuid PointerScriptingInterface::createLaserPointer(const QVariant& properties)
faceAvatar, centerEndY, lockEnd, distanceScaleEnd, enabled));
}
void PointerScriptingInterface::editRenderState(const QUuid& uid, const QString& renderState, const QVariant& properties) const {
void PointerScriptingInterface::editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const {
QVariantMap propMap = properties.toMap();
QVariant startProps;

26
interface/src/raypick/PointerScriptingInterface.h
View file

@ -19,23 +19,23 @@ class PointerScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public:
QUuid createLaserPointer(const QVariant& properties) const;
unsigned int createLaserPointer(const QVariant& properties) const;
public slots:
Q_INVOKABLE QUuid createPointer(const PickQuery::PickType& type, const QVariant& properties) const;
Q_INVOKABLE void enablePointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->enablePointer(uid); }
Q_INVOKABLE void disablePointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->disablePointer(uid); }
Q_INVOKABLE void removePointer(const QUuid& uid) const { DependencyManager::get<PointerManager>()->removePointer(uid); }
Q_INVOKABLE void editRenderState(const QUuid& uid, const QString& renderState, const QVariant& properties) const;
Q_INVOKABLE void setRenderState(const QUuid& uid, const QString& renderState) const { DependencyManager::get<PointerManager>()->setRenderState(uid, renderState.toStdString()); }
Q_INVOKABLE QVariantMap getPrevPickResult(const QUuid& uid) const { return DependencyManager::get<PointerManager>()->getPrevPickResult(uid); }
Q_INVOKABLE unsigned int createPointer(const PickQuery::PickType& type, const QVariant& properties) const;
Q_INVOKABLE void enablePointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->enablePointer(uid); }
Q_INVOKABLE void disablePointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->disablePointer(uid); }
Q_INVOKABLE void removePointer(unsigned int uid) const { DependencyManager::get<PointerManager>()->removePointer(uid); }
Q_INVOKABLE void editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const;
Q_INVOKABLE void setRenderState(unsigned int uid, const QString& renderState) const { DependencyManager::get<PointerManager>()->setRenderState(uid, renderState.toStdString()); }
Q_INVOKABLE QVariantMap getPrevPickResult(unsigned int uid) const { return DependencyManager::get<PointerManager>()->getPrevPickResult(uid); }
Q_INVOKABLE void setPrecisionPicking(const QUuid& uid, bool precisionPicking) const { DependencyManager::get<PointerManager>()->setPrecisionPicking(uid, precisionPicking); }
Q_INVOKABLE void setLaserLength(const QUuid& uid, float laserLength) const { DependencyManager::get<PointerManager>()->setLength(uid, laserLength); }
Q_INVOKABLE void setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreEntities) const;
Q_INVOKABLE void setIncludeItems(const QUuid& uid, const QScriptValue& includeEntities) const;
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking) const { DependencyManager::get<PointerManager>()->setPrecisionPicking(uid, precisionPicking); }
Q_INVOKABLE void setLaserLength(unsigned int uid, float laserLength) const { DependencyManager::get<PointerManager>()->setLength(uid, laserLength); }
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities) const;
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities) const;
Q_INVOKABLE void setLockEndUUID(const QUuid& uid, const QUuid& objectID, bool isOverlay) const { DependencyManager::get<PointerManager>()->setLockEndUUID(uid, objectID, isOverlay); }
Q_INVOKABLE void setLockEndUid(unsigned int uid, const QUuid& objectID, bool isOverlay) const { DependencyManager::get<PointerManager>()->setLockEndUUID(uid, objectID, isOverlay); }
signals:
void triggerBegin(const QUuid& id, const PointerEvent& pointerEvent);

16
interface/src/raypick/RayPickScriptingInterface.cpp
View file

@ -20,34 +20,34 @@
#include "JointRayPick.h"
#include "MouseRayPick.h"
QUuid RayPickScriptingInterface::createRayPick(const QVariant& properties) {
uint32_t RayPickScriptingInterface::createRayPick(const QVariant& properties) {
return DependencyManager::get<PickScriptingInterface>()->createRayPick(properties);
}
void RayPickScriptingInterface::enableRayPick(const QUuid& uid) {
void RayPickScriptingInterface::enableRayPick(uint32_t uid) {
DependencyManager::get<PickManager>()->enablePick(uid);
}
void RayPickScriptingInterface::disableRayPick(const QUuid& uid) {
void RayPickScriptingInterface::disableRayPick(uint32_t uid) {
DependencyManager::get<PickManager>()->disablePick(uid);
}
void RayPickScriptingInterface::removeRayPick(const QUuid& uid) {
void RayPickScriptingInterface::removeRayPick(uint32_t uid) {
DependencyManager::get<PickManager>()->removePick(uid);
}
QVariantMap RayPickScriptingInterface::getPrevRayPickResult(const QUuid& uid) {
QVariantMap RayPickScriptingInterface::getPrevRayPickResult(uint32_t uid) {
return DependencyManager::get<PickManager>()->getPrevPickResult(uid);
}
void RayPickScriptingInterface::setPrecisionPicking(const QUuid& uid, const bool precisionPicking) {
void RayPickScriptingInterface::setPrecisionPicking(uint32_t uid, const bool precisionPicking) {
DependencyManager::get<PickManager>()->setPrecisionPicking(uid, precisionPicking);
}
void RayPickScriptingInterface::setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreItems) {
void RayPickScriptingInterface::setIgnoreItems(uint32_t uid, const QScriptValue& ignoreItems) {
DependencyManager::get<PickManager>()->setIgnoreItems(uid, qVectorQUuidFromScriptValue(ignoreItems));
}
void RayPickScriptingInterface::setIncludeItems(const QUuid& uid, const QScriptValue& includeItems) {
void RayPickScriptingInterface::setIncludeItems(uint32_t uid, const QScriptValue& includeItems) {
DependencyManager::get<PickManager>()->setIncludeItems(uid, qVectorQUuidFromScriptValue(includeItems));
}

16
interface/src/raypick/RayPickScriptingInterface.h
View file

@ -37,15 +37,15 @@ class RayPickScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public slots:
Q_INVOKABLE QUuid createRayPick(const QVariant& properties);
Q_INVOKABLE void enableRayPick(const QUuid& uid);
Q_INVOKABLE void disableRayPick(const QUuid& uid);
Q_INVOKABLE void removeRayPick(const QUuid& uid);
Q_INVOKABLE QVariantMap getPrevRayPickResult(const QUuid& uid);
Q_INVOKABLE unsigned int createRayPick(const QVariant& properties);
Q_INVOKABLE void enableRayPick(unsigned int uid);
Q_INVOKABLE void disableRayPick(unsigned int uid);
Q_INVOKABLE void removeRayPick(unsigned int uid);
Q_INVOKABLE QVariantMap getPrevRayPickResult(unsigned int uid);
Q_INVOKABLE void setPrecisionPicking(const QUuid& uid, const bool precisionPicking);
Q_INVOKABLE void setIgnoreItems(const QUuid& uid, const QScriptValue& ignoreEntities);
Q_INVOKABLE void setIncludeItems(const QUuid& uid, const QScriptValue& includeEntities);
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, const bool precisionPicking);
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities);
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities);
static unsigned int PICK_NOTHING() { return PickScriptingInterface::PICK_NOTHING(); }
static unsigned int PICK_ENTITIES() { return PickScriptingInterface::PICK_ENTITIES(); }

4
libraries/entities-renderer/src/EntityTreeRenderer.cpp
View file

@ -51,11 +51,11 @@ EntityTreeRenderer::EntityTreeRenderer(bool wantScripts, AbstractViewStateInterf
_displayModelBounds(false),
_layeredZones(this)
{
setMouseRayPickResultOperator([](QUuid rayPickID) {
setMouseRayPickResultOperator([](unsigned int rayPickID) {
RayToEntityIntersectionResult entityResult;
return entityResult;
});
setSetPrecisionPickingOperator([](QUuid rayPickID, bool value) {});
setSetPrecisionPickingOperator([](unsigned int rayPickID, bool value) {});
EntityRenderer::initEntityRenderers();
_currentHoverOverEntityID = UNKNOWN_ENTITY_ID;
_currentClickingOnEntityID = UNKNOWN_ENTITY_ID;

12
libraries/entities-renderer/src/EntityTreeRenderer.h
View file

@ -74,9 +74,9 @@ public:
static float getEntityLoadingPriority(const EntityItem& item) { return _calculateEntityLoadingPriorityFunc(item); }
static void setEntityLoadingPriorityFunction(CalculateEntityLoadingPriority fn) { _calculateEntityLoadingPriorityFunc = fn; }
void setMouseRayPickID(QUuid rayPickID) { _mouseRayPickID = rayPickID; }
void setMouseRayPickResultOperator(std::function<RayToEntityIntersectionResult(QUuid)> getPrevRayPickResultOperator) { _getPrevRayPickResultOperator = getPrevRayPickResultOperator; }
void setSetPrecisionPickingOperator(std::function<void(QUuid, bool)> setPrecisionPickingOperator) { _setPrecisionPickingOperator = setPrecisionPickingOperator; }
void setMouseRayPickID(unsigned int rayPickID) { _mouseRayPickID = rayPickID; }
void setMouseRayPickResultOperator(std::function<RayToEntityIntersectionResult(unsigned int)> getPrevRayPickResultOperator) { _getPrevRayPickResultOperator = getPrevRayPickResultOperator; }
void setSetPrecisionPickingOperator(std::function<void(unsigned int, bool)> setPrecisionPickingOperator) { _setPrecisionPickingOperator = setPrecisionPickingOperator; }
void shutdown();
void update(bool simulate);
@ -182,9 +182,9 @@ private:
QMultiMap<QUrl, EntityItemID> _waitingOnPreload;
QUuid _mouseRayPickID;
std::function<RayToEntityIntersectionResult(QUuid)> _getPrevRayPickResultOperator;
std::function<void(QUuid, bool)> _setPrecisionPickingOperator;
unsigned int _mouseRayPickID;
std::function<RayToEntityIntersectionResult(unsigned int)> _getPrevRayPickResultOperator;
std::function<void(unsigned int, bool)> _setPrecisionPickingOperator;
class LayeredZone {
public:

4
libraries/pointers/src/pointers/PickCacheOptimizer.h
View file

@ -37,7 +37,7 @@ template<typename T>
class PickCacheOptimizer {
public:
void update(QHash<QUuid, std::shared_ptr<PickQuery>>& picks, bool shouldPickHUD);
void update(QHash<unsigned int, std::shared_ptr<PickQuery>>& picks, bool shouldPickHUD);
protected:
typedef std::unordered_map<T, std::unordered_map<PickCacheKey, PickResultPointer>> PickCache;
@ -67,7 +67,7 @@ void PickCacheOptimizer<T>::cacheResult(const bool intersects, const PickResultP
}
template<typename T>
void PickCacheOptimizer<T>::update(QHash<QUuid, std::shared_ptr<PickQuery>>& picks, bool shouldPickHUD) {
void PickCacheOptimizer<T>::update(QHash<unsigned int, std::shared_ptr<PickQuery>>& picks, bool shouldPickHUD) {
PickCache results;
for (const auto& uid : picks.keys()) {
std::shared_ptr<Pick<T>> pick = std::static_pointer_cast<Pick<T>>(picks[uid]);

30
libraries/pointers/src/pointers/PickManager.cpp
View file

@ -12,16 +12,20 @@ PickManager::PickManager() {
setCalculatePos2DFromHUDOperator([](const glm::vec3& intersection) { return glm::vec2(NAN); });
}
QUuid PickManager::addPick(PickQuery::PickType type, const std::shared_ptr<PickQuery> pick) {
QUuid id = QUuid::createUuid();
unsigned int PickManager::addPick(PickQuery::PickType type, const std::shared_ptr<PickQuery> pick) {
unsigned int id = 0;
withWriteLock([&] {
_picks[type][id] = pick;
_typeMap[id] = type;
// Don't let the pick IDs overflow
if (_nextPickID < UINT32_MAX) {
id = _nextPickID++;
_picks[type][id] = pick;
_typeMap[id] = type;
}
});
return id;
}
std::shared_ptr<PickQuery> PickManager::findPick(const QUuid& uid) const {
std::shared_ptr<PickQuery> PickManager::findPick(unsigned int uid) const {
return resultWithReadLock<std::shared_ptr<PickQuery>>([&] {
auto type = _typeMap.find(uid);
if (type != _typeMap.end()) {
@ -31,7 +35,7 @@ std::shared_ptr<PickQuery> PickManager::findPick(const QUuid& uid) const {
});
}
void PickManager::removePick(const QUuid& uid) {
void PickManager::removePick(unsigned int uid) {
withWriteLock([&] {
auto type = _typeMap.find(uid);
if (type != _typeMap.end()) {
@ -41,7 +45,7 @@ void PickManager::removePick(const QUuid& uid) {
});
}
QVariantMap PickManager::getPrevPickResult(const QUuid& uid) const {
QVariantMap PickManager::getPrevPickResult(unsigned int uid) const {
auto pick = findPick(uid);
if (pick && pick->getPrevPickResult()) {
return pick->getPrevPickResult()->toVariantMap();
@ -49,35 +53,35 @@ QVariantMap PickManager::getPrevPickResult(const QUuid& uid) const {
return QVariantMap();
}
void PickManager::enablePick(const QUuid& uid) const {
void PickManager::enablePick(unsigned int uid) const {
auto pick = findPick(uid);
if (pick) {
pick->enable();
}
}
void PickManager::disablePick(const QUuid& uid) const {
void PickManager::disablePick(unsigned int uid) const {
auto pick = findPick(uid);
if (pick) {
pick->disable();
}
}
void PickManager::setPrecisionPicking(const QUuid& uid, bool precisionPicking) const {
void PickManager::setPrecisionPicking(unsigned int uid, bool precisionPicking) const {
auto pick = findPick(uid);
if (pick) {
pick->setPrecisionPicking(precisionPicking);
}
}
void PickManager::setIgnoreItems(const QUuid& uid, const QVector<QUuid>& ignore) const {
void PickManager::setIgnoreItems(unsigned int uid, const QVector<QUuid>& ignore) const {
auto pick = findPick(uid);
if (pick) {
pick->setIgnoreItems(ignore);
}
}
void PickManager::setIncludeItems(const QUuid& uid, const QVector<QUuid>& include) const {
void PickManager::setIncludeItems(unsigned int uid, const QVector<QUuid>& include) const {
auto pick = findPick(uid);
if (pick) {
pick->setIncludeItems(include);
@ -85,7 +89,7 @@ void PickManager::setIncludeItems(const QUuid& uid, const QVector<QUuid>& includ
}
void PickManager::update() {
QHash<PickQuery::PickType, QHash<QUuid, std::shared_ptr<PickQuery>>> cachedPicks;
QHash<PickQuery::PickType, QHash<unsigned int, std::shared_ptr<PickQuery>>> cachedPicks;
withReadLock([&] {
cachedPicks = _picks;
});

25
libraries/pointers/src/pointers/PickManager.h
View file

@ -22,16 +22,16 @@ public:
void update();
QUuid addPick(PickQuery::PickType type, const std::shared_ptr<PickQuery> pick);
void removePick(const QUuid& uid);
void enablePick(const QUuid& uid) const;
void disablePick(const QUuid& uid) const;
unsigned int addPick(PickQuery::PickType type, const std::shared_ptr<PickQuery> pick);
void removePick(unsigned int uid);
void enablePick(unsigned int uid) const;
void disablePick(unsigned int uid) const;
QVariantMap getPrevPickResult(const QUuid& uid) const;
QVariantMap getPrevPickResult(unsigned int uid) const;
void setPrecisionPicking(const QUuid& uid, bool precisionPicking) const;
void setIgnoreItems(const QUuid& uid, const QVector<QUuid>& ignore) const;
void setIncludeItems(const QUuid& uid, const QVector<QUuid>& include) const;
void setPrecisionPicking(unsigned int uid, bool precisionPicking) const;
void setIgnoreItems(unsigned int uid, const QVector<QUuid>& ignore) const;
void setIncludeItems(unsigned int uid, const QVector<QUuid>& include) const;
void setShouldPickHUDOperator(std::function<bool()> shouldPickHUDOperator) { _shouldPickHUDOperator = shouldPickHUDOperator; }
void setCalculatePos2DFromHUDOperator(std::function<glm::vec2(const glm::vec3&)> calculatePos2DFromHUDOperator) { _calculatePos2DFromHUDOperator = calculatePos2DFromHUDOperator; }
@ -41,9 +41,12 @@ protected:
std::function<bool()> _shouldPickHUDOperator;
std::function<glm::vec2(const glm::vec3&)> _calculatePos2DFromHUDOperator;
std::shared_ptr<PickQuery> findPick(const QUuid& uid) const;
QHash<PickQuery::PickType, QHash<QUuid, std::shared_ptr<PickQuery>>> _picks;
QHash<QUuid, PickQuery::PickType> _typeMap;
std::shared_ptr<PickQuery> findPick(unsigned int uid) const;
QHash<PickQuery::PickType, QHash<unsigned int, std::shared_ptr<PickQuery>>> _picks;
QHash<unsigned int, PickQuery::PickType> _typeMap;
// 0 = invalid
const unsigned int FIRST_PICK_ID { 1 };
unsigned int _nextPickID { FIRST_PICK_ID };
PickCacheOptimizer<PickRay> _rayPickCacheOptimizer;
};

13
libraries/pointers/src/pointers/Pointer.cpp
View file

@ -46,16 +46,16 @@ void Pointer::setIncludeItems(const QVector<QUuid>& includeItems) const {
DependencyManager::get<PickManager>()->setIncludeItems(_pickUID, includeItems);
}
void Pointer::update() {
void Pointer::update(unsigned int pointerID) {
// This only needs to be a read lock because update won't change any of the properties that can be modified from scripts
withReadLock([&] {
QVariantMap pickResult = getPrevPickResult();
updateVisuals(pickResult);
generatePointerEvents(pickResult);
generatePointerEvents(pointerID, pickResult);
});
}
void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
void Pointer::generatePointerEvents(unsigned int pointerID, const QVariantMap& pickResult) {
// TODO: avatars?
auto pointerManager = DependencyManager::get<PointerManager>();
@ -63,6 +63,7 @@ void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
Pointer::PickedObject hoveredObject = getHoveredObject(pickResult);
PointerEvent hoveredEvent = buildPointerEvent(hoveredObject, pickResult);
hoveredEvent.setType(PointerEvent::Move);
hoveredEvent.setID(pointerID);
// TODO: set buttons on hover events
hoveredEvent.setButton(PointerEvent::NoButtons);
if (_enabled && _hover && shouldHover()) {
@ -72,6 +73,7 @@ void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
emit pointerManager->hoverContinueOverlay(hoveredObject.objectID, hoveredEvent);
} else {
PointerEvent prevHoveredEvent = buildPointerEvent(_prevHoveredObject, pickResult);
prevHoveredEvent.setID(pointerID);
emit pointerManager->hoverEndOverlay(_prevHoveredObject.objectID, prevHoveredEvent);
emit pointerManager->hoverBeginOverlay(hoveredObject.objectID, hoveredEvent);
}
@ -92,6 +94,7 @@ void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
emit pointerManager->hoverContinueEntity(hoveredObject.objectID, hoveredEvent);
} else {
PointerEvent prevHoveredEvent = buildPointerEvent(_prevHoveredObject, pickResult);
prevHoveredEvent.setID(pointerID);
emit pointerManager->hoverEndEntity(_prevHoveredObject.objectID, prevHoveredEvent);
emit pointerManager->hoverBeginEntity(hoveredObject.objectID, hoveredEvent);
}
@ -153,10 +156,13 @@ void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
}
_triggeredObjects[button] = hoveredObject;
}
// We still want other trigger events for Focus buttons, but they only set focus on triggerBegin
hoveredEvent.setShouldFocus(false);
// Trigger continue
for (const std::string& button : sameButtons) {
PointerEvent triggeredEvent = buildPointerEvent(_triggeredObjects[button], pickResult);
triggeredEvent.setID(pointerID);
triggeredEvent.setType(PointerEvent::Move);
hoveredEvent.setButton(chooseButton(button));
if (_triggeredObjects[button].type == ENTITY) {
@ -171,6 +177,7 @@ void Pointer::generatePointerEvents(const QVariantMap& pickResult) {
// Trigger end
for (const std::string& button : _prevButtons) {
PointerEvent triggeredEvent = buildPointerEvent(_triggeredObjects[button], pickResult);
triggeredEvent.setID(pointerID);
triggeredEvent.setType(PointerEvent::Release);
hoveredEvent.setButton(chooseButton(button));
if (_triggeredObjects[button].type == ENTITY) {

10
libraries/pointers/src/pointers/Pointer.h
View file

@ -38,7 +38,7 @@ using PointerTriggers = std::vector<PointerTrigger>;
class Pointer : protected ReadWriteLockable {
public:
Pointer(const QUuid& uid, bool enabled, bool hover) : _pickUID(uid), _enabled(enabled), _hover(hover) {}
Pointer(unsigned int uid, bool enabled, bool hover) : _pickUID(uid), _enabled(enabled), _hover(hover) {}
virtual ~Pointer();
@ -57,9 +57,9 @@ public:
virtual void setLength(float length) {}
virtual void setLockEndUUID(const QUuid& objectID, bool isOverlay) {}
void update();
void update(unsigned int pointerID);
virtual void updateVisuals(const QVariantMap& pickResult) = 0;
void generatePointerEvents(const QVariantMap& pickResult);
void generatePointerEvents(unsigned int pointerID, const QVariantMap& pickResult);
struct PickedObject {
PickedObject() {}
@ -71,10 +71,10 @@ public:
using Buttons = std::unordered_set<std::string>;
QUuid getRayUID() { return _pickUID; }
unsigned int getRayUID() { return _pickUID; }
protected:
const QUuid _pickUID;
const unsigned int _pickUID;
bool _enabled;
bool _hover;

47
libraries/pointers/src/pointers/PointerManager.cpp
View file

@ -8,7 +8,7 @@
#include "PointerManager.h"
std::shared_ptr<Pointer> PointerManager::find(const QUuid& uid) const {
std::shared_ptr<Pointer> PointerManager::find(unsigned int uid) const {
return resultWithReadLock<std::shared_ptr<Pointer>>([&] {
auto itr = _pointers.find(uid);
if (itr != _pointers.end()) {
@ -18,50 +18,55 @@ std::shared_ptr<Pointer> PointerManager::find(const QUuid& uid) const {
});
}
QUuid PointerManager::addPointer(std::shared_ptr<Pointer> pointer) {
QUuid result;
if (!pointer->getRayUID().isNull()) {
result = QUuid::createUuid();
withWriteLock([&] { _pointers[result] = pointer; });
unsigned int PointerManager::addPointer(std::shared_ptr<Pointer> pointer) {
unsigned int result = 0;
if (pointer->getRayUID() > 0) {
withWriteLock([&] {
// Don't let the pointer IDs overflow
if (_nextPointerID < UINT32_MAX) {
result = _nextPointerID++;
_pointers[result] = pointer;
}
});
}
return result;
}
void PointerManager::removePointer(const QUuid& uid) {
void PointerManager::removePointer(unsigned int uid) {
withWriteLock([&] {
_pointers.remove(uid);
});
}
void PointerManager::enablePointer(const QUuid& uid) const {
void PointerManager::enablePointer(unsigned int uid) const {
auto pointer = find(uid);
if (pointer) {
pointer->enable();
}
}
void PointerManager::disablePointer(const QUuid& uid) const {
void PointerManager::disablePointer(unsigned int uid) const {
auto pointer = find(uid);
if (pointer) {
pointer->disable();
}
}
void PointerManager::setRenderState(const QUuid& uid, const std::string& renderState) const {
void PointerManager::setRenderState(unsigned int uid, const std::string& renderState) const {
auto pointer = find(uid);
if (pointer) {
pointer->setRenderState(renderState);
}
}
void PointerManager::editRenderState(const QUuid& uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) const {
void PointerManager::editRenderState(unsigned int uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) const {
auto pointer = find(uid);
if (pointer) {
pointer->editRenderState(state, startProps, pathProps, endProps);
}
}
const QVariantMap PointerManager::getPrevPickResult(const QUuid& uid) const {
const QVariantMap PointerManager::getPrevPickResult(unsigned int uid) const {
auto pointer = find(uid);
if (pointer) {
return pointer->getPrevPickResult();
@ -70,44 +75,44 @@ const QVariantMap PointerManager::getPrevPickResult(const QUuid& uid) const {
}
void PointerManager::update() {
auto cachedPointers = resultWithReadLock<QList<std::shared_ptr<Pointer>>>([&] {
return _pointers.values();
auto cachedPointers = resultWithReadLock<QHash<unsigned int, std::shared_ptr<Pointer>>>([&] {
return _pointers;
});
for (const auto& pointer : cachedPointers) {
pointer->update();
for (const auto& uid : cachedPointers.keys()) {
cachedPointers[uid]->update(uid);
}
}
void PointerManager::setPrecisionPicking(const QUuid& uid, bool precisionPicking) const {
void PointerManager::setPrecisionPicking(unsigned int uid, bool precisionPicking) const {
auto pointer = find(uid);
if (pointer) {
pointer->setPrecisionPicking(precisionPicking);
}
}
void PointerManager::setIgnoreItems(const QUuid& uid, const QVector<QUuid>& ignoreEntities) const {
void PointerManager::setIgnoreItems(unsigned int uid, const QVector<QUuid>& ignoreEntities) const {
auto pointer = find(uid);
if (pointer) {
pointer->setIgnoreItems(ignoreEntities);
}
}
void PointerManager::setIncludeItems(const QUuid& uid, const QVector<QUuid>& includeEntities) const {
void PointerManager::setIncludeItems(unsigned int uid, const QVector<QUuid>& includeEntities) const {
auto pointer = find(uid);
if (pointer) {
pointer->setIncludeItems(includeEntities);
}
}
void PointerManager::setLength(const QUuid& uid, float length) const {
void PointerManager::setLength(unsigned int uid, float length) const {
auto pointer = find(uid);
if (pointer) {
pointer->setLength(length);
}
}
void PointerManager::setLockEndUUID(const QUuid& uid, const QUuid& objectID, bool isOverlay) const {
void PointerManager::setLockEndUUID(unsigned int uid, const QUuid& objectID, bool isOverlay) const {
auto pointer = find(uid);
if (pointer) {
pointer->setLockEndUUID(objectID, isOverlay);

30
libraries/pointers/src/pointers/PointerManager.h
View file

@ -23,26 +23,28 @@ class PointerManager : public QObject, public Dependency, protected ReadWriteLoc
public:
PointerManager() {}
QUuid addPointer(std::shared_ptr<Pointer> pointer);
void removePointer(const QUuid& uid);
void enablePointer(const QUuid& uid) const;
void disablePointer(const QUuid& uid) const;
void setRenderState(const QUuid& uid, const std::string& renderState) const;
void editRenderState(const QUuid& uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) const;
const QVariantMap getPrevPickResult(const QUuid& uid) const;
unsigned int addPointer(std::shared_ptr<Pointer> pointer);
void removePointer(unsigned int uid);
void enablePointer(unsigned int uid) const;
void disablePointer(unsigned int uid) const;
void setRenderState(unsigned int uid, const std::string& renderState) const;
void editRenderState(unsigned int uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) const;
const QVariantMap getPrevPickResult(unsigned int uid) const;
void setPrecisionPicking(const QUuid& uid, bool precisionPicking) const;
void setIgnoreItems(const QUuid& uid, const QVector<QUuid>& ignoreEntities) const;
void setIncludeItems(const QUuid& uid, const QVector<QUuid>& includeEntities) const;
void setPrecisionPicking(unsigned int uid, bool precisionPicking) const;
void setIgnoreItems(unsigned int uid, const QVector<QUuid>& ignoreEntities) const;
void setIncludeItems(unsigned int uid, const QVector<QUuid>& includeEntities) const;
void setLength(const QUuid& uid, float length) const;
void setLockEndUUID(const QUuid& uid, const QUuid& objectID, bool isOverlay) const;
void setLength(unsigned int uid, float length) const;
void setLockEndUUID(unsigned int uid, const QUuid& objectID, bool isOverlay) const;
void update();
private:
std::shared_ptr<Pointer> find(const QUuid& uid) const;
QHash<QUuid, std::shared_ptr<Pointer>> _pointers;
std::shared_ptr<Pointer> find(unsigned int uid) const;
QHash<unsigned int, std::shared_ptr<Pointer>> _pointers;
// 0 = invalid, 1 = reserved for system mouse
unsigned int _nextPointerID { 2 };
signals:
void triggerBeginOverlay(const QUuid& id, const PointerEvent& pointerEvent);

1
libraries/shared/src/PointerEvent.h
View file

@ -57,6 +57,7 @@ public:
Qt::KeyboardModifiers getKeyboardModifiers() const { return _keyboardModifiers; }
bool shouldFocus() const { return _shouldFocus; }
void setID(uint32_t id) { _id = id; }
void setType(EventType type) { _type = type; }
void setButton(Button button);
void setShouldFocus(bool focus) { _shouldFocus = focus; }

4
libraries/ui/src/ui/OffscreenQmlSurface.cpp
View file

@ -959,7 +959,7 @@ void OffscreenQmlSurface::handlePointerEvent(const QUuid& id, const PointerEvent
return;
}
QEvent::Type type;
QEvent::Type type = QEvent::Type::MouseMove;
switch (event.getType()) {
case PointerEvent::Press:
type = QEvent::Type::MouseButtonPress;
@ -973,6 +973,8 @@ void OffscreenQmlSurface::handlePointerEvent(const QUuid& id, const PointerEvent
case PointerEvent::Move:
type = QEvent::Type::MouseMove;
break;
default:
break;
}
QPointF screenPos(event.getPos2D().x, event.getPos2D().y);
QMouseEvent mouseEvent(type, screenPos, Qt::MouseButton(event.getButton()), Qt::MouseButtons(event.getButtons()), event.getKeyboardModifiers());