Workspace.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2018
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include "Node.h"
#include "Document.h"
#include "Progress.h"
#include "ChannelMode.h"
#include <unordered_map>
#include <unordered_set>
#include <gsl/gsl>
#include <optional>

  namespace maquina
  {
    class Array;
    class Dict;
    class AnimCurve;
    class CustomAction;
    struct GeometryComponentSelection;
    struct LastSelectedComponent;

    class MAQUINA_EXPORT Workspace : public NodePlugin
    {
    public:
      virtual Node new_document();

      virtual Node load_document(
        const std::string_view& path,
        const ProgressCallback& progress={}
      );

      virtual void set_current_frame(float frame);

      static void set_class_name(std::string class_name);

      Workspace(Node* node) : NodePlugin(node) {}
    };

    MAQUINA_EXPORT Node workspace();

    MAQUINA_EXPORT Node active_document();


    MAQUINA_EXPORT void set_active_document(Node& document);

    MAQUINA_EXPORT bool has_active_document();

    MAQUINA_EXPORT void set_document_factory(const std::function<maquina::Node()>& factory);

    MAQUINA_EXPORT Plug background_progress();

    MAQUINA_EXPORT std::string active_document_filename();

    MAQUINA_EXPORT void undo();

    MAQUINA_EXPORT void redo();

    MAQUINA_EXPORT bool is_modifying();

    MAQUINA_EXPORT void modify_begin(
      const char* modification_name, 
      const gsl::span<const float>& interactive_frames = {} 
    );
    MAQUINA_EXPORT void modify_curve_begin(const char* modification_name);


    MAQUINA_EXPORT bool modify_end();


    MAQUINA_EXPORT bool modify_abort();

    MAQUINA_EXPORT void add_modify_action(const std::shared_ptr<maquina::CustomAction>& custom_action);


    MAQUINA_EXPORT bool delete_animation_graph(Node& node_to_delete, bool undo_stack=true);

    MAQUINA_EXPORT float current_frame();

    MAQUINA_EXPORT void set_current_frame(float frame);

    MAQUINA_EXPORT bool can_undo_blend();

    MAQUINA_EXPORT void undo_blend(float undo_blend);


    MAQUINA_EXPORT Node duplicate_layer(
      Node& layer 
    );


    MAQUINA_EXPORT void set_animated_plug_value(
      Plug& plug,         
      const Value& value, 
      float frame,        
      bool create_curve,   
      bool layer_value=false,    
      int tangent_mode=-1   
    );


    MAQUINA_EXPORT bool has_animated_plug(
      const Plug& plug  
    );


    MAQUINA_EXPORT bool has_animated_plug_in_layer(
      const Plug& plug,  
      Node& layer  
    );


    MAQUINA_EXPORT std::vector<Node> in_animated_layers(
      const Plug& plug,        
      bool skip_disabled=true     
    );

    MAQUINA_EXPORT bool has_target_layer(
      const Plug& plug   
    );


    MAQUINA_EXPORT Node target_layer(
      const Plug& plug   
    );


    MAQUINA_EXPORT Plug animated_plug(
      const Plug& plug   
    );


    MAQUINA_EXPORT Plug animated_plug_in_layer(
      const Plug& plug,   
      Node& layer         
    );


    MAQUINA_EXPORT Value animated_plug_value_in_layer(
      const Plug& plug,   
      const Node& layer,        
      float frame         
    );


    MAQUINA_EXPORT bool has_animated_channel(
      Plug& animated_plug  
    );


    MAQUINA_EXPORT Plug animated_channel(
      Plug& animated_plug   
    );

    MAQUINA_EXPORT Value default_rig_value(
      Plug& plug        
    );

    MAQUINA_EXPORT void delete_channels_animation(
      std::vector<Plug> channels,  
      bool all_layers=false        
    );


    MAQUINA_EXPORT bool rig_matrix(
      Plug& plug,         
      const std::string_view& srt_class_name = "SRTToTransformNode" 
    );


    MAQUINA_EXPORT void constrain_node(
      Node& constraint, 
      Node& node 
    );

      /* A key will be added on all controllers already keyed in the layer */
    MAQUINA_EXPORT void key_layer(
      Node& layer, 
      float frame, 
      bool default_value=false 
    );


    MAQUINA_EXPORT std::vector<Node> selection();
    

    MAQUINA_EXPORT std::vector<std::shared_ptr<NodeDelegate>> delegate_selection();

    MAQUINA_EXPORT const std::vector<GeometryComponentSelection>& sub_component_selection();

    MAQUINA_EXPORT LastSelectedComponent last_selected_components();

    MAQUINA_EXPORT std::vector<std::string> selection_paths();

    MAQUINA_EXPORT std::vector<std::shared_ptr<NodeDelegate>> tool_selection();

    enum class SelectionMode
    {
      Replace, 
      Add, 
      Remove, 
      Invert 
    };

    MAQUINA_EXPORT void select(
      const std::vector<Node>& nodes, 
      SelectionMode mode=SelectionMode::Replace 
    );

    MAQUINA_EXPORT void select_delegate(
      std::vector<std::string> paths, 
      SelectionMode mode = SelectionMode::Replace 
    );


    MAQUINA_EXPORT void select_sub_component(
      std::vector<GeometryComponentSelection>&& selection, 
      SelectionMode mode = SelectionMode::Replace,    
      bool keep_sub_components = true                 
    );

    /* The return value is a list a channel full name */
    MAQUINA_EXPORT std::unordered_set<std::string> selected_keys_channels(Node& anim_layer);


    MAQUINA_EXPORT std::vector<Channel> channel_selection(ChannelMode channel_mode_filter);

    /* The return value is a LayerKeys user data
    */
    MAQUINA_EXPORT Value copy_keys(
      Node& anim_layer 
    );
   
    enum class PasteMode
    {
      Clear, 
      Merge, 
      Replace, 
      Insert 
    };

    /* This function is looking for the best match in the active selection that leads to the closest channel.
    * A Channel is defined as DOCUMENT/ASSET.CTRL_SIDE_CHANNEL, comparison of two channels will give a matching score.
    * With a score given to each channels of the active selection compare to a channel to paste, the highest score will be the targeted one
    * The overall highest score is the only one that is returned
    * Return value is a list of matching channels
    */
    MAQUINA_EXPORT std::vector< std::pair<std::string, std::string> > match_channels(
            const Value& to_match 
    );

    enum class MatchMirrorMode
    {
      automatic, 
      mirror,    
      no_mirror  
    };

    /* This function is looking for the best match in the selected channels that leads to the closest channel.
    * A Channel is defined as DOCUMENT/ASSET.CTRL_SIDE_CHANNEL, comparison of two channels will give a matching score.
    * With a score given to each channels in the selected channels compare to a channel to paste, the highest score will be the targeted one
    * The overall highest score is the only one that is returned
    * Return value is a list of matching channels and a mirrored bool which is true if the channels have been matched to the mirrored controllers.
    */
    MAQUINA_EXPORT std::pair<std::vector< std::pair<std::string, std::string> >, bool> match_to_channels(
      const std::unordered_set<std::string>& channels_to_match, 
      const std::unordered_set<std::string>& selected_channels, 
      MatchMirrorMode mirror_mode                               
    );

    enum class PasteType
    {
      Null, 
      Soft, 
      Hard  
    };

    MAQUINA_EXPORT PasteType is_paste_valid(
    const Value& to_paste, 
    const std::vector< std::pair<std::string, std::string> >& matched_channels, 
        Node& dest_layer 
    );


    MAQUINA_EXPORT void paste_keys(
      const Value& to_paste, 
      const std::vector< std::pair<std::string, std::string> >& matched_channels, // Matching channels
      Node& dest_layer, 
      float frame_in, 
      float frame_out, 
      float to_frame, 
      PasteMode mode = PasteMode::Merge, 
      PasteType type = PasteType::Hard 
    );


    MAQUINA_EXPORT void paste_keys_on_curve(
      Node& anim_curve_node,  
      const AnimCurve& curve, 
      float frame_in,  
      float frame_out, 
      float to_frame, 
      PasteMode mode=PasteMode::Merge 
    );

    MAQUINA_EXPORT void remove_keys(
          Node& anim_layer, 
          bool normalize=true 
      );

    MAQUINA_EXPORT void remove_key(
      Plug& plug, 
      const float frame 
    );

    MAQUINA_EXPORT void transform_keys(Node& anim_layer);
    MAQUINA_EXPORT void transform_curve_keys(const Plug& plug, std::unordered_map<float, float>& original_to_transformed_keys);

    MAQUINA_EXPORT int insert_key(const Plug& plug, float t, float v);

    MAQUINA_EXPORT void time_warp_keys(Node& anim_layer);

    MAQUINA_EXPORT void move_layer(
        Node& layer, 
        int dest_id 
    );

    MAQUINA_EXPORT void reparent_layers(
      Node& parent, 
      const std::vector<Node>& layers 
    );

    MAQUINA_EXPORT void ungroup_layer(
      Node& layer_group 
    );

    MAQUINA_EXPORT bool can_be_flatten(
      Node& layer 
    );

    // Extends the layers vector with the layer group children of type layer_type
    MAQUINA_EXPORT void group_child_layers(
      Node& layer_group, //< The layer group
      std::vector<Node>& layers, //< The layers vector to be completed
      const char* layer_type, //< The type of layer we are looking for
      bool recursive = false //< Go recursively in layer group children
    );

    enum class FlattenMode
    {
      In_Dest_Key, 
      Union_Keys, 
      All_Frames 
    };

    /* The return value is the layer that contain the flatten result */
    MAQUINA_EXPORT Node flatten_group(
      Node& layer_group, 
      FlattenMode mode = FlattenMode::Union_Keys, 
      int all_frames_interval = 1, 
      int all_frames_offset = 0, 
      int all_frames_tangents_mode = 1 
    );

    MAQUINA_EXPORT void flatten_layer(
      Node& layer, 
      Node& dest_layer, 
      FlattenMode mode=FlattenMode::Union_Keys, 
      int all_frames_interval=1, 
      int all_frames_offset=0, 
      int all_frames_tangents_mode=1  
    );

    MAQUINA_EXPORT void bake_layer(
      Node& layer, 
      int interval = 1, 
      int offset = 0, 
      int tangents_mode = 1  
    );

    MAQUINA_EXPORT void bake_curve(
      Node& curve, 
      const Plug& value_plug, 
      int interval = 1, 
      int offset = 0, 
      int tangents_mode = 1  
    );


    MAQUINA_EXPORT Node reference(
      Node& root,                     
      const std::wstring& filepath,   
      const std::string& reference_root_name = "", 
      const ProgressCallback& progress={} 
    );


    MAQUINA_EXPORT bool has_loader(
      const std::wstring& filepath   
    );


    MAQUINA_EXPORT Node load_node(
      Node& root,                     
      const std::wstring& filepath,   
      const std::string& root_name = "", 
      const ProgressCallback& progress={} 
    );


    MAQUINA_EXPORT Dict extract_pose(
      const std::vector<std::string>& channels,   
      float frame                                 
    );


    MAQUINA_EXPORT Dict blend_poses(
      const Dict& from_pose,    
      const Dict& to_pose,      
      float weight              
    );


    MAQUINA_EXPORT Dict matching_pose(
      const Dict& pose,                            
      const std::vector<std::string>& channels,    
      MatchMirrorMode mirror_mode                  
    );

    MAQUINA_EXPORT bool has_controller(const Plug& plug);

    /*
     * \raise{std::runtime_error,RuntimeError} if the node has no controller.
     */
    MAQUINA_EXPORT Node controller(const Plug& plug);

    MAQUINA_EXPORT void init_crash_handler(const std::string& message, bool send_report, const std::wstring& app_name, const std::wstring& app_version, const std::string& recovery_file_extension, const std::string& post_dump_url);

    /*
     * \exception std::runtime_error if the node is not an animation node.
     */
    MAQUINA_EXPORT Plug animation_node_channel_plug(Node& node);

    MAQUINA_EXPORT bool is_right(Node& asset, const std::string& name);

    MAQUINA_EXPORT bool is_left(Node& asset, const std::string& name);

    MAQUINA_EXPORT std::string asset_mirror(Node& asset, const std::string& name);

    MAQUINA_EXPORT std::string asset_mirror_path(Node& asset, const std::string& path);

    /*
    * \raise{std::runtime_error,RuntimeError} if unable to find node's mirror or asset is not an Asset
    */
    MAQUINA_EXPORT Node asset_mirror_node(Node& asset, const Node& node);

    MAQUINA_EXPORT bool asset_has_manipulator(Node& asset, const std::string& manipulator_name);

    /*
    * \raise{std::runtime_error,RuntimeError} if unable to find or node is not an asset
    */
    MAQUINA_EXPORT Node asset_manipulator(Node& asset, const std::string& manipulator_name);

    /*
    * \raise{std::runtime_error,RuntimeError} if node is not an asset
    */
    MAQUINA_EXPORT std::optional<Node> asset_controller(Node& asset, const std::string_view& controller_name);
    
    MAQUINA_EXPORT bool asset_has_child(Node& asset, const std::string& name);
    /*
    * \raise{std::runtime_error,RuntimeError} if unable to find or node is not an asset
    */
    MAQUINA_EXPORT Node asset_child(Node& asset, const std::string& name);

    MAQUINA_EXPORT bool asset_child_has_manipulator(Node& asset, const Node& child);

    /*
    * \raise{std::runtime_error,RuntimeError} if unable to find or node is not an asset
    */
    MAQUINA_EXPORT Node asset_child_manipulator(Node& asset, const Node& child);

    MAQUINA_EXPORT Node manipulator_controller(Node& manipulator);

    MAQUINA_EXPORT std::vector<Node> asset_controllers(Node& asset);

    MAQUINA_EXPORT void start_profiling();

    MAQUINA_EXPORT void clear_profiling();


    MAQUINA_EXPORT std::vector<std::pair<std::string, Imath::V2f>> end_profiling();


    MAQUINA_EXPORT void load_document(
      const std::string_view& path,         
      const ProgressCallback& progress={}   
    );


    MAQUINA_EXPORT std::optional<Node> add_document(
      const std::string& path,            
      const ProgressCallback& progress={} 
    );

    MAQUINA_EXPORT Node add_new_document();

    MAQUINA_EXPORT std::optional<Node> document(
      const std::string& path,  
      bool comparable=false);   

    MAQUINA_EXPORT void new_document();


    MAQUINA_EXPORT bool is_demo_mode();

    MAQUINA_EXPORT void flush_observers();

    MAQUINA_EXPORT Node create_tool_geometry(const char* name, Node& parent);

    MAQUINA_EXPORT void background_start();

    MAQUINA_EXPORT void background_wait();

    // Return an Asset's Display node
    /*
    * \raise{std::runtime_error,RuntimeError} if no display node is available for this asset
    */
    MAQUINA_EXPORT Node asset_display(const Node& asset);

    MAQUINA_EXPORT void increment_dirty_token();

    MAQUINA_EXPORT Value weighted_sum(const gsl::span<const Value>& values, const gsl::span<const double>& weights, int quat_iter = 15, double quat_eps = 1e-12);

    MAQUINA_EXPORT bool is_rig_mode_on();

    MAQUINA_EXPORT void frame_camera(maquina::NodeDelegate& camera, const std::vector<std::shared_ptr<maquina::NodeDelegate>>& selection);

    MAQUINA_EXPORT std::vector<std::shared_ptr<maquina::NodeDelegate>> cameras();

    MAQUINA_EXPORT std::string beautify(const std::string& s);

    // TODO optional
    /*
    * \raise{std::runtime_error,RuntimeError} if type_name has not been registered as a Value type.
    */
    MAQUINA_EXPORT Value default_value(const maquina::StringView& type_name);
    
    /* Delete this node if it is an orphan AnimLayerBlend node.
       Returns true if the node is deleted.
       Armless if the node is not an AnimLayerBlend node. */
    MAQUINA_EXPORT bool delete_orphan_alb(Node& node, bool undo_stack);


    MAQUINA_EXPORT std::optional<Node> node_asset(const Node& node);


    MAQUINA_EXPORT void pick(const std::function<void(const std::optional<std::string_view>& path)>& picking_callback);

    MAQUINA_EXPORT bool is_picking();

    MAQUINA_EXPORT void stop_picking();

    MAQUINA_EXPORT void notify_picking(const std::string_view& node_delegate_path);


    MAQUINA_EXPORT Array trigger_event(const std::string_view& event_type, const Value& value=Value::default_value);


    [[nodiscard]]
    MAQUINA_EXPORT int register_event_callback(const std::string_view& event_type, std::function<Value(const Value&)> callback);

    MAQUINA_EXPORT void unregister_event_callback(int callback_id);

    MAQUINA_EXPORT Imath::M44d reflection_matrix(const Node& node, const Node& mirrored_node);
    MAQUINA_EXPORT Imath::M44d rest_transform(const Node& node);

    MAQUINA_EXPORT void enable_plug_listener(bool enable);

    MAQUINA_EXPORT void create_type_alias(const std::string& previous_type_name, std::string new_type_name);

    MAQUINA_EXPORT maquina::Plug widget_setting_plug(const std::string& setting_name, const std::string& widget_name, const maquina::Value& default_value);
  }