NodeDelegate.h

Go to the documentation of this file.

/*

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

*/
#pragma once

#include "Buffer.h"
#include "UserData.h"
#include "ModificationContext.h"
#include "QueryContext.h"
#include "StringView.h"
#include "Value.h"
#include "Plug.h"
#include "SparseBuffer.h"

#include <unordered_set>
#include <memory>
#include <ImathEuler.h>

namespace maquina
{
  class Channel;
  class NodeDelegateRumba;
  class Shape;
}

template class MAQUINA_EXPORT std::weak_ptr< maquina::NodeDelegate >;
template class MAQUINA_EXPORT std::enable_shared_from_this< maquina::NodeDelegate >;

namespace maquina
{

  class MAQUINA_EXPORT NodeDelegate : public std::enable_shared_from_this< NodeDelegate >
  {
    // *** Please update NodeDelegateWrapper after modifying NodeDelegate
    friend class NodeDelegateWrapper;
  public:
    virtual ~NodeDelegate() {};

    virtual StringView type_name() const = 0;


    virtual std::shared_ptr<NodeDelegate> parent() const = 0;


    virtual maquina::StringView name() const = 0;


    virtual std::string path() const = 0;

    virtual std::string document_path() const;

    virtual Imath::Box3d bounding_box() const;

    virtual bool is_node() const;

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


    virtual Node node() const;


    virtual bool operator==(const NodeDelegate& o) const = 0;


    virtual bool operator!=(const NodeDelegate& o) const = 0;


    virtual std::shared_ptr<NodeDelegate> find(const StringView& path);


    virtual int child_count() const;
    

    virtual std::shared_ptr<NodeDelegate> child(const StringView& name);

    class ChildIteratorDelegate
    {
    public:
      virtual ~ChildIteratorDelegate() {}
      virtual std::shared_ptr<NodeDelegate> operator*() const = 0;
      virtual std::shared_ptr<NodeDelegate> operator->() const = 0;
      virtual bool operator==(const ChildIteratorDelegate &other) const = 0;
      virtual bool operator!=(const ChildIteratorDelegate &other) const = 0;
      virtual ChildIteratorDelegate& operator++() = 0;
    };

    class ChildIterator
    {
    public:
      ChildIterator(const std::shared_ptr<ChildIteratorDelegate>& impl);
      std::shared_ptr<NodeDelegate> operator*() const;
      std::shared_ptr<NodeDelegate> operator->() const;
      bool operator==(const ChildIterator &other) const;
      bool operator!=(const ChildIterator &other) const;
      ChildIterator& operator++();
    private:
      std::shared_ptr<ChildIteratorDelegate> _impl;
    };

  protected:

    virtual std::shared_ptr<ChildIteratorDelegate> _children_begin();
    virtual std::shared_ptr<ChildIteratorDelegate> _children_end();

  public:

    class Children
    {
    friend class NodeDelegate;
    public:
      Children(const std::shared_ptr<NodeDelegate>& node);
      ChildIterator begin() const;
      ChildIterator end() const;
    private:
      const std::shared_ptr<NodeDelegate> _node;
    };

    Children children();
 // end of Children

    class AttributeDelegate;

    class Observer
    {
    public:
      virtual ~Observer() {};

      virtual std::shared_ptr<AttributeDelegate> attribute() = 0;
    };

    class MAQUINA_EXPORT AttributeDelegate
    {
    public:
      virtual ~AttributeDelegate() {}

      virtual std::shared_ptr<NodeDelegate> owner() = 0;

      virtual std::string name() const = 0;


      virtual bool is_mutable() const;


      virtual bool is_visible() const;


      virtual bool is_animable() const;


      virtual bool accepts_overrides() const;


      virtual bool is_overridden() const;


      virtual void add_override();


      virtual void remove_override();

      virtual Value value(const QueryContext& qc=QueryContext::at_current_frame) const = 0;

      virtual StringView type_name() const = 0;

      virtual bool is_plug() const;


      virtual Plug plug() const;

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


      virtual bool has_node_delegate() const;


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

      virtual void set_value(const Value& value, const ModificationContext& mc=ModificationContext::undoable);


      virtual std::shared_ptr<Observer> create_observer(const std::function<void()>& func, bool in_interactive=true);

      // TODO optional
      virtual std::shared_ptr<Channel> channel();

      // TODO optional
      virtual std::shared_ptr<Channel> channel(const ChannelType sc);

      virtual std::vector<Channel> channels();
    };

    virtual int attribute_count() const;


    virtual std::shared_ptr<AttributeDelegate> attribute(const StringView& name);


    virtual bool add_attribute(const StringView& name, const Value& value);

    // TODO optional
    virtual std::shared_ptr<Channel> channel(const ChannelType sc);

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

    [[deprecated]]
    virtual void channel_plugs( std::unordered_set<Plug>& set ) const;

    virtual void animate();

    class AttributeIteratorDelegate
    {
    public:
      virtual ~AttributeIteratorDelegate() {}
      virtual std::shared_ptr<AttributeDelegate> operator*() const = 0;
      virtual std::shared_ptr<AttributeDelegate> operator->() const = 0;
      virtual bool operator==(const AttributeIteratorDelegate &other) const = 0;
      virtual bool operator!=(const AttributeIteratorDelegate &other) const = 0;
      virtual AttributeIteratorDelegate& operator++() = 0;
    };

    class AttributeIterator
    {
    public:
      AttributeIterator(const std::shared_ptr<AttributeIteratorDelegate>& impl);
      std::shared_ptr<AttributeDelegate> operator*() const;
      std::shared_ptr<AttributeDelegate> operator->() const;
      bool operator==(const AttributeIterator &other) const;
      bool operator!=(const AttributeIterator &other) const;
      AttributeIterator& operator++();
    private:
      std::shared_ptr<AttributeIteratorDelegate> _impl;
    };

  protected:

    virtual std::shared_ptr<AttributeIteratorDelegate> _attributes_begin();
    virtual std::shared_ptr<AttributeIteratorDelegate> _attributes_end();

  public:

    struct Attributes {
      Attributes( const std::shared_ptr<NodeDelegate>& node ) : node{ node }{}
      AttributeIterator begin() const { return node->_attributes_begin(); }
      AttributeIterator end() const { return node->_attributes_end(); }
      std::shared_ptr<NodeDelegate> node;
    };

    Attributes attributes() { return Attributes{shared_from_this()}; }
 // end of Attributes


    virtual bool has_transform() const;

    virtual Imath::M44d matrix(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual Imath::M44d world_matrix(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual Imath::M44d parent_world_matrix(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual Imath::V3d rotate_pivot(const QueryContext& qc=QueryContext::at_current_frame) const;
    virtual Imath::V3d scale_pivot(const QueryContext& qc=QueryContext::at_current_frame) const;
    virtual Imath::V3d joint_orient(const QueryContext& qc=QueryContext::at_current_frame) const;
    virtual Imath::V3d rotate_axis(const QueryContext& qc=QueryContext::at_current_frame) const;

    enum MutableFlags
    {
      ScaleX        = 0x001, 
      ScaleY        = 0x002, 
      ScaleZ        = 0x004, 
      Scale         = ScaleX|ScaleY|ScaleZ, 
      RotateX       = 0x008, 
      RotateY       = 0x010, 
      RotateZ       = 0x020, 
      Rotate        = RotateX|RotateY|RotateZ, 
      TranslateX    = 0x040, 
      TranslateY    = 0x080, 
      TranslateZ    = 0x100, 
      Translate     = TranslateX|TranslateY|TranslateZ, 
      AllComponents = Scale|Rotate|Translate 
    };


    virtual int mutable_flags() const;

    class TransformUserData
    {
    public:
      virtual ~TransformUserData() {}
    };


    virtual std::unique_ptr<TransformUserData> start_transform(const QueryContext& qc=QueryContext::at_current_frame);


    virtual void end_transform(const ModificationContext& mc=ModificationContext::default_mc(), TransformUserData* user_data = nullptr);


    virtual void set_matrix(const Imath::M44d& matrix, const ModificationContext& mc = ModificationContext::default_mc(), TransformUserData* user_data = nullptr);

    virtual Imath::V3d scale(const QueryContext& qc=QueryContext::at_current_frame) const;


    virtual void set_scale(const Imath::V3d& scale, const ModificationContext& mc=ModificationContext::default_mc(), TransformUserData* user_data = nullptr);


    virtual Imath::V3d rotation(const QueryContext& qc=QueryContext::at_current_frame) const;


    virtual Imath::Eulerd::Order rotate_order(const QueryContext& qc=QueryContext::at_current_frame) const;


    virtual void set_rotation(const Imath::V3d& rotation, const ModificationContext& mc=ModificationContext::default_mc(), TransformUserData* user_data = nullptr);


    virtual Imath::V3d translation(const QueryContext& qc=QueryContext::at_current_frame) const;


    virtual void set_translation(const Imath::V3d& translation, const ModificationContext& mc=ModificationContext::default_mc(), TransformUserData* user_data = nullptr);

    Imath::V3d extract_translation(const Imath::M44d& local_matrix, const QueryContext& mc=QueryContext::at_current_frame) const;

    Imath::V3d extract_rotation(Imath::M44d local_matrix, const QueryContext& mc=QueryContext::at_current_frame) const;

    virtual std::shared_ptr<Observer> create_transform_observer(const std::function<void()>& func, bool in_interactive=true);
 // end of Transformation

    virtual bool is_camera() const;

    virtual bool is_locked() const;

    virtual void set_locked(bool locked, const ModificationContext& mc=ModificationContext::default_mc());

    virtual bool is_orthographic(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual float orthographic_width(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual void set_orthographic_width(float width, const ModificationContext& mc=ModificationContext::default_mc());

    virtual float center_of_interest(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual void set_center_of_interest(float coi, const ModificationContext& mc=ModificationContext::default_mc());

    virtual float near_clipping_plane(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual void set_near_clipping_plane(float near_clipping_plane, const ModificationContext& mc=ModificationContext::default_mc());

    virtual float far_clipping_plane(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual void set_far_clipping_plane(float far_clipping_plane, const ModificationContext& mc=ModificationContext::default_mc());

    virtual Imath::M44d projection_matrix(const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual float aspect_ratio() const;

    virtual std::shared_ptr<NodeDelegate> aim() const;

    virtual std::shared_ptr<NodeDelegate> up() const;

    virtual std::shared_ptr<Observer> create_camera_observer(const std::function<void()>& func, bool in_interactive=true);
 // end of Camera

    virtual bool has_geometry() const;


    virtual Shape geometry() const;
 // end of Geometry

    virtual bool is_sculpt() const;

    virtual BufferConstV3f input_points(const StringView& path, const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual SparseBufferConstV3f delta_points(const StringView& path, const QueryContext& qc=QueryContext::at_current_frame) const;

    virtual void set_delta_points(const SparseBufferConstV3f& delta_points, const StringView& path, const ModificationContext& mc=ModificationContext::default_mc()) const;

    virtual std::shared_ptr<maquina::NodeDelegate::Observer> create_sculpt_observer(const std::function<void()>& func, bool in_interactive);
 // end of Sculpt
  };

  inline NodeDelegate::Children::Children(const std::shared_ptr<NodeDelegate>& node) : _node(node)
  {}

  inline NodeDelegate::ChildIterator NodeDelegate::Children::begin() const
  {
    return _node->_children_begin();
  }

  inline NodeDelegate::ChildIterator NodeDelegate::Children::end() const
  {
    return _node->_children_end();
  }

  inline NodeDelegate::ChildIterator::ChildIterator(const std::shared_ptr<ChildIteratorDelegate>& impl) : _impl(impl)
  {}

  inline std::shared_ptr<NodeDelegate> NodeDelegate::ChildIterator::operator*() const
  {
    return **_impl;
  }

  inline std::shared_ptr<NodeDelegate> NodeDelegate::ChildIterator::operator->() const
  {
    return (*_impl).operator->();
  }

  inline bool NodeDelegate::ChildIterator::operator==(const ChildIterator &other) const
  {
    // we can have nullptr in _impl
    return (!_impl || !other._impl) ? _impl == other._impl : (*_impl).operator==(*other._impl);
  }

  inline bool NodeDelegate::ChildIterator::operator!=(const ChildIterator &other) const
  {
    return (!_impl || !other._impl) ? _impl != other._impl : (*_impl).operator!=(*other._impl);
  }

  inline NodeDelegate::ChildIterator& NodeDelegate::ChildIterator::operator++()
  {
    ++(*_impl);
    return *this;
  }

  inline NodeDelegate::AttributeIterator::AttributeIterator(const std::shared_ptr<AttributeIteratorDelegate>& impl) : _impl(impl)
  {}

  inline std::shared_ptr<NodeDelegate::AttributeDelegate> NodeDelegate::AttributeIterator::operator*() const
  {
    return **_impl;
  }

  inline std::shared_ptr<NodeDelegate::AttributeDelegate> NodeDelegate::AttributeIterator::operator->() const
  {
    return (*_impl).operator->();
  }

  inline bool NodeDelegate::AttributeIterator::operator==(const AttributeIterator &other) const
  {
    // we can have nullptr in _impl
    return (!_impl || !other._impl) ? _impl == other._impl : (*_impl).operator==(*other._impl);
  }

  inline bool NodeDelegate::AttributeIterator::operator!=(const AttributeIterator &other) const
  {
    return (!_impl || !other._impl) ? _impl != other._impl : (*_impl).operator!=(*other._impl);
  }

  inline NodeDelegate::AttributeIterator& NodeDelegate::AttributeIterator::operator++()
  {
    ++(*_impl);
    return *this;
  }

}