environmentObjectsCommands.h

Go to the documentation of this file.

//  ConscienceRobotManager
//
//  Created by Louis Grignon on 21/12/2022.
//  Copyright © 2022 IliesZaoui. All rights reserved.
//
#ifndef environmentObjectsCommands_h
#define environmentObjectsCommands_h
 
#include "CommandCommons.h"
 
namespace conscience_core::bridging::commands::environment_objects {
 
// Structure pour définir un objet dans l'environnement 3D de Conscience
struct CSC_DLL_IMPORTEXPORT WorldObjectCommandDataType {
    WorldObjectCommandDataType();
 
    WorldObjectCommandDataType(
        const string &id,
        const string &name,
        const string &modelId,
        const CscPoint3d *position,
        const CscRotation3dEuler *rotationEuler,
        const CscQuaternion *rotationQuaternion);
 
    ~WorldObjectCommandDataType();
 
    string id;
    string name;
    string modelId;
    const CscPoint3d *position = nullptr;
    const CscRotation3dEuler *rotationEuler = nullptr;
    const CscQuaternion *rotationQuaternion = nullptr;
 
    static vector<WorldObjectCommandDataType *> fromObjects(const vector<CscWorldObject *> &objects);
};
 
// Structure pour les filtres d'objets
struct CSC_DLL_IMPORTEXPORT ObjectsFiltersCommandDataType {
 
    ~ObjectsFiltersCommandDataType();
 
    ObjectsFiltersCommandDataType(
        const CscArea3d *zone = nullptr,
        const optional<vector<string>> &ids = {},
        const optional<vector<string>> &modelIds = {},
        const optional<vector<string>> &names = {});
 
    const CscArea3d *zone;
    optional<vector<string>> ids;
    optional<vector<string>> modelIds;
    optional<vector<string>> names;
};
 
COMMAND_TYPE_BUILDER(ObjectsFilters, ObjectsFiltersCommandDataType, const CscArea3d *, optional<vector<string>>, optional<vector<string>>, optional<vector<string>>)
 
 
class CSC_DLL_IMPORTEXPORT CommandGetObjects : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECTS_GET";
 
    CommandGetObjects(const optional<ptr<ObjectsFiltersCommandDataType>> &filters = nullopt);
 
    ~CommandGetObjects() override;
 
protected:
    const CscCommandExecutionResultList<WorldObjectCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    optional<ptr<ObjectsFiltersCommandDataType>> filters;
};
COMMAND_TYPE_BUILDER(CommandGetObjects, CscPoint3d, double, double, double)
COMMAND_RESULT_JSON_SERIALIZER(CscRotation3dEuler, pitch, yaw, roll)
COMMAND_RESULT_JSON_SERIALIZER(CscQuaternion, w, x, y, z)
COMMAND_RESULT_JSON_SERIALIZER(WorldObjectCommandDataType,
                               id,
                               name,
                               modelId,
                               position,
                               rotationEuler,
                               rotationQuaternion)
COMMAND_REGISTER(CommandGetObjects, const optional<ptr<ObjectsFiltersCommandDataType>> &)
 
// Structure pour les objets en attente d'insertion
struct CSC_DLL_IMPORTEXPORT ObjectPendingInsertionCommandDataType {
    ObjectPendingInsertionCommandDataType();
    ~ObjectPendingInsertionCommandDataType();
 
    ObjectPendingInsertionCommandDataType(
        const string &name,
        const string &modelId,
        const CscPoint3d *position,
        const CscPoint3d *rotation = nullptr,
        const optional<double> &mass = nullopt,
        const optional<CscPhysicsType> &physiqueType = nullopt,
        const optional<string> &positionRelativeToRobotMember = nullopt,
        const optional<string> &robotSerialNumber = nullopt);
 
    string name;
    string modelId;
    const CscPoint3d *position;
    const CscPoint3d *rotation;
    optional<double> mass;
    optional<CscPhysicsType> physiqueType;
    optional<string> positionRelativeToRobotMember;
    optional<string> robotSerialNumber;
};
 
class CSC_DLL_IMPORTEXPORT CommandInsertObjects : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECTS_INSERT";
 
    CommandInsertObjects(const vector<ptr<ObjectPendingInsertionCommandDataType>> &objects);
 
    ~CommandInsertObjects() override;
 
protected:
    const CscCommandExecutionResultList<string> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    vector<ptr<ObjectPendingInsertionCommandDataType>> objects;
};
COMMAND_TYPE_BUILDER(CommandInsertObjects, ObjectPendingInsertionCommandDataType, const string &, const string &, const CscPoint3d *, CscPoint3d *, optional<double>, optional<CscPhysicsType>, optional<string>, optional<string>)
COMMAND_REGISTER(CommandInsertObjects, const vector<ptr<ObjectPendingInsertionCommandDataType>> &)
 
