NodeDelegate.h

Go to the documentation of this file.

/*

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

*/
#pragma once

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

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

namespace maquina
{
  class NodeDelegateRumba;
}

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 UserData, public std::enable_shared_from_this< NodeDelegate >
  {
  public:


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


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


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

    virtual Imath::Box3d bounding_box() const;

    virtual bool is_node() const;

    virtual StringView ui_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;
    };
 // 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 = 0;

      virtual StringView type_name() const = 0;

      virtual bool is_plug() const;


      virtual Plug plug() const;

      virtual std::string 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);
    };

    virtual int attribute_count() const;


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

    virtual void channels( std::unordered_set<Plug>& set ) const;

    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;

    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;

    virtual void start_transform(const QueryContext& qc=QueryContext::at_current_frame);

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


    virtual void set_scale(const Imath::V3d& scale, const ModificationContext& mc=ModificationContext::layer);


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


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


    virtual void set_translation(const Imath::V3d& translation, const ModificationContext& mc=ModificationContext::layer);

    static Imath::V3d extract_translation(const Imath::M44d& matrix, const Imath::V3d& scale_pivot, const Imath::V3d& rotate_pivot);

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

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

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

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

    virtual void set_focal_length(float fl, const ModificationContext& mc);

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

    virtual void set_horizontal_aperture(float horizontal_aperture, const ModificationContext& mc);

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

    virtual void set_vertical_aperture(float vertical_aperture, const ModificationContext& 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);

    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);
 // end of Camera


  };

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

}