start on code to de/serialize actions

interface/src/InterfaceActionFactory.cpp

@@ -18,32 +18,53 @@
 #include "InterfaceActionFactory.h"
 
 
+EntityActionPointer interfaceActionFactory(EntityActionType type, QUuid id, EntityItemPointer ownerEntity) {
+    switch (type) {
+        case ACTION_TYPE_NONE:
+            return nullptr;
+        case ACTION_TYPE_OFFSET:
+            return (EntityActionPointer) new ObjectActionOffset(id, ownerEntity);
+        case ACTION_TYPE_SPRING:
+            return (EntityActionPointer) new ObjectActionSpring(id, ownerEntity);
+        case ACTION_TYPE_HOLD:
+            return (EntityActionPointer) new AvatarActionHold(id, ownerEntity);
+    }
+
+    assert(false);
+    return nullptr;
+}
+
+
 EntityActionPointer InterfaceActionFactory::factory(EntitySimulation* simulation,
                                                     EntityActionType type,
                                                     QUuid id,
                                                     EntityItemPointer ownerEntity,
                                                     QVariantMap arguments) {
-    EntityActionPointer action = nullptr;
-    switch (type) {
-        case ACTION_TYPE_NONE:
-            return nullptr;
-        case ACTION_TYPE_OFFSET:
-            action = (EntityActionPointer) new ObjectActionOffset(id, ownerEntity);
-            break;
-        case ACTION_TYPE_SPRING:
-            action = (EntityActionPointer) new ObjectActionSpring(id, ownerEntity);
-            break;
-        case ACTION_TYPE_HOLD:
-            action = (EntityActionPointer) new AvatarActionHold(id, ownerEntity);
-            break;
+    EntityActionPointer action = interfaceActionFactory(type, id, ownerEntity);
+    if (action) {
+        bool ok = action->updateArguments(arguments);
+        if (ok) {
+            ownerEntity->addAction(simulation, action);
+            return action;
+        }
     }
-
-    bool ok = action->updateArguments(arguments);
-    if (ok) {
-        ownerEntity->addAction(simulation, action);
-        return action;
-    }
-
-    action = nullptr;
+    return action;
+}
+
+
+EntityActionPointer InterfaceActionFactory::factoryBA(EntitySimulation* simulation,
+                                                      EntityItemPointer ownerEntity,
+                                                      QByteArray data) {
+    QDataStream ds(data);
+    EntityActionType type;
+    QUuid id;
+
+    ds >> type;
+    ds >> id;
+
+    EntityActionPointer action = interfaceActionFactory(type, id, ownerEntity);
+
+    action->deserializeFromDataStream(ds);
+    ownerEntity->addAction(simulation, action);
     return action;
 }

interface/src/InterfaceActionFactory.h

@@ -23,6 +23,9 @@ public:
                                         QUuid id,
                                         EntityItemPointer ownerEntity,
                                         QVariantMap arguments);
+    virtual EntityActionPointer factoryBA(EntitySimulation* simulation,
+                                          EntityItemPointer ownerEntity,
+                                          QByteArray data);
 };
 
 #endif // hifi_InterfaceActionFactory_h

interface/src/avatar/AvatarActionHold.cpp

@@ -115,3 +115,16 @@ bool AvatarActionHold::updateArguments(QVariantMap arguments) {
     unlock();
     return true;
 }
+
+void AvatarActionHold::serializeToDataStream(QDataStream& dataStream) {
+    dataStream << _relativePosition;
+    dataStream << _relativeRotation;
+    dataStream << _hand;
+}
+
+void AvatarActionHold::deserializeFromDataStream(QDataStream& dataStream) {
+    dataStream >> _relativePosition;
+    dataStream >> _relativeRotation;
+    dataStream >> _hand;
+    _parametersSet = true;
+}

interface/src/avatar/AvatarActionHold.h

@@ -22,9 +22,15 @@ public:
     AvatarActionHold(QUuid id, EntityItemPointer ownerEntity);
     virtual ~AvatarActionHold();
 
+    virtual EntityActionType getType() { return ACTION_TYPE_HOLD; }
+
     virtual bool updateArguments(QVariantMap arguments);
     virtual void updateActionWorker(float deltaTimeStep);
 
+protected:
+    void serializeToDataStream(QDataStream& dataStream);
+    void deserializeFromDataStream(QDataStream& dataStream);
+
 private:
     glm::vec3 _relativePosition;
     glm::quat _relativeRotation;

libraries/entities/src/EntityActionFactoryInterface.h

@@ -28,6 +28,9 @@ class EntityActionFactoryInterface : public QObject, public Dependency {
                                         QUuid id,
                                         EntityItemPointer ownerEntity,
                                         QVariantMap arguments) { assert(false); return nullptr; }
+    virtual EntityActionPointer factoryBA(EntitySimulation* simulation,
+                                          EntityItemPointer ownerEntity,
+                                          QByteArray data) { assert(false); return nullptr; }
 };
 
 #endif // hifi_EntityActionFactoryInterface_h

libraries/entities/src/EntityActionInterface.cpp

@@ -174,3 +174,27 @@ QString EntityActionInterface::extractStringArgument(QString objectName, QVarian
     QString v = vV.toString();
     return v;
 }
