ManagedDesignCommand.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Material.h>
#include <NDEVR/Pointer.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief A specified type of DesignCommand that performs common actions such as grouping or setting
        property variables
    *-----------------------------------------------------------------------------------------------**/
    class NDEVR_DESIGN_API ManagedDesignCommand : public DesignCommand
    {
    public:
        enum CommandType
        {
              e_none
            , e_set_transform
            , e_validate
            , e_set_geometry_property
            , e_set_material_property
            , e_set_model_property
            , e_set_model_material_mode
            , e_set_design_property
            , e_create_property
            , e_normal_expansion
            , e_set_winding_mode
            , e_center_align
            , e_smooth_laplacian
            , e_smooth_cotangent
            , e_remove_smoothing
            , e_fill_holes_by_neighbor
            , e_make_closed_solid
            , e_update_vertex
            , e_calculate_tangents
            , e_set_normal_mode
            , e_flip_normals
            , e_remove_duplicates
            , e_set_UV_mode
            , e_set_UV_color
            , e_set_UV_image
            , e_set_real_thickness
            , e_scale_object
            , e_set_UV_intensity
            , e_set_UV_property_channel
            , e_set_shader
            , e_calibrate_scan
            , e_delete_enclosed_area
            , e_explode
            , e_group
            , e_clear_all
            , e_color_by_channel
            , e_read_from_file
            , e_read_from_database
            , e_create_material
            , e_create_geometry
            , e_delete_object
            , e_set_metadata
            , e_append_data
            , e_set_active_filters
            , e_add_active_filters
            , e_slice_into_polylines
            , e_remove_filter
            , e_auto_register
            , e_place_object
        };
    public:
        ManagedDesignCommand();
    protected:
        explicit ManagedDesignCommand(CommandType command);
        ManagedDesignCommand(CommandType command, const String& params);
 
        template<class t_arg_type>
        ManagedDesignCommand(CommandType 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(CommandType 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(CommandType 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(CommandType 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:
        bool isAsyncExecution() const override;
        void setParams(const Buffer<String>& params)
        {
            m_command_params = params;
        }
        void setParams(const String& params)
        {
            m_command_params = params.splitString('|');
        }
        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)
        {
            if(!m_undo_params.hasKey(uuid))
                m_undo_params.insert({ 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)
        {
            if (!m_undo_params.hasKey(uuid))
                m_undo_params.insert({ 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)
        {
            if (!m_undo_params.hasKey(uuid))
                m_undo_params.insert({ uuid, {String(param_a), String(param_b), String(param_c)} });
        }
        bool hasUndo(const UUID& uuid) const
        {
            return m_undo_params.hasKey(uuid);
        }
        void execute(DesignObjectLookup* lookup) override;
        bool canGroupWith(const DynamicPointer<DesignCommand>& command) override;
        bool canCombineWith(const DynamicPointer<DesignCommand>& command) override;
        void combineWith(const DynamicPointer<DesignCommand>& command) override;
        void removeUndo(const UUID& uuid)
        {
            m_undo_params.erase(uuid);
        }
 
        
        static DynamicPointer<DesignCommand> PlaceObject(const Matrix<fltp08>& transform)
        {
            return new ManagedDesignCommand(e_place_object, transform);
        }
        static DynamicPointer<DesignCommand> SetTransform(const Matrix<fltp08>& transform)
        {
            return new ManagedDesignCommand(e_set_transform, transform);
        }
        template<class t_type>
        static DynamicPointer<DesignCommand> SetGeometryProperty(Geometry::GeometryProperty geo_property, const t_type& value)
        {
            return new ManagedDesignCommand(e_set_geometry_property, geo_property, value);
        }
        template<class t_type>
        static DynamicPointer<DesignCommand> SetMaterialProperty(Material::MaterialProperties mat_property, const t_type& value)
        {
            return new ManagedDesignCommand(e_set_material_property, mat_property, value);
        }
        template<class t_type>
        static DynamicPointer<DesignCommand> SetModelProperty(Model::ModelProperty mod_property, const t_type& value)
        {
            return new ManagedDesignCommand(e_set_model_property, mod_property, value);
        }
        static DynamicPointer<DesignCommand> SetModelMaterialMode(PrimitiveProperty property, Model::MaterialMode mode)
        {
            return new ManagedDesignCommand(e_set_model_material_mode, property, mode);
        }
        template<class t_type>
        static DynamicPointer<DesignCommand> SetProperty(DesignObject::DesignProperty design_property, const t_type& value)
        {
            return new ManagedDesignCommand(e_set_design_property, design_property, value);
        }
        static DynamicPointer<DesignCommand> Delete()
        {
            return new ManagedDesignCommand(e_delete_object);
        }
        static DynamicPointer<DesignCommand> CreateGeometry(const String& name = "")
        {
            return new ManagedDesignCommand(e_create_geometry, name);
        }
        static DynamicPointer<DesignCommand> CreateMaterial(const String& name = "")
        {
            return new ManagedDesignCommand(e_create_material, name);
        }
        static DynamicPointer<DesignCommand> ValidateCommand()
        {
            return new ManagedDesignCommand(e_validate);
        }
        static DynamicPointer<DesignCommand> ScaleObject(const fltp08& scale)
        {
            return new ManagedDesignCommand(e_scale_object, Vector<3, fltp08>(scale));
        }
        static DynamicPointer<DesignCommand> ScaleObject(const Vector<3, fltp08>& scale)
        {
            return new ManagedDesignCommand(e_scale_object, scale);
        }
        static DynamicPointer<DesignCommand> ScaleObject(const fltp08& scale, const Vector<3, fltp08>& scale_center)
        {
            return new ManagedDesignCommand(e_scale_object, Vector<3, fltp08>(scale), scale_center);
        }
        static DynamicPointer<DesignCommand> ScaleObject(const Vector<3, fltp08>& scale, const Vector<3, fltp08>& scale_center)
        {
            return new ManagedDesignCommand(e_scale_object, scale, scale_center);
        }
        static DynamicPointer<DesignCommand> SetRealThickness(fltp08 real_thickness)
        {
            return new ManagedDesignCommand(e_set_real_thickness, real_thickness);
        }
        static DynamicPointer<DesignCommand> SmoothLaplacianCommand(uint04 number_of_iterations)
        {
            return new ManagedDesignCommand(e_smooth_laplacian, number_of_iterations);
        }
        static DynamicPointer<DesignCommand> SmoothCotangentCommand(uint04 number_of_iterations)
        {
            return new ManagedDesignCommand(e_smooth_cotangent, number_of_iterations);
        }
        static DynamicPointer<DesignCommand> SmoothLaplacianCommand(uint04 number_of_iterations, fltp08 shrink_rate, fltp08 grow_rate)
        {
            return new ManagedDesignCommand(e_smooth_laplacian, number_of_iterations, shrink_rate, grow_rate);
        }
        static DynamicPointer<DesignCommand> SmoothCotangentCommand(uint04 number_of_iterations, fltp08 shrink_rate, fltp08 grow_rate)
        {
            return new ManagedDesignCommand(e_smooth_cotangent, number_of_iterations, shrink_rate, grow_rate);
        }
        template<class t_type>
        static DynamicPointer<DesignCommand> UpdateVertex(VertexProperty property, uint04 vertex_id, const t_type& new_location)
        {
            return new ManagedDesignCommand(e_update_vertex, property, vertex_id, new_location);
        }
        static DynamicPointer<DesignCommand> RemoveSmoothingCommand()
        {
            return new ManagedDesignCommand(e_remove_smoothing);
        }
        static DynamicPointer<DesignCommand> RemoveDuplicateVertices()
        {
            return new ManagedDesignCommand(e_remove_duplicates);
        }
        static DynamicPointer<DesignCommand> DeleteEnclosedArea()
        {
            return new ManagedDesignCommand(e_delete_enclosed_area);
        }
        static DynamicPointer<DesignCommand> SetUVMode(UVType uv_type, Material::UVMode uv_mode)
        {
            return new ManagedDesignCommand(e_set_UV_mode, uv_type, uv_mode);
        }
        static DynamicPointer<DesignCommand> SetUVColor(const RGBColor& uv_color)
        {
            return new ManagedDesignCommand(e_set_UV_color, uv_color);
        }
        static DynamicPointer<DesignCommand> SetUVColor(UVType uv_type, const RGBColor& uv_color)
        {
            return new ManagedDesignCommand(e_set_UV_color, uv_type, uv_color);
        }
        static DynamicPointer<DesignCommand> SetUVImage(UVType uv_type, const String& uv_image)
        {
            return new ManagedDesignCommand(e_set_UV_image, uv_type, uv_image);
        }
        static DynamicPointer<DesignCommand> FillHolesByNeighbor()
        {
            return new ManagedDesignCommand(e_fill_holes_by_neighbor);
        }
        static DynamicPointer<DesignCommand> Explode()
        {
            return new ManagedDesignCommand(e_explode);
        }
        static DynamicPointer<DesignCommand> Group(const String& model_name = String())
        {
            return new ManagedDesignCommand(e_group, model_name);
        }
        static DynamicPointer<DesignCommand> SetUVIntensity(UVType uv_type, fltp08 uv_intensity)
        {
            return new ManagedDesignCommand(e_set_UV_intensity, uv_type, uv_intensity);
        }
        static DynamicPointer<DesignCommand> SetUVPropertyChannel(UVType uv_type, String uv_channel)
        {
            return new ManagedDesignCommand(e_set_UV_property_channel, uv_type, uv_channel);
        }
        static DynamicPointer<DesignCommand> ColorByChannel(String vertex_channel)
        {
            return new ManagedDesignCommand(e_color_by_channel, vertex_channel);
        }
        static DynamicPointer<DesignCommand> SetWindingMode(WindingMode mode)
        {
            return new ManagedDesignCommand(e_set_winding_mode, mode);
        }
        static DynamicPointer<DesignCommand> MakeClosedSolid(bool is_closed_solid)
        {
            return new ManagedDesignCommand(e_make_closed_solid, is_closed_solid);
        }
        static DynamicPointer<DesignCommand> SetNormalMode(NormalMode mode)
        {
            return new ManagedDesignCommand(e_set_normal_mode, mode);
        }
        static DynamicPointer<DesignCommand> SetActiveFilters(const String& filters)
        {
            return new ManagedDesignCommand(e_set_active_filters, filters);
        }
        static DynamicPointer<DesignCommand> AddActiveFilters(const String& filters)
        {
            return new ManagedDesignCommand(e_add_active_filters, filters);
        }
        static DynamicPointer<DesignCommand> AutoRegister(const String& filters, const UUID& reference)
        {
            return new ManagedDesignCommand(e_auto_register, reference, filters);
        }
        static DynamicPointer<DesignCommand> RemoveActiveFilter(const uint04& index)
        {
            return new ManagedDesignCommand(e_remove_filter, index);
        }
        static DynamicPointer<DesignCommand> SetNormalMode(NormalMode mode, Angle<fltp08> smooth_angle)
        {
            return new ManagedDesignCommand(e_set_normal_mode, mode, smooth_angle);
        }
        static DynamicPointer<DesignCommand> CalibrateScan(bool calibrate_yaw, InterpolationValues value = InterpolationValues::e_linear)
        {
            return new ManagedDesignCommand(e_calibrate_scan, calibrate_yaw, value);
        }
        static DynamicPointer<DesignCommand> CalibrateScan(Angle<fltp08> angle, bool calibrate_yaw, InterpolationValues value = InterpolationValues::e_linear)
        {
            return new ManagedDesignCommand(e_calibrate_scan, angle, calibrate_yaw, value);
        }
        static DynamicPointer<DesignCommand> CalculateTangents(bool calc_tangent, bool calc_bitangent)
        {
            return new ManagedDesignCommand(e_calculate_tangents, calc_tangent, calc_bitangent);
        }
        static DynamicPointer<DesignCommand> SliceIntoPolylines(const Matrix<fltp08>& transform, const Vector<3, fltp08>& spacing)
        {
            return new ManagedDesignCommand(e_slice_into_polylines, transform, spacing);
        }
        static DynamicPointer<DesignCommand> FlipNormals()
        {
            return new ManagedDesignCommand(e_flip_normals);
        }
        static DynamicPointer<DesignCommand> SendInfo(const String& info)
        {
            return new ManagedDesignCommand(e_append_data, info);
        }
        static DynamicPointer<DesignCommand> SetMetadata(const String& label, const String& value)
        {
            return new ManagedDesignCommand(e_set_metadata, label, value);
        }
        static DynamicPointer<DesignCommand> ClearAll()
        {
            return new ManagedDesignCommand(e_clear_all);
        }
        String toString() const
        {
            String name = this->name().translation("en_US");
            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 TranslatedString name() const override;
        virtual String icon() const override;
        void deleteEnclosedSelection(DesignObjectLookup* lookup);
        CommandType command_type;
        Buffer<String> m_command_params;
        Dictionary<UUID, Buffer<String>> m_undo_params;
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<ManagedDesignCommand::CommandType>;
}