Work on porting laser pointers to local entities, removal of LaserPointer JS API

ksuprynowicz committed 3 years ago

Commit 2a2cf381 parent 4d0303313 files · +311 −385Browse files

Showing the changes to interface/src/raypick/PointerScriptingInterface.cpp (1 of 13 files). Show all

Unified · Split

interface/src/raypick/PointerScriptingInterface.cpp+82−19

 #include "StylusPointer.h"
 #include "ParabolaPointer.h"
 #include "StylusPick.h"
+#include <ScriptManager.h>
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
+    qDebug() << "STATIC_SCRIPT_TYPES_INITIALIZER PointerScriptingInterface";
+    auto scriptEngine = manager->engine().get();
+    scriptRegisterMetaType<RayPointerProperties, rayPointerPropertiesToScriptValue, rayPointerPropertiesFromScriptValue>(scriptEngine);
+}));
 static const glm::quat X_ROT_NEG_90{ 0.70710678f, -0.70710678f, 0.0f, 0.0f };
 static const glm::vec3 DEFAULT_POSITION_OFFSET{0.0f, 0.0f, -StylusPick::WEB_STYLUS_LENGTH / 2.0f};
     DependencyManager::get<PointerManager>()->setIncludeItems(uid, qVectorQUuidFromScriptValue(includeItems));
 }
-unsigned int PointerScriptingInterface::createPointer(const PickQuery::PickType& type, const QVariant& properties) {
+unsigned int PointerScriptingInterface::createPointerInternal(const PickQuery::PickType& type, const PointerProperties& properties) {
     // Interaction with managers should always happen on the main thread
     if (QThread::currentThread() != qApp->thread()) {
         unsigned int result;
-        BLOCKING_INVOKE_METHOD(this, "createPointer", Q_RETURN_ARG(unsigned int, result), Q_ARG(PickQuery::PickType, type), Q_ARG(QVariant, properties));
+        BLOCKING_INVOKE_METHOD(this, "createPointerInternal", Q_RETURN_ARG(unsigned int, result), Q_ARG(PickQuery::PickType, type), Q_ARG(PointerProperties, properties));
         return result;
     }
-    QVariantMap propertyMap = properties.toMap();
+    QVariantMap propertyMap = properties.properties;
     std::shared_ptr<Pointer> pointer;
     switch (type) {
         case PickQuery::PickType::Ray:
-            pointer = buildLaserPointer(propertyMap);
+            pointer = buildLaserPointer(properties);
             break;
         case PickQuery::PickType::Stylus:
-            pointer = buildStylus(propertyMap);
+            pointer = buildStylus(properties);
             break;
         case PickQuery::PickType::Parabola:
-            pointer = buildParabolaPointer(propertyMap);
+            pointer = buildParabolaPointer(properties);
             break;
         default:
             break;
     return DependencyManager::get<PointerManager>()->addPointer(pointer);
 }
+unsigned int PointerScriptingInterface::createRayPointer(RayPointerProperties properties) {
+    return createPointerInternal(PickQuery::PickType::Ray, properties);
+}
 bool PointerScriptingInterface::isPointerEnabled(unsigned int uid) const {
     return DependencyManager::get<PointerManager>()->isPointerEnabled(uid);
 }
  *     offset.
  * @property {Quat} [rotationOffset] - The rotation offset of the model from the hand, to override the default rotation offset.
  */
-std::shared_ptr<Pointer> PointerScriptingInterface::buildStylus(const QVariant& properties) {
+std::shared_ptr<Pointer> PointerScriptingInterface::buildStylus(const PointerProperties& properties) {
-    QVariantMap propertyMap = properties.toMap();
+    QVariantMap propertyMap = properties.properties;
     bool hover = false;
     if (propertyMap["hover"].isValid()) {
         }
     }
-    return std::make_shared<StylusPointer>(properties, StylusPointer::buildStylus(propertyMap), hover, enabled, modelPositionOffset, modelRotationOffset, modelDimensions);
+    return std::make_shared<StylusPointer>(properties.properties, StylusPointer::buildStylus(propertyMap), hover, enabled, modelPositionOffset, modelRotationOffset, modelDimensions);
 }
 /*@jsdoc
  *     {@link Pointers.getPointerProperties}.
  * @see {@link Picks.RayPickProperties} for additional properties from the underlying ray pick.
  */
-std::shared_ptr<Pointer> PointerScriptingInterface::buildLaserPointer(const QVariant& properties) {
+std::shared_ptr<Pointer> PointerScriptingInterface::buildLaserPointer(const PointerProperties& properties) {
-    QVariantMap propertyMap = properties.toMap();
+    QVariantMap propertyMap = properties.properties;
 #if defined (Q_OS_ANDROID)
     QString jointName { "" };
                 QVariantMap renderStateMap = renderStateVariant.toMap();
                 if (renderStateMap["name"].isValid()) {
                     std::string name = renderStateMap["name"].toString().toStdString();
-                    renderStates[name] = LaserPointer::buildRenderState(renderStateMap);
+                    renderStates[name] = LaserPointer::buildRenderState(renderStateMap, properties.entityProperties);
                 }
             }
         }
                 if (renderStateMap["name"].isValid() && renderStateMap["distance"].isValid()) {
                     std::string name = renderStateMap["name"].toString().toStdString();
                     float distance = renderStateMap["distance"].toFloat();
-                    defaultRenderStates[name] = std::pair<float, std::shared_ptr<StartEndRenderState>>(distance, LaserPointer::buildRenderState(renderStateMap));
+                    defaultRenderStates[name] = std::pair<float, std::shared_ptr<StartEndRenderState>>(distance,
+                    LaserPointer::buildRenderState(renderStateMap, properties.entityProperties));
                 }
             }
         }
         }
     }
