Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 06:10:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Clean up C++ relating to panels.

Browse source
This commit is contained in:
Zander Otavka 2015-07-24 17:50:17 -07:00
parent da2afca391
commit bc5ef8eb11
7 changed files with 151 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
interface/src/ui/overlays/BillboardOverlay.cpp
View file

@ -13,17 +13,15 @@
#include <QScriptValue> #include <QScriptValue>
#include <DeferredLightingEffect.h>
#include <DependencyManager.h> #include <DependencyManager.h>
#include <GeometryCache.h> #include <GeometryCache.h>
#include <gpu/Batch.h> #include <gpu/Batch.h>
#include <GLMHelpers.h>
#include "Application.h" #include "Application.h"
#include "GeometryUtil.h" #include "GeometryUtil.h"
#include "DeferredLightingEffect.h"
#include <GLMHelpers.h>
QString const BillboardOverlay::TYPE = "billboard"; QString const BillboardOverlay::TYPE = "billboard";
@ -107,7 +105,7 @@ void BillboardOverlay::render(RenderArgs* args) {
batch->setModelTransform(transform); batch->setModelTransform(transform);
batch->setResourceTexture(0, _texture->getGPUTexture()); batch->setResourceTexture(0, _texture->getGPUTexture());
DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(*batch, true, true, false); DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(*batch, true, true, false, true);
DependencyManager::get<GeometryCache>()->renderQuad( DependencyManager::get<GeometryCache>()->renderQuad(
*batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, *batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha) glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha)
@ -118,6 +116,7 @@ void BillboardOverlay::render(RenderArgs* args) {
void BillboardOverlay::setProperties(const QScriptValue &properties) { void BillboardOverlay::setProperties(const QScriptValue &properties) {
Planar3DOverlay::setProperties(properties); Planar3DOverlay::setProperties(properties);
PanelAttachable::setProperties(properties);
QScriptValue urlValue = properties.property("url"); QScriptValue urlValue = properties.property("url");
if (urlValue.isValid()) { if (urlValue.isValid()) {
@ -162,21 +161,6 @@ void BillboardOverlay::setProperties(const QScriptValue &properties) {
if (isFacingAvatarValue.isValid()) { if (isFacingAvatarValue.isValid()) {
_isFacingAvatar = isFacingAvatarValue.toVariant().toBool(); _isFacingAvatar = isFacingAvatarValue.toVariant().toBool();
} }
QScriptValue offsetPosition = properties.property("offsetPosition");
if (offsetPosition.isValid()) {
QScriptValue x = offsetPosition.property("x");
QScriptValue y = offsetPosition.property("y");
QScriptValue z = offsetPosition.property("z");
if (x.isValid() && y.isValid() && z.isValid()) {
glm::vec3 newPosition;
newPosition.x = x.toVariant().toFloat();
newPosition.y = y.toVariant().toFloat();
newPosition.z = z.toVariant().toFloat();
setOffsetPosition(newPosition);
}
}
} }
QScriptValue BillboardOverlay::getProperty(const QString& property) { QScriptValue BillboardOverlay::getProperty(const QString& property) {
@ -193,6 +177,10 @@ QScriptValue BillboardOverlay::getProperty(const QString& property) {
return vec3toScriptValue(_scriptEngine, getOffsetPosition()); return vec3toScriptValue(_scriptEngine, getOffsetPosition());
} }
QScriptValue value = PanelAttachable::getProperty(_scriptEngine, property);
if (value.isValid()) {
return value;
}
return Planar3DOverlay::getProperty(property); return Planar3DOverlay::getProperty(property);
} }

53
interface/src/ui/overlays/FloatingUIPanel.cpp
View file

@ -20,7 +20,6 @@
#include "Application.h" #include "Application.h"
#include "Base3DOverlay.h" #include "Base3DOverlay.h"
std::function<glm::vec3()> const FloatingUIPanel::AVATAR_POSITION = []() -> glm::vec3 { std::function<glm::vec3()> const FloatingUIPanel::AVATAR_POSITION = []() -> glm::vec3 {
return DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(); return DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition();
}; };
@ -30,12 +29,6 @@ std::function<glm::quat()> const FloatingUIPanel::AVATAR_ORIENTATION = []() -> g
glm::angleAxis(glm::pi<float>(), IDENTITY_UP); glm::angleAxis(glm::pi<float>(), IDENTITY_UP);
}; };
FloatingUIPanel::FloatingUIPanel() :
_anchorPosition(AVATAR_POSITION),
_offsetRotation(AVATAR_ORIENTATION)
{
}
glm::vec3 FloatingUIPanel::getPosition() const { glm::vec3 FloatingUIPanel::getPosition() const {
return getOffsetRotation() * getOffsetPosition() + getAnchorPosition(); return getOffsetRotation() * getOffsetPosition() + getAnchorPosition();
} }
@ -44,18 +37,30 @@ glm::quat FloatingUIPanel::getRotation() const {
return getOffsetRotation() * getFacingRotation(); return getOffsetRotation() * getFacingRotation();
} }
void FloatingUIPanel::setAnchorPosition(glm::vec3 position) { void FloatingUIPanel::setAnchorPosition(const glm::vec3& position) {
setAnchorPosition([position]() -> glm::vec3 { setAnchorPosition([position]() -> glm::vec3 {
return position; return position;
}); });
} }
void FloatingUIPanel::setOffsetRotation(glm::quat rotation) { void FloatingUIPanel::setOffsetRotation(const glm::quat& rotation) {
setOffsetRotation([rotation]() -> glm::quat { setOffsetRotation([rotation]() -> glm::quat {
return rotation; return rotation;
}); });
} }
void FloatingUIPanel::addChild(unsigned int childId) {
if (!_children.contains(childId)) {
_children.append(childId);
}
}
void FloatingUIPanel::removeChild(unsigned int childId) {
if (_children.contains(childId)) {
_children.removeOne(childId);
}
}
QScriptValue FloatingUIPanel::getProperty(const QString &property) { QScriptValue FloatingUIPanel::getProperty(const QString &property) {
if (property == "anchorPosition") { if (property == "anchorPosition") {
return vec3toScriptValue(_scriptEngine, getAnchorPosition()); return vec3toScriptValue(_scriptEngine, getAnchorPosition());
@ -76,15 +81,15 @@ QScriptValue FloatingUIPanel::getProperty(const QString &property) {
void FloatingUIPanel::setProperties(const QScriptValue &properties) { void FloatingUIPanel::setProperties(const QScriptValue &properties) {
QScriptValue anchor = properties.property("anchorPosition"); QScriptValue anchor = properties.property("anchorPosition");
if (anchor.isValid()) { if (anchor.isValid()) {
QScriptValue type = anchor.property("type"); QScriptValue bindType = anchor.property("bind");
QScriptValue value = anchor.property("value"); QScriptValue value = anchor.property("value");
if (type.isValid()) { if (bindType.isValid()) {
QString typeString = type.toVariant().toString(); QString bindTypeString = bindType.toVariant().toString();
if (typeString == "myAvatar") { if (bindTypeString == "myAvatar") {
setAnchorPosition(AVATAR_POSITION); setAnchorPosition(AVATAR_POSITION);
} else if (value.isValid()) { } else if (value.isValid()) {
if (typeString == "overlay") { if (bindTypeString == "overlay") {
Overlay::Pointer overlay = Application::getInstance()->getOverlays() Overlay::Pointer overlay = Application::getInstance()->getOverlays()
.getOverlay(value.toVariant().toUInt()); .getOverlay(value.toVariant().toUInt());
if (overlay->is3D()) { if (overlay->is3D()) {
@ -93,13 +98,13 @@ void FloatingUIPanel::setProperties(const QScriptValue &properties) {
return overlay3D->getPosition(); return overlay3D->getPosition();
}); });
} }
} else if (typeString == "panel") { } else if (bindTypeString == "panel") {
FloatingUIPanel::Pointer panel = Application::getInstance()->getOverlays() FloatingUIPanel::Pointer panel = Application::getInstance()->getOverlays()
.getPanel(value.toVariant().toUInt()); .getPanel(value.toVariant().toUInt());
setAnchorPosition([panel]() -> glm::vec3 { setAnchorPosition([panel]() -> glm::vec3 {
return panel->getPosition(); return panel->getPosition();
}); });
} else if (typeString == "vec3") { } else if (bindTypeString == "vec3") {
QScriptValue x = value.property("x"); QScriptValue x = value.property("x");
QScriptValue y = value.property("y"); QScriptValue y = value.property("y");
QScriptValue z = value.property("z"); QScriptValue z = value.property("z");
@ -117,15 +122,15 @@ void FloatingUIPanel::setProperties(const QScriptValue &properties) {
QScriptValue offsetRotation = properties.property("offsetRotation"); QScriptValue offsetRotation = properties.property("offsetRotation");
if (offsetRotation.isValid()) { if (offsetRotation.isValid()) {
QScriptValue type = offsetRotation.property("type"); QScriptValue bindType = offsetRotation.property("bind");
QScriptValue value = offsetRotation.property("value"); QScriptValue value = offsetRotation.property("value");
if (type.isValid()) { if (bindType.isValid()) {
QString typeString = type.toVariant().toString(); QString bindTypeString = bindType.toVariant().toString();
if (typeString == "myAvatar") { if (bindTypeString == "myAvatar") {
setOffsetRotation(AVATAR_ORIENTATION); setOffsetRotation(AVATAR_ORIENTATION);
} else if (value.isValid()) { } else if (value.isValid()) {
if (typeString == "overlay") { if (bindTypeString == "overlay") {
Overlay::Pointer overlay = Application::getInstance()->getOverlays() Overlay::Pointer overlay = Application::getInstance()->getOverlays()
.getOverlay(value.toVariant().toUInt()); .getOverlay(value.toVariant().toUInt());
if (overlay->is3D()) { if (overlay->is3D()) {
@ -134,13 +139,13 @@ void FloatingUIPanel::setProperties(const QScriptValue &properties) {
return overlay3D->getRotation(); return overlay3D->getRotation();
}); });
} }
} else if (typeString == "panel") { } else if (bindTypeString == "panel") {
FloatingUIPanel::Pointer panel = Application::getInstance()->getOverlays() FloatingUIPanel::Pointer panel = Application::getInstance()->getOverlays()
.getPanel(value.toVariant().toUInt()); .getPanel(value.toVariant().toUInt());
setOffsetRotation([panel]() -> glm::quat { setOffsetRotation([panel]() -> glm::quat {
return panel->getRotation(); return panel->getRotation();
}); });
} else if (typeString == "quat") { } else if (bindTypeString == "quat") {
QScriptValue x = value.property("x"); QScriptValue x = value.property("x");
QScriptValue y = value.property("y"); QScriptValue y = value.property("y");
QScriptValue z = value.property("z"); QScriptValue z = value.property("z");
@ -174,7 +179,7 @@ void FloatingUIPanel::setProperties(const QScriptValue &properties) {
} }
QScriptValue facingRotation = properties.property("facingRotation"); QScriptValue facingRotation = properties.property("facingRotation");
if (offsetRotation.isValid()) { if (facingRotation.isValid()) {
QScriptValue x = facingRotation.property("x"); QScriptValue x = facingRotation.property("x");
QScriptValue y = facingRotation.property("y"); QScriptValue y = facingRotation.property("y");
QScriptValue z = facingRotation.property("z"); QScriptValue z = facingRotation.property("z");

22
interface/src/ui/overlays/FloatingUIPanel.h
View file

@ -12,6 +12,8 @@
#ifndef hifi_FloatingUIPanel_h #ifndef hifi_FloatingUIPanel_h
#define hifi_FloatingUIPanel_h #define hifi_FloatingUIPanel_h
#include <functional>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp> #include <glm/gtc/quaternion.hpp>
#include <QScriptValue> #include <QScriptValue>
@ -21,8 +23,6 @@ class FloatingUIPanel : public QObject {
public: public:
typedef std::shared_ptr<FloatingUIPanel> Pointer; typedef std::shared_ptr<FloatingUIPanel> Pointer;
QList<unsigned int> children;
void init(QScriptEngine* scriptEngine) { _scriptEngine = scriptEngine; } void init(QScriptEngine* scriptEngine) { _scriptEngine = scriptEngine; }
glm::vec3 getAnchorPosition() const { return _anchorPosition(); } glm::vec3 getAnchorPosition() const { return _anchorPosition(); }
@ -33,11 +33,16 @@ public:
glm::quat getRotation() const; glm::quat getRotation() const;
void setAnchorPosition(const std::function<glm::vec3()>& func) { _anchorPosition = func; } void setAnchorPosition(const std::function<glm::vec3()>& func) { _anchorPosition = func; }
void setAnchorPosition(glm::vec3 position); void setAnchorPosition(const glm::vec3& position);
void setOffsetRotation(const std::function<glm::quat()>& func) { _offsetRotation = func; } void setOffsetRotation(const std::function<glm::quat()>& func) { _offsetRotation = func; }
void setOffsetRotation(glm::quat rotation); void setOffsetRotation(const glm::quat& rotation);
void setOffsetPosition(glm::vec3 position) { _offsetPosition = position; } void setOffsetPosition(const glm::vec3& position) { _offsetPosition = position; }
void setFacingRotation(glm::quat rotation) { _facingRotation = rotation; } void setFacingRotation(const glm::quat& rotation) { _facingRotation = rotation; }
const QList<unsigned int>& getChildren() { return _children; }
void addChild(unsigned int childId);
void removeChild(unsigned int childId);
unsigned int popLastChild() { return _children.takeLast(); }
QScriptValue getProperty(const QString& property); QScriptValue getProperty(const QString& property);
void setProperties(const QScriptValue& properties); void setProperties(const QScriptValue& properties);
@ -46,11 +51,12 @@ private:
static std::function<glm::vec3()> const AVATAR_POSITION; static std::function<glm::vec3()> const AVATAR_POSITION;
static std::function<glm::quat()> const AVATAR_ORIENTATION; static std::function<glm::quat()> const AVATAR_ORIENTATION;
std::function<glm::vec3()> _anchorPosition; std::function<glm::vec3()> _anchorPosition{AVATAR_POSITION};
std::function<glm::quat()> _offsetRotation; std::function<glm::quat()> _offsetRotation{AVATAR_ORIENTATION};
glm::vec3 _offsetPosition{0, 0, 0}; glm::vec3 _offsetPosition{0, 0, 0};
glm::quat _facingRotation{1, 0, 0, 0}; glm::quat _facingRotation{1, 0, 0, 0};
QScriptEngine* _scriptEngine; QScriptEngine* _scriptEngine;
QList<unsigned int> _children;
}; };
#endif // hifi_FloatingUIPanel_h #endif // hifi_FloatingUIPanel_h

75
interface/src/ui/overlays/Overlays.cpp
View file

@ -135,23 +135,6 @@ Overlay::Pointer Overlays::getOverlay(unsigned int id) const {
return nullptr; return nullptr;
} }
void Overlays::setAttachedPanel(Overlay::Pointer overlay, unsigned int overlayId, const QScriptValue& property) {
auto attachable = std::dynamic_pointer_cast<PanelAttachable>(overlay);
if (attachable) {
if (property.isValid()) {
unsigned int attachedPanelId = property.toVariant().toUInt();
if (_panels.contains(attachedPanelId)) {
auto panel = _panels[attachedPanelId];
panel->children.append(overlayId);
attachable->setAttachedPanel(panel);
} else {
attachable->getAttachedPanel()->children.removeAll(overlayId);
attachable->setAttachedPanel(nullptr);
}
}
}
}
unsigned int Overlays::addOverlay(const QString& type, const QScriptValue& properties) { unsigned int Overlays::addOverlay(const QString& type, const QScriptValue& properties) {
Overlay::Pointer thisOverlay = nullptr; Overlay::Pointer thisOverlay = nullptr;
@ -183,9 +166,7 @@ unsigned int Overlays::addOverlay(const QString& type, const QScriptValue& prope
if (thisOverlay) { if (thisOverlay) {
thisOverlay->setProperties(properties); thisOverlay->setProperties(properties);
unsigned int overlayId = addOverlay(thisOverlay); return addOverlay(thisOverlay);
setAttachedPanel(thisOverlay, overlayId, properties.property("attachedPanel"));
return overlayId;
} }
return 0; return 0;
} }
@ -252,8 +233,6 @@ bool Overlays::editOverlay(unsigned int id, const QScriptValue& properties) {
thisOverlay->setProperties(properties); thisOverlay->setProperties(properties);
} }
setAttachedPanel(thisOverlay, id, properties.property("attachedPanel"));
return true; return true;
} }
return false; return false;
@ -273,8 +252,16 @@ void Overlays::deleteOverlay(unsigned int id) {
} }
} }
auto attachable = std::dynamic_pointer_cast<PanelAttachable>(overlayToDelete);
if (attachable && attachable->getAttachedPanel()) {
attachable->getAttachedPanel()->removeChild(id);
attachable->setAttachedPanel(nullptr);
}
QWriteLocker lock(&_deleteLock); QWriteLocker lock(&_deleteLock);
_overlaysToDelete.push_back(overlayToDelete); _overlaysToDelete.push_back(overlayToDelete);
emit overlayDeleted(id);
} }
QString Overlays::getOverlayType(unsigned int overlayId) const { QString Overlays::getOverlayType(unsigned int overlayId) const {
@ -285,6 +272,33 @@ QString Overlays::getOverlayType(unsigned int overlayId) const {
return ""; return "";
} }
unsigned int Overlays::getAttachedPanel(unsigned int childId) const {
Overlay::Pointer overlay = getOverlay(childId);
auto attachable = std::dynamic_pointer_cast<PanelAttachable>(overlay);
if (attachable) {
return _panels.key(attachable->getAttachedPanel());
}
return 0;
}
void Overlays::setAttachedPanel(unsigned int childId, unsigned int panelId) {
Overlay::Pointer overlay = getOverlay(childId);
auto attachable = std::dynamic_pointer_cast<PanelAttachable>(overlay);
if (attachable) {
if (_panels.contains(panelId)) {
auto panel = _panels[panelId];
panel->addChild(childId);
attachable->setAttachedPanel(panel);
} else {
auto panel = attachable->getAttachedPanel();
if (panel) {
panel->removeChild(childId);
attachable->setAttachedPanel(nullptr);
}
}
}
}
unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) { unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
glm::vec2 pointCopy = point; glm::vec2 pointCopy = point;
if (qApp->isHMDMode()) { if (qApp->isHMDMode()) {
@ -328,16 +342,7 @@ OverlayPropertyResult Overlays::getProperty(unsigned int id, const QString& prop
Overlay::Pointer thisOverlay = getOverlay(id); Overlay::Pointer thisOverlay = getOverlay(id);
QReadLocker lock(&_lock); QReadLocker lock(&_lock);
if (thisOverlay) { if (thisOverlay) {
if (property == "attachedPanel") { result.value = thisOverlay->getProperty(property);
auto panelAttachable = std::dynamic_pointer_cast<PanelAttachable>(thisOverlay);
if (panelAttachable) {
result.value = _panels.key(panelAttachable->getAttachedPanel());
} else {
result.value = 0;
}
} else {
result.value = thisOverlay->getProperty(property);
}
} }
return result; return result;
} }
@ -553,7 +558,9 @@ void Overlays::deletePanel(unsigned int panelId) {
} }
} }
while (!panelToDelete->children.isEmpty()) { while (!panelToDelete->getChildren().isEmpty()) {
deleteOverlay(panelToDelete->children.takeLast()); deleteOverlay(panelToDelete->popLastChild());
} }
emit panelDeleted(panelId);
} }

10
interface/src/ui/overlays/Overlays.h
View file

@ -87,9 +87,12 @@ public slots:
/// deletes a particle /// deletes a particle
void deleteOverlay(unsigned int id); void deleteOverlay(unsigned int id);
/// /// get the string type of the overlay used in addOverlay
QString getOverlayType(unsigned int overlayId) const; QString getOverlayType(unsigned int overlayId) const;
unsigned int getAttachedPanel(unsigned int childId) const;
void setAttachedPanel(unsigned int childId, unsigned int panelId);
/// returns the top most 2D overlay at the screen point, or 0 if not overlay at that point /// returns the top most 2D overlay at the screen point, or 0 if not overlay at that point
unsigned int getOverlayAtPoint(const glm::vec2& point); unsigned int getOverlayAtPoint(const glm::vec2& point);
@ -122,9 +125,12 @@ public slots:
/// deletes a panel and all child overlays /// deletes a panel and all child overlays
void deletePanel(unsigned int panelId); void deletePanel(unsigned int panelId);
signals:
void overlayDeleted(unsigned int id);
void panelDeleted(unsigned int id);
private: private:
void cleanupOverlaysToDelete(); void cleanupOverlaysToDelete();
void setAttachedPanel(Overlay::Pointer overlay, unsigned int overlayId, const QScriptValue& property);
QMap<unsigned int, Overlay::Pointer> _overlaysHUD; QMap<unsigned int, Overlay::Pointer> _overlaysHUD;
QMap<unsigned int, Overlay::Pointer> _overlaysWorld; QMap<unsigned int, Overlay::Pointer> _overlaysWorld;

46
interface/src/ui/overlays/PanelAttachable.cpp
View file

@ -11,6 +11,8 @@
#include "PanelAttachable.h" #include "PanelAttachable.h"
#include <RegisteredMetaTypes.h>
PanelAttachable::PanelAttachable() : PanelAttachable::PanelAttachable() :
_attachedPanel(nullptr), _attachedPanel(nullptr),
_facingRotation(1, 0, 0, 0) _facingRotation(1, 0, 0, 0)
@ -33,3 +35,47 @@ void PanelAttachable::setTransforms(Transform* transform) {
transform->postRotate(getFacingRotation() * getAttachedPanel()->getFacingRotation()); transform->postRotate(getFacingRotation() * getAttachedPanel()->getFacingRotation());
} }
} }
QScriptValue PanelAttachable::getProperty(QScriptEngine* scriptEngine, const QString &property) {
if (property == "offsetPosition") {
return vec3toScriptValue(scriptEngine, getOffsetPosition());
}
if (property == "facingRotation") {
return quatToScriptValue(scriptEngine, getFacingRotation());
}
return QScriptValue();
}
void PanelAttachable::setProperties(const QScriptValue &properties) {
QScriptValue offsetPosition = properties.property("offsetPosition");
if (offsetPosition.isValid()) {
QScriptValue x = offsetPosition.property("x");
QScriptValue y = offsetPosition.property("y");
QScriptValue z = offsetPosition.property("z");
if (x.isValid() && y.isValid() && z.isValid()) {
glm::vec3 newPosition;
newPosition.x = x.toVariant().toFloat();
newPosition.y = y.toVariant().toFloat();
newPosition.z = z.toVariant().toFloat();
setOffsetPosition(newPosition);
}
}
QScriptValue facingRotation = properties.property("facingRotation");
if (facingRotation.isValid()) {
QScriptValue x = facingRotation.property("x");
QScriptValue y = facingRotation.property("y");
QScriptValue z = facingRotation.property("z");
QScriptValue w = facingRotation.property("w");
if (x.isValid() && y.isValid() && z.isValid() && w.isValid()) {
glm::quat newRotation;
newRotation.x = x.toVariant().toFloat();
newRotation.y = y.toVariant().toFloat();
newRotation.z = z.toVariant().toFloat();
newRotation.w = w.toVariant().toFloat();
setFacingRotation(newRotation);
}
}
}

7
interface/src/ui/overlays/PanelAttachable.h
View file

@ -27,8 +27,11 @@ public:
glm::quat getFacingRotation() const { return _facingRotation; } glm::quat getFacingRotation() const { return _facingRotation; }
void setAttachedPanel(FloatingUIPanel::Pointer panel) { _attachedPanel = panel; } void setAttachedPanel(FloatingUIPanel::Pointer panel) { _attachedPanel = panel; }
void setOffsetPosition(glm::vec3 position) { _offsetPosition = position; } void setOffsetPosition(const glm::vec3& position) { _offsetPosition = position; }
void setFacingRotation(glm::quat rotation) { _facingRotation = rotation; } void setFacingRotation(const glm::quat& rotation) { _facingRotation = rotation; }
QScriptValue getProperty(QScriptEngine* scriptEngine, const QString& property);
void setProperties(const QScriptValue& properties);
protected: protected:
void setTransforms(Transform* transform); void setTransforms(Transform* transform);