+
+QByteArray EntityActionInterface::serialize() {
+    QByteArray ba;
+    QDataStream ds(&ba, QIODevice::WriteOnly);
+
+    ds << getType();
+    ds << getID();
+
+    serializeToDataStream(ds);
+    return ba;
+}
+
+QDataStream& operator<<(QDataStream& stream, const EntityActionType& entityActionType)
+{
+    return stream << (quint8)entityActionType;
+}
+
+QDataStream& operator>>(QDataStream& stream, EntityActionType& entityActionType)
+{
+    quint8 v;
+    stream >> v;
+    entityActionType = (EntityActionType)v;
+    return stream;
+}

libraries/entities/src/EntityActionInterface.h

@@ -32,11 +32,17 @@ public:
     EntityActionInterface() { }
     virtual ~EntityActionInterface() { }
     virtual const QUuid& getID() const = 0;
+    virtual EntityActionType getType() { assert(false); return ACTION_TYPE_NONE; }
+
     virtual void removeFromSimulation(EntitySimulation* simulation) const = 0;
     virtual const EntityItemPointer& getOwnerEntity() const = 0;
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) = 0;
     virtual bool updateArguments(QVariantMap arguments) = 0;
 
+    virtual QByteArray serialize();
+    virtual void serializeToDataStream(QDataStream& dataStream) = 0;
+    virtual void deserializeFromDataStream(QDataStream& dataStream) = 0;
+
     static EntityActionType actionTypeFromString(QString actionTypeString);
     static QString actionTypeToString(EntityActionType actionType);
 
@@ -67,4 +73,7 @@ protected:
 
 typedef std::shared_ptr<EntityActionInterface> EntityActionPointer;
 
+QDataStream& operator<<(QDataStream& stream, const EntityActionType& entityActionType);
+QDataStream& operator>>(QDataStream& stream, EntityActionType& entityActionType);
+
 #endif // hifi_EntityActionInterface_h

libraries/physics/src/ObjectAction.h

@@ -30,6 +30,7 @@ public:
     virtual ~ObjectAction();
 
     const QUuid& getID() const { return _id; }
+    virtual EntityActionType getType() { assert(false); return ACTION_TYPE_NONE; }
     virtual void removeFromSimulation(EntitySimulation* simulation) const;
     virtual const EntityItemPointer& getOwnerEntity() const { return _ownerEntity; }
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) { _ownerEntity = ownerEntity; }
@@ -47,6 +48,9 @@ private:
     QReadWriteLock _lock;
 
 protected:
+    virtual void serializeToDataStream(QDataStream& dataStream) = 0;
+    virtual void deserializeFromDataStream(QDataStream& dataStream) = 0;
+
     virtual btRigidBody* getRigidBody();
     virtual glm::vec3 getPosition();
     virtual void setPosition(glm::vec3 position);

libraries/physics/src/ObjectActionOffset.cpp

@@ -107,3 +107,17 @@ bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
     unlock();
     return true;
 }
+
+void ObjectActionOffset::serializeToDataStream(QDataStream& dataStream) {
+    dataStream << _pointToOffsetFrom;
+    dataStream << _linearDistance;
+    dataStream << _linearTimeScale;
+    dataStream << _positionalTargetSet;
+}
+
+void ObjectActionOffset::deserializeFromDataStream(QDataStream& dataStream) {
+    dataStream >> _pointToOffsetFrom;
+    dataStream >> _linearDistance;
+    dataStream >> _linearTimeScale;
+    dataStream >> _positionalTargetSet;
+}

libraries/physics/src/ObjectActionOffset.h

@@ -22,9 +22,15 @@ public:
     ObjectActionOffset(QUuid id, EntityItemPointer ownerEntity);
     virtual ~ObjectActionOffset();
 
+    virtual EntityActionType getType() { return ACTION_TYPE_OFFSET; }
+
     virtual bool updateArguments(QVariantMap arguments);
     virtual void updateActionWorker(float deltaTimeStep);
 
+protected:
+    virtual void serializeToDataStream(QDataStream& dataStream);
+    virtual void deserializeFromDataStream(QDataStream& dataStream);
+
 private:
     glm::vec3 _pointToOffsetFrom;
     float _linearDistance;

libraries/physics/src/ObjectActionSpring.cpp

@@ -142,3 +142,24 @@ bool ObjectActionSpring::updateArguments(QVariantMap arguments) {
     unlock();
     return true;
 }
+
+
+void ObjectActionSpring::serializeToDataStream(QDataStream& dataStream) {
+    dataStream << _positionalTarget;
+    dataStream << _linearTimeScale;
+    dataStream << _positionalTargetSet;
+
+    dataStream << _rotationalTarget;
+    dataStream << _angularTimeScale;
+    dataStream << _rotationalTargetSet;
+}
+
+void ObjectActionSpring::deserializeFromDataStream(QDataStream& dataStream) {
+    dataStream >> _positionalTarget;
+    dataStream >> _linearTimeScale;
+    dataStream >> _positionalTargetSet;
+
+    dataStream >> _rotationalTarget;
+    dataStream >> _angularTimeScale;
+    dataStream >> _rotationalTargetSet;
+}

libraries/physics/src/ObjectActionSpring.h

@@ -22,10 +22,14 @@ public:
     ObjectActionSpring(QUuid id, EntityItemPointer ownerEntity);
     virtual ~ObjectActionSpring();
 
+    virtual EntityActionType getType() { return ACTION_TYPE_SPRING; }
+
     virtual bool updateArguments(QVariantMap arguments);
     virtual void updateActionWorker(float deltaTimeStep);
 
 protected:
+    virtual void serializeToDataStream(QDataStream& dataStream);
+    virtual void deserializeFromDataStream(QDataStream& dataStream);
 
     glm::vec3 _positionalTarget;
     float _linearTimeScale;