-    return std::make_shared<LaserPointer>(properties, renderStates, defaultRenderStates, hover, triggers,
+    return std::make_shared<LaserPointer>(properties.properties, renderStates, defaultRenderStates, hover, triggers,
                                           faceAvatar, followNormal, followNormalStrength, centerEndY, lockEnd,
                                           distanceScaleEnd, scaleWithParent, enabled);
 }
  *     {@link Pointers.getPointerProperties}.
  * @see {@link Picks.ParabolaPickProperties} for additional properties from the underlying parabola pick.
  */
-std::shared_ptr<Pointer> PointerScriptingInterface::buildParabolaPointer(const QVariant& properties) {
+std::shared_ptr<Pointer> PointerScriptingInterface::buildParabolaPointer(const PointerProperties& properties) {
-    QVariantMap propertyMap = properties.toMap();
+    QVariantMap propertyMap = properties.properties;
     bool faceAvatar = false;
     if (propertyMap["faceAvatar"].isValid()) {
                 QVariantMap renderStateMap = renderStateVariant.toMap();
                 if (renderStateMap["name"].isValid()) {
                     std::string name = renderStateMap["name"].toString().toStdString();
-                    renderStates[name] = ParabolaPointer::buildRenderState(renderStateMap);
+                    renderStates[name] = ParabolaPointer::buildRenderState(renderStateMap, properties.entityProperties);
                 }
             }
         }
                 if (renderStateMap["name"].isValid() && renderStateMap["distance"].isValid()) {
                     std::string name = renderStateMap["name"].toString().toStdString();
                     float distance = renderStateMap["distance"].toFloat();
-                    defaultRenderStates[name] = std::pair<float, std::shared_ptr<StartEndRenderState>>(distance, ParabolaPointer::buildRenderState(renderStateMap));
+                    defaultRenderStates[name] = std::pair<float, std::shared_ptr<StartEndRenderState>>(distance,
+                        ParabolaPointer::buildRenderState(renderStateMap, properties.entityProperties));
                 }
             }
         }
         }
     }
-    return std::make_shared<ParabolaPointer>(properties, renderStates, defaultRenderStates, hover, triggers,
+    return std::make_shared<ParabolaPointer>(properties.properties, renderStates, defaultRenderStates, hover, triggers,
                                              faceAvatar, followNormal, followNormalStrength, centerEndY, lockEnd, distanceScaleEnd,
                                              scaleWithParent, enabled);
 }
 void PointerScriptingInterface::editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const {
+    //V8TODO: this won't work for now
     QVariantMap propMap = properties.toMap();
     QVariant startProps;
     }
     return result;
 }
+ScriptValue rayPointerPropertiesToScriptValue(ScriptEngine* engine, const RayPointerProperties& in) {
+    return engine->newVariant(QVariant(in.properties));
+}
+bool rayPointerPropertiesFromScriptValue(const ScriptValue& value, RayPointerProperties& out) {
+    // This copies properties from script value, but also converts entity properties of entities used in render states
+    // from JS objects into EntityItemProperties
+    out.properties = value.engine()->fromScriptValue<QVariantMap>(value);
+    if (out.properties["renderStates"].canConvert<QVariantList>()) {
+        QVariantList renderStates = out.properties["renderStates"].value<QVariantList>();
+        for( int i = 0; i < renderStates.length(); i++) {
+            if (renderStates[i].canConvert<QVariantMap>()) {
+                QVariantMap stateMap = renderStates[i].value<QVariantMap>();
+                if (stateMap["name"].canConvert<QString>()) {
+                    stateMap["name"].value<QString>();
+                }
+                if (stateMap["start"].isValid()) {
+                    ScriptValue start = value.property("renderStates").property(i).property("start");
+                    EntityItemProperties startProperties;
+                    startProperties.copyFromScriptValue(start, false);
+                    stateMap.insert("startPropertyIndex", QVariant(out.entityProperties.length()));
+                    out.entityProperties.append(startProperties);
+                }
+                if (stateMap["path"].isValid()) {
+                    ScriptValue path = value.property("renderStates").property(i).property("path");
+                    EntityItemProperties pathProperties;
+                    pathProperties.copyFromScriptValue(path, false);
+                    stateMap.insert("pathPropertyIndex", QVariant(out.entityProperties.length()));
+                    out.entityProperties.append(pathProperties);
+                }
+                if (stateMap["end"].isValid()) {
+                    ScriptValue end = value.property("renderStates").property(i).property("end");
+                    EntityItemProperties endProperties;
+                    endProperties.copyFromScriptValue(end, false);
+                    stateMap.insert("endPropertyIndex", QVariant(out.entityProperties.length()));
+                    out.entityProperties.append(endProperties);
+                }
+                // V8TODO: Check if path is a polyline and if values are valid
+                renderStates[i].setValue(stateMap);
+            }
+        }
+        out.properties["renderStates"].setValue(renderStates);
+    }
+    qDebug() << "rayPointerPropertiesFromScriptValue" << out.properties;
+    return true;
+}