ManagedDesignCommand.h

#pragma once
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Material.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/StringEnum.h>
namespace NDEVR
{

#define NDEVR_MANAGED_COMMAND_TYPES(X) \
            X(e_none) \
            X(e_validate) \
            X(e_set_geometry_property) \
            X(e_set_material_property) \
            X(e_set_model_property) \
            X(e_set_model_material_mode) \
            X(e_set_design_property) \
            X(e_create_property) \
            X(e_normal_expansion) \
            X(e_set_winding_mode) \
            X(e_center_align) \
            X(e_smooth_laplacian) \
            X(e_smooth_cotangent) \
            X(e_remove_smoothing) \
            X(e_fill_holes_by_neighbor) \
            X(e_make_closed_solid) \
            X(e_update_vertex) \
            X(e_calculate_tangents) \
            X(e_set_normal_mode) \
            X(e_flip_normals) \
            X(e_remove_duplicates) \
            X(e_set_UV_mode) \
            X(e_set_UV_color) \
            X(e_set_UV_image) \
            X(e_set_real_thickness) \
            X(e_scale_object) \
            X(e_set_UV_intensity) \
            X(e_set_UV_property_channel) \
            X(e_set_shader) \
            X(e_calibrate_scan) \
            X(e_delete_enclosed_area) \
            X(e_explode) \
            X(e_group) \
            X(e_clear_all) \
            X(e_color_by_channel) \
            X(e_read_from_file) \
            X(e_read_from_database) \
            X(e_create_material) \
            X(e_create_geometry) \
            X(e_delete_object) \
            X(e_set_metadata) \
            X(e_append_data) \
            X(e_set_active_filters) \
            X(e_add_active_filters) \
            X(e_slice_into_polylines) \
            X(e_remove_filter) \
            X(e_auto_register) \
            X(e_place_object) \
            X(e_select_objects) \
            X(e_set_size)
    NDEVR_DEFINE_STRING_STREAM(ManagedCommandType, NDEVR_MANAGED_COMMAND_TYPES);

    class ManagedDesignCommand : public DesignCommand
    {
 
    public:
        NDEVR_DESIGN_API ManagedDesignCommand();
    protected:
        NDEVR_DESIGN_API explicit ManagedDesignCommand(ManagedCommandType command);
        NDEVR_DESIGN_API ManagedDesignCommand(ManagedCommandType command, const String& params);

        template<class t_arg_type>
        ManagedDesignCommand(ManagedCommandType command, const t_arg_type& param_a)
            : command_type(command)
        {
            setParams(String(param_a));
        }

        template<class t_arg_type_a, class t_arg_type_b>
        ManagedDesignCommand(ManagedCommandType command, const t_arg_type_a& param_a, const t_arg_type_b& param_b)
            : command_type(command)
        {
            setParams(String(param_a) + "|" + String(param_b));
        }

        template<class t_arg_type_a, class t_arg_type_b, class t_arg_type_c>
        ManagedDesignCommand(ManagedCommandType command, const t_arg_type_a& param_a, const t_arg_type_b& param_b, const t_arg_type_c& param_c)
            : command_type(command)
        {
            setParams(String(param_a) + "|" + String(param_b) + "|" + String(param_c));
        }

        template<class t_arg_type_a, class t_arg_type_b, class t_arg_type_c, class t_arg_type_d>
        ManagedDesignCommand(ManagedCommandType command, const t_arg_type_a& param_a, const t_arg_type_b& param_b, const t_arg_type_c& param_c, const t_arg_type_d& param_d)
            : command_type(command)
        {
            setParams(String(param_a) + "|" + String(param_b) + "|" + String(param_c) + "|" + String(param_d));
        }
    public:
        NDEVR_DESIGN_API bool isAsyncExecution() const override;
        void setParams(const Buffer<String>& params)
        {
            m_command_params = params;
        }

        void setParams(const String& params)
        {
            m_command_params = StringView::Convert(params.split('|'));
        }

        const Buffer<String>& params() const
        {
            return m_command_params;
        }

        const Buffer<String>& undoParams(const UUID& uuid) const
        {
            auto iter = m_undo_params.find(uuid);
            if (iter == m_undo_params.end())
            {
                static Buffer<String> empty;
                return empty;
            }
            return iter.value();
        }

        const Dictionary<UUID, Buffer<String>>& undoParams() const
        {
            return m_undo_params;
        }

        Dictionary<UUID, Buffer<String>> undoParams()
        {
            return m_undo_params;
        }

        template<class t_arg_type>
        void setUndoParams(const UUID& uuid, const t_arg_type& params)
        {
            m_undo_params[uuid] = { String(params) };
        }

        template<class t_arg_type_a, class t_arg_type_b>
        void setUndoParams(const UUID& uuid, const t_arg_type_a& param_a, const t_arg_type_b& param_b)
        {
            m_undo_params[uuid] = {String(param_a), String(param_b)};
        }

