Plug.h

Go to the documentation of this file.

/*

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

*/
#pragma once

#include "ChannelType.h" 
#include "Impl.h" 
#include "Macros.h"
#include "Ptr.h"

MAQUINA_IGNORE_WARNINGS_BEGIN
#include <ImathBox.h>
#include <ImathColor.h>
#include <ImathMatrix.h>
#include <ImathQuat.h>
#include <gsl/span>
MAQUINA_IGNORE_WARNINGS_END

#include <vector>
#include <unordered_map>
#include "AttributeDescriptor.h"
#include "QueryContext.h"

  namespace maquina
  {
    class Channel;
    class NodePlugin;
    class NodeDelegate;
    class Node;
    class Value;
    class ModificationContext;
    class PartialInvalidation;
    using PartialInvalidationPtr = Ptr<const PartialInvalidation>;


    class MAQUINA_EXPORT Plug
    {
    public:
      class Flags
      {
      public:
        enum Enum
        {
          none            = 0,      
          cache           = 1 << 0, 
          time_varying    = 1 << 1, 
          serial          = 1 << 3, 
          hidden          = 1 << 8, 
          channel         = 1 << 9, 
          main            = 1 << 12,
          auto_connect    = 1 << 13,
          no_input        = 1 << 15,
          background      = 1 << 30 
        };
      };

      enum DependencyFlags
      {
        Automatic = -2
      };

      Plug(
        const char* name,    
        const Value& value,  
        uint32_t flags = 0   
        );

      // TODO use a const char* or a string_view here
      std::string name() const;

      std::string full_name() const;

      std::string document_path() const;

      std::string nice_name() const;

      enum class TypeEvaluationMode
      {
        Default = 0,         
        Exact = 1,           
        Approximation = 2,   
      };

      std::string type_name(TypeEvaluationMode mode = TypeEvaluationMode::Default) const;

      std::shared_ptr<AttributeDescriptor> description() const;

      void set_description( const std::string& description, bool undo_stack=false);

      void set_default_value(const Value& value);

      enum class EvaluationMode
      {
        Interactive = 0,  
        Exact = 1,        
        NoEvaluation = 2, 
        Rest = 3          
      };
      static const int32_t AllFrames = int32_t(0x80000000);


      Value default_value() const;


      Value rest_value() const;

      void force_varying( bool force );

      Value value(
        const QueryContext& qc=QueryContext::at_current_frame,  
        EvaluationMode mode=EvaluationMode::Interactive         
      ) const;


      bool as_bool() const;


      int as_int() const;


      float as_float() const;


      double as_double() const;


      const std::string& as_string() const;

      // Returns the plug value as a wstring
      std::wstring as_wstring() const;


      const Imath::V2d& as_V2d() const;


      const Imath::V3d& as_V3d() const;


      const Imath::V4d& as_V4d() const;


      const Imath::V2i& as_V2i() const;


      const Imath::V3i& as_V3i() const;


      const Imath::V4i& as_V4i() const;


      const Imath::M44d &as_M44d() const;


      const Imath::Box3f& as_Box3f() const;


      const Imath::Color4f& as_Color4f() const;


      const Imath::Quatd& as_Quatd() const;


      std::shared_ptr<const class UserData> as_user_data() const;

      void set_value(const Value& value, bool undo_stack=false);

      void set_value(const Value& value, const PartialInvalidationPtr pi, bool undo_stack = false);

      void set_value(const Value& value, const ModificationContext& mc);


      void set_value(const Value& value, const ModificationContext& mc, int32_t start, int32_t end);


      bool can_connect(
        const Plug& other 
        ) const;

      bool depend_on(
        const gsl::span<const Plug>& plugs 
        ) const;

      bool is_connected() const;

      bool is_connection_serialized() const;

      bool is_internal() const;

      bool is_channel() const;

      void set_channel( bool channel );

      bool is_constant() const;

      bool is_evaluated() const;

      bool is_output() const;

      bool is_keyable() const;

      bool is_main_plug() const;


      bool is_auto_connect() const;


      bool is_dynamic() const;


      bool is_referenced_dynamic() const;

      bool is_animable() const;

      bool is_mutable() const;

      bool is_referenced_connection() const;

      enum class Status
      {
        Default, 
        Overridden, 
        Animated 
      };


      Plug::Status status() const;


      void connect(const Plug& src, 
        bool undo_stack=false,        
        bool serialize=false);        
      
      void disconnect(bool undo_stack=false);       

      void disconnect_outputs(bool undo_stack=false);       

      void add_dynamic_valued_dependency( const Plug& dependence,
        int32_t time_offset = 0, bool undo_stack = false, bool serialize = false);

      [[deprecated]]
      void add_valued_dependency( const Plug& dependence, int32_t index = -1,
        int32_t time_offset = 0, bool undo_stack = false, bool serialize = false);

      void remove_dynamic_valued_dependency( const Plug& dependence, bool undo_stack = true );

      [[deprecated]]
      void remove_valued_dependency( const Plug& dependence, bool undo_stack = true );

      void remove_dynamic_valued_dependency( uint32_t index, bool undo_stack = true );

      [[deprecated]]
      void remove_valued_dependency( uint32_t index, bool undo_stack = true );

      void remove_all_dynamic_valued_dependencies( bool undo_stack = true );

      [[deprecated]]
      void remove_all_valued_dependencies( bool undo_stack = true );

      std::vector<Plug> notification_dependencies();
      void add_notification_dependency(const Plug& dependence,
        bool serialize=false);
      void remove_notification_dependency(const Plug& dependence,
        bool notify=true);
      void remove_all_notification_dependencies(bool notify=true);

      std::vector<Plug> back_dependencies();
      size_t back_dependencies_count();

      std::vector<Plug> valued_dependencies();

      Plug valued_dependence(int dep_index) const;

      uint32_t valued_dependencies_count() const;

      bool has_valued_dependency( const Plug& plug ) const;

      // Invalidate a plug
      void touch();

      void touch(int first_frame, int last_frame, bool rest);

      void set_to_default();

      uint32_t flags() const;

      void set_flags(uint32_t flags);


      Plug input() const;

      Plug input_origin() const;


      class MAQUINA_EXPORT Outputs
      {
      public:
        class MAQUINA_EXPORT Iterator
        {
        public:
          using iterator_category = std::forward_iterator_tag;
          using value_type = Plug;
          using difference_type = std::ptrdiff_t;
          using pointer = Plug;
          using reference = Plug;

          reference operator*() const noexcept;
          bool operator==(const Iterator &other) const noexcept;
          bool operator!=(const Iterator &other) const noexcept;
          Iterator& operator++() noexcept;
          Iterator()=delete;
          Iterator(void* ite);
          Iterator(const Iterator &other);
          Iterator(Iterator &&other) noexcept;
          Iterator& operator=(const Iterator &other)=delete;
          Iterator& operator=(Iterator &&other)=delete;
          ~Iterator();
        private:
          void* _internal;
        };

        Outputs(void* plug) noexcept
          : _plug{ plug }
        {
        }
        Iterator begin();
        Iterator end();
      private:
        void* _plug;
      };

      Outputs outputs() const;

      [[deprecated]]
      std::vector<Plug> channel_plugs() const;

      std::vector<Channel> channels() const;

      std::shared_ptr<Channel> channel() const;

      std::shared_ptr<Channel> channel(ChannelType channel_type) const;

      bool has_node() const;
      Node node() const;


      std::vector<Plug> walk_down() const;

      static bool validate_name(const char* plug_name);

      bool operator==(const Plug& o) const { return _owner == o._owner && _plug == o._plug; }
      bool operator!=(const Plug& o) const { return _owner != o._owner || _plug != o._plug; }

      std::shared_ptr<NodeDelegate> node_delegate() const;

      struct Key
      {
        bool selected;
      };

      std::unordered_map<float, Key> key_frames() const;
      std::unordered_map<float, Key> key_frames_in_layer(const Node& layer) const;

      std::shared_ptr<Impl> _owner;
      void *_plug;

      Plug(const std::shared_ptr<Impl>& node, void *plug) 
        : _owner{ node }
        , _plug{ plug }
      {}
    };
  }

# include <functional>
namespace std
{
  template<>
  struct hash<::maquina::Plug>
  {
    std::size_t operator()( const ::maquina::Plug& plug ) const noexcept
    {
      return reinterpret_cast<size_t>( plug._plug );
    }
  };
}