// Structure pour les modèles d'objets
struct CSC_DLL_IMPORTEXPORT ObjectModelCommandDataType {
    ObjectModelCommandDataType();
 
    ObjectModelCommandDataType(
        const string &id,
        const string &name,
        unsigned long long lastModificationTimeMillis);
 
    string id;
    string name;
    unsigned long long lastModificationTimeMillis;
};
 
COMMAND_TYPE_BUILDER(ObjectModel, ObjectModelCommandDataType, string, string, unsigned long long)
 
// Structure pour les filtres de modèles d'objets
struct CSC_DLL_IMPORTEXPORT ObjectModelsGetFiltersCommandDataType {
    ObjectModelsGetFiltersCommandDataType();
 
    ObjectModelsGetFiltersCommandDataType(const optional<string> &objectId);
 
    optional<string> objectId;
};
 
class CSC_DLL_IMPORTEXPORT CommandObjectModelsGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECT_MODELS_GET";
 
    CommandObjectModelsGet(const optional<ptr<ObjectModelsGetFiltersCommandDataType>> &filters = nullopt);
 
    ~CommandObjectModelsGet() override;
 
protected:
    const CscCommandExecutionResultList<ObjectModelCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    optional<ptr<ObjectModelsGetFiltersCommandDataType>> filters;
};
COMMAND_TYPE_BUILDER(CommandObjectModelsGet, ObjectModelsGetFiltersCommandDataType, optional<string>)
COMMAND_RESULT_JSON_SERIALIZER(ObjectModelCommandDataType, id,
    name,
    lastModificationTimeMillis)
COMMAND_REGISTER(CommandObjectModelsGet, const optional<ptr<ObjectModelsGetFiltersCommandDataType>> &)
 
 
class CSC_DLL_IMPORTEXPORT CommandObjectModelLogoGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECT_MODEL_LOGO_GET";
 
    CommandObjectModelLogoGet(const string &objectModelId);
 
    ~CommandObjectModelLogoGet() override;
 
protected:
    const CscCommandExecutionResultBinary *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string objectModelId;
};
 
COMMAND_REGISTER(CommandObjectModelLogoGet, const string &)
 
 
class CSC_DLL_IMPORTEXPORT CommandRemoveObjects : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECTS_REMOVE";
 
    CommandRemoveObjects(const optional<ptr<ObjectsFiltersCommandDataType>> &filters = nullopt);
 
    ~CommandRemoveObjects() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    optional<ptr<ObjectsFiltersCommandDataType>> filters;
};
 
COMMAND_REGISTER(CommandRemoveObjects, const optional<ptr<ObjectsFiltersCommandDataType>> &)
 
 
class CSC_DLL_IMPORTEXPORT CommandObjectsClear : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECTS_CLEAR";
 
    CommandObjectsClear();
    ~CommandObjectsClear() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
};
 
COMMAND_REGISTER(CommandObjectsClear)
 
 
class CSC_DLL_IMPORTEXPORT CommandObjectModelSourceFileGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECT_MODEL_SOURCE_FILE_GET";
 
    CommandObjectModelSourceFileGet(const string &objectModelId, CscWorldElementModelFormat format);
    ~CommandObjectModelSourceFileGet() override;
 
protected:
    const CscCommandExecutionResultBinary *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string objectModelId;
    CscWorldElementModelFormat format;
};
 
COMMAND_REGISTER(CommandObjectModelSourceFileGet, const string &, CscWorldElementModelFormat)
 
class CSC_DLL_IMPORTEXPORT CommandObjectInsert : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "OBJECT_INSERT";
 
    CommandObjectInsert(const ptr<const CscObjectModel> &objectModel,
                        const string &name,
                        const CscPoint3d *position, const CscPoint3d *rotation,
                        optional<double> mass,
                        optional<CscPhysicsType> physiqueType,
                        optional<string> positionRelativeToRobotMember,
                        optional<string> robotSerialNumber);
    ~CommandObjectInsert() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const string name;
    ptr<const CscObjectModel> objectModel;
    const CscPoint3d *position;
    const CscPoint3d *rotation;
    optional<double> mass;
    optional<CscPhysicsType> physiqueType;
    optional<string> positionRelativeToRobotMember;
    optional<string> robotSerialNumber;
};
 
COMMAND_TYPE_BUILDER(CommandObjectInsert, CscObjectModel, const Csc3dElementType &,
                     const string &,
                     const string &,
                     const optional<string> &,
                     const optional<string> &,
                     unsigned long long)
 
COMMAND_REGISTER(CommandObjectInsert, const ptr<CscObjectModel> &,
                 const string &,
                 const CscPoint3d*,
                 const CscPoint3d*,
                 optional<double>,
                 optional<CscPhysicsType>,
                 optional<string>,
                 optional<string>);
 
}
 
#endif