        template<class t_arg_type_a, class t_arg_type_b, class t_arg_type_c>
        void setUndoParams(const UUID& uuid, const t_arg_type_a& param_a, const t_arg_type_b& param_b, const t_arg_type_c& param_c)
        {
            m_undo_params[uuid] = { String(param_a), String(param_b), String(param_c) };
        }

        bool hasUndo(const UUID& uuid) const
        {
            return m_undo_params.hasKey(uuid);
        }

        NDEVR_DESIGN_API void execute(DesignObjectLookup* lookup) override;
        NDEVR_DESIGN_API bool canGroupWith(const DynamicPointer<DesignCommand>& command) override;
        NDEVR_DESIGN_API bool canCombineWith(const DynamicPointer<DesignCommand>& command) override;
        NDEVR_DESIGN_API void combineWith(const DynamicPointer<DesignCommand>& command) override;
        void removeUndo(const UUID& uuid)
        {
            m_undo_params.erase(uuid);
        }

        static DynamicPointer<ManagedDesignCommand> PlaceObject(const Matrix<fltp08>& transform)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_place_object, transform);
        }

        template<class t_type>
        static DynamicPointer<ManagedDesignCommand> set(NDPG geo_property, const t_type& value)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_geometry_property, geo_property, value);
        }

        template<class t_type>
        static DynamicPointer<ManagedDesignCommand> SetMaterialProperty(NDPM mat_property, const t_type& value)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_material_property, mat_property, value);
        }

        template<class t_type>
        static DynamicPointer<ManagedDesignCommand> set(NDPN mod_property, const t_type& value)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_model_property, mod_property, value);
        }

        static DynamicPointer<ManagedDesignCommand> SetModelMaterialMode(Model::MaterialMode mode)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_model_material_mode, mode);
        }

        template<class t_type>
        static DynamicPointer<ManagedDesignCommand> SetProperty(NDPO design_property, const t_type& value)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_design_property, design_property, value);
        }

        static DynamicPointer<ManagedDesignCommand> Delete()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_delete_object);
        }

        static DynamicPointer<ManagedDesignCommand> CreateGeometry(const StringView& name = StringView())
        {
            return new ManagedDesignCommand(ManagedCommandType::e_create_geometry, name);
        }

        static DynamicPointer<ManagedDesignCommand> SetSize(const Vector<3, fltp08>& size)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_size, size);
        }

        static DynamicPointer<ManagedDesignCommand> CreateMaterial(const StringView& name = StringView())
        {
            return new ManagedDesignCommand(ManagedCommandType::e_create_material, name);
        }

        static DynamicPointer<ManagedDesignCommand> ValidateCommand()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_validate);
        }

        static DynamicPointer<ManagedDesignCommand> ScaleObject(const fltp08& scale)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_scale_object, Vector<3, fltp08>(scale));
        }

        static DynamicPointer<ManagedDesignCommand> ScaleObject(const Vector<3, fltp08>& scale)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_scale_object, scale);
        }

        static DynamicPointer<ManagedDesignCommand> ScaleObject(const fltp08& scale, const Vector<3, fltp08>& scale_center)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_scale_object, Vector<3, fltp08>(scale), scale_center);
        }

        static DynamicPointer<ManagedDesignCommand> ScaleObject(const Vector<3, fltp08>& scale, const Vector<3, fltp08>& scale_center)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_scale_object, scale, scale_center);
        }

        static DynamicPointer<ManagedDesignCommand> SetRealThickness(fltp08 real_thickness)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_real_thickness, real_thickness);
        }

        static DynamicPointer<ManagedDesignCommand> SmoothLaplacianCommand(uint04 number_of_iterations)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_smooth_laplacian, number_of_iterations);
        }

        static DynamicPointer<ManagedDesignCommand> SmoothCotangentCommand(uint04 number_of_iterations)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_smooth_cotangent, number_of_iterations);
        }

        static DynamicPointer<ManagedDesignCommand> SmoothLaplacianCommand(uint04 number_of_iterations, fltp08 shrink_rate, fltp08 grow_rate)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_smooth_laplacian, number_of_iterations, shrink_rate, grow_rate);
        }

        static DynamicPointer<ManagedDesignCommand> SmoothCotangentCommand(uint04 number_of_iterations, fltp08 shrink_rate, fltp08 grow_rate)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_smooth_cotangent, number_of_iterations, shrink_rate, grow_rate);
        }

        template<class t_type>
        static DynamicPointer<ManagedDesignCommand> UpdateVertex(VertexProperty property, uint04 vertex_id, const t_type& new_location)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_update_vertex, property, vertex_id, new_location);
        }

        static DynamicPointer<ManagedDesignCommand> RemoveSmoothingCommand()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_remove_smoothing);
        }

        static DynamicPointer<ManagedDesignCommand> RemoveDuplicateVertices()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_remove_duplicates);
        }

        static DynamicPointer<ManagedDesignCommand> DeleteEnclosedArea()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_delete_enclosed_area);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVMode(UVType uv_type, Material::UVMode uv_mode)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_mode, uv_type, uv_mode);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVColor(const RGBColor& uv_color)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_color, uv_color);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVColor(UVType uv_type, const RGBColor& uv_color)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_color, uv_type, uv_color);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVImage(UVType uv_type, const String& uv_image)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_image, uv_type, uv_image);
        }

        static DynamicPointer<ManagedDesignCommand> FillHolesByNeighbor()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_fill_holes_by_neighbor);
        }

        static DynamicPointer<ManagedDesignCommand> Explode()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_explode);
        }

        static DynamicPointer<ManagedDesignCommand> Group(const String& model_name = String())
        {
            return new ManagedDesignCommand(ManagedCommandType::e_group, model_name);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVIntensity(UVType uv_type, fltp08 uv_intensity)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_intensity, uv_type, uv_intensity);
        }

        static DynamicPointer<ManagedDesignCommand> SetUVPropertyChannel(UVType uv_type, String uv_channel)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_UV_property_channel, uv_type, uv_channel);
        }

        static DynamicPointer<ManagedDesignCommand> ColorByChannel(String vertex_channel)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_color_by_channel, vertex_channel);
        }

        static DynamicPointer<ManagedDesignCommand> SetWindingMode(WindingMode mode)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_winding_mode, mode);
        }

        static DynamicPointer<ManagedDesignCommand> MakeClosedSolid(bool is_closed_solid)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_make_closed_solid, is_closed_solid);
        }

        static DynamicPointer<ManagedDesignCommand> SetNormalMode(NormalMode mode)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_normal_mode, mode);
        }

        static DynamicPointer<ManagedDesignCommand> SetActiveFilters(const String& filters)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_active_filters, filters);
        }

        static DynamicPointer<ManagedDesignCommand> AddActiveFilters(const String& filters)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_add_active_filters, filters);
        }

        static DynamicPointer<ManagedDesignCommand> AutoRegister(const String& filters, const UUID& reference)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_auto_register, reference, filters);
        }

        static DynamicPointer<ManagedDesignCommand> RemoveActiveFilter(const uint04& index)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_remove_filter, index);
        }

        static DynamicPointer<ManagedDesignCommand> SetNormalMode(NormalMode mode, Angle<fltp08> smooth_angle)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_normal_mode, mode, smooth_angle);
        }

        static DynamicPointer<ManagedDesignCommand> CalibrateScan(bool calibrate_yaw, InterpolationValues value = InterpolationValues::e_linear)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_calibrate_scan, calibrate_yaw, value);
        }

        static DynamicPointer<ManagedDesignCommand> CalibrateScan(Angle<fltp08> angle, bool calibrate_yaw, InterpolationValues value = InterpolationValues::e_linear)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_calibrate_scan, angle, calibrate_yaw, value);
        }

        static DynamicPointer<ManagedDesignCommand> CalculateTangents(bool calc_tangent, bool calc_bitangent)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_calculate_tangents, calc_tangent, calc_bitangent);
        }

        static DynamicPointer<ManagedDesignCommand> SliceIntoPolylines(const Matrix<fltp08>& transform, const Vector<3, fltp08>& spacing)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_slice_into_polylines, transform, spacing);
        }

        static DynamicPointer<ManagedDesignCommand> SelectObjects(bool add_to_selection)
        {
            ManagedDesignCommand* command = new ManagedDesignCommand(ManagedCommandType::e_select_objects, add_to_selection);
            command->can_undo = false;
            command->update_project_modified = false;
            return command;
        }

        static DynamicPointer<ManagedDesignCommand> FlipNormals()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_flip_normals);
        }

        static DynamicPointer<ManagedDesignCommand> SendInfo(const String& info)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_append_data, info);
        }

        static DynamicPointer<ManagedDesignCommand> SetMetadata(const String& label, const String& value)
        {
            return new ManagedDesignCommand(ManagedCommandType::e_set_metadata, label, value);
        }

        static DynamicPointer<ManagedDesignCommand> ClearAll()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_clear_all);
        }

        static DynamicPointer<ManagedDesignCommand> CenterAlign()
        {
            return new ManagedDesignCommand(ManagedCommandType::e_center_align);
        }

        String toString() const
        {
            String name = this->name().englishTranslation();
            if (targets.size() > 0)
            {
                name.add('[');
                for (const UUID& target_id : targets)
                {
                    name += String(target_id) + ",";
                }
                name.last() = ']';
            }
            else
            {
                name.append("[]");
            }
            if (params().size() > 0)
            {
                name.add('(');
                for (const String& param : params())
                {
                    name += String(param) + "|";
                }
                name.last() = ')';
            }
            else
            {
                name.append("()");
            }
            return name;
        }

        virtual bool addTarget(UUID target_id) override  { targets.add(target_id); return true; }
        NDEVR_DESIGN_API virtual TranslatedString name() const override;
        NDEVR_DESIGN_API virtual StringView icon() const override;
        NDEVR_DESIGN_API void deleteEnclosedSelection(DesignObjectLookup* lookup);
    public:
        ManagedCommandType command_type; 
        Buffer<String> m_command_params; 
        Dictionary<UUID, Buffer<String>> m_undo_params; 
        Buffer<UUID> targets; 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<ManagedCommandType>;
}