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 <unordered_map>
#include <unordered_set>
#include <gsl/gsl>

  namespace maquina
  {
    class Array;
    class Dict;
    class AnimCurve;
    class CustomAction;

    class MAQUINA_EXPORT Workspace : public Node
    {
    public:
      Workspace(const std::shared_ptr<Impl>& impl)
        : Node{ impl }
      {}
    };

    MAQUINA_EXPORT Workspace workspace();

    MAQUINA_EXPORT Node active_document();

    MAQUINA_EXPORT bool has_active_document();

    MAQUINA_EXPORT Plug background_progress();

    MAQUINA_EXPORT std::wstring active_document_filename();

    MAQUINA_EXPORT void undo();

    MAQUINA_EXPORT void redo();

    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 void add_modify_action(const std::shared_ptr<maquina::CustomAction>& custom_action);


    MAQUINA_EXPORT bool delete_animation_graph(Node& node_to_delete);

    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 void add_channels_to_layer(
      const std::vector<Plug>& channels, 
      Node& layer 
    );

    MAQUINA_EXPORT void remove_channels_from_layer(
      const std::vector<Plug>& channels, 
      Node& layer 
    );


    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     
    );


    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          
    );


    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 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(
      const std::vector<std::string>& paths, 
      SelectionMode mode = SelectionMode::Replace 
    );

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

    /* 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 
    );

    /* 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
    */
    MAQUINA_EXPORT std::vector< std::pair<std::string, std::string> > match_to_channels(
      const std::unordered_set<std::string>& channels_to_match, 
      const std::unordered_set<std::string>& selected_channels  
    );

    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 = "" 
    );


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


    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     
    );

    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);

    /*
     * \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);

    /*
    * \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);
    
    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 std::vector<std::pair<std::string, float>> end_profiling();


    MAQUINA_EXPORT void load_document(const std::wstring& path);

    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 Array& values, const std::vector<double>& weights);
  }