AnimCurve.h

Go to the documentation of this file.

/*

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

*/
#pragma once

#include <gsl/span>
#include <optional>

#include "Value.h"
#include "Impl.h"

MAQUINA_IGNORE_WARNINGS_BEGIN
#include <gsl/gsl>
MAQUINA_IGNORE_WARNINGS_END

namespace maquina
{
  enum class CycleMode
  {
    cycle_mode_constant = 0,
    cycle_mode_repeat,
    cycle_mode_repeat_continuous,
    cycle_mode_linear
  };

  struct WrapSlice
  {
    using WrapFunc = std::function<std::pair<float,float>(float)>;
    WrapSlice(float start, float end, const WrapFunc& time_wrap_func) : start(start), end(end), time_wrap_func(time_wrap_func) {}

    float start;

    float end;

    WrapFunc time_wrap_func;
  };


  class MAQUINA_EXPORT AnimCurve : public Value
  {
  public:

    AnimCurve(const Value &v);


    AnimCurve(const char* key_type);

    AnimCurve create_empty() const;

    size_t size() const;


    AnimCurve copy_keys(const gsl::span<const int>& keys) const;

    std::vector<int> selected_keys() const;

    int key_index(float t) const;

    int previous_key(float t) const;

    int next_key(float t) const;

    class MAQUINA_EXPORT Key
    {
      friend class AnimCurve;
    public:
      float time() const;

      void set_time(float t);

      float as_float() const;

      Value value() const;

      void set_value(float v);

      void set_value(const Value& v);

      bool selected() const;

      void set_selected(bool state);

    private:
      Key(Impl* curve, size_t index) : _curve(curve), _index(index) {}
      Impl* _curve;
      size_t _index;
    };


    size_t set_value(float frame, const maquina::Value& value = Value::default_value);

    size_t insert_value(float frame, const maquina::Value& value = Value::default_value, bool before=true);

    void remove_key(size_t i);

    const Key operator[](size_t i) const { return {_impl.get(), i}; }

    Value interpolate(float t, CycleMode pre_cycle_mode, CycleMode post_cycle_mode) const;

    void normalize(bool repeat);

    class Iterator
    {
      int _index;
      AnimCurve *_parent;
      bool _only_selected;
      void _skip_unselected()
      {
        if (_only_selected)
        {
          // Point on the first selected key
          const int size = int(_parent->size());
          while (_index < size)
          {
            if ((*_parent)[_index].selected())
              break;
            ++_index;
          }
        }
      }
    public:
      using iterator_category = std::input_iterator_tag;
      using value_type = Key;
      using difference_type = std::ptrdiff_t;
      using pointer = Key*;
      using reference = Key&;

      Iterator(int index, AnimCurve *parent, bool only_selected) : _index(index), _parent(parent), _only_selected(only_selected)
      {
        _skip_unselected();
      }
      bool operator==(const Iterator& o) { return _index == o._index;}
      bool operator!=(const Iterator& o) { return _index != o._index;}
      Iterator& operator++()
      {
        ++_index;
        _skip_unselected();
        return *this;
      }
      Key operator*() {return (*_parent)[_index];}
    };

    Iterator begin(bool only_selected = false) { return {0, this, only_selected}; }

    Iterator end() { return {int(size()), this, false}; }

    class Keys
    {
      AnimCurve *_parent;
      bool _only_selected;
    public:
      Keys(AnimCurve *parent, bool only_selected) : _parent(parent), _only_selected(only_selected) {}
      Iterator begin() { return _parent->begin(_only_selected); }
      Iterator end() { return _parent->end(); }
    private:
    };

    Keys keys(
      bool only_selected = false  
    )
    {
      return {this, only_selected};
    }


    std::optional<Value> clip(float frame_in, float frame_out);

    Value time_wrap(const gsl::span<const WrapSlice>& wrap_slices, CycleMode pre_cycle_mode, CycleMode post_cycle_mode) const;

    AnimCurve(std::shared_ptr<Impl> impl) { _impl=impl; }
  };


  class MAQUINA_EXPORT AnimCurveFloat : public AnimCurve
  {
  public:
    enum class CycleMode
    {
      constant=0,
      repeat,
      repeat_continuous,
      linear
    };

    class Key
    {
    public:
      class Tangent
      {
      public:
        enum class Mode
        {
          linear = 0,
          auto_,
          custom,
          spline,
          flat,
          step,
          custom_simple,
        };

        MAQUINA_EXPORT Tangent(Mode mode=Mode::auto_);
        MAQUINA_EXPORT Tangent(float frame, float value, Mode mode=Mode::custom);
        MAQUINA_EXPORT Tangent(const Imath::V2f& tangent, Mode mode=Mode::custom);

        Imath::V2f tangent;
        Mode mode;
      };

      MAQUINA_EXPORT Key(float frame, float value);

      MAQUINA_EXPORT Key(const Imath::V2f& key);


      MAQUINA_EXPORT Key(const Imath::V2f& key, const Tangent& right);

      MAQUINA_EXPORT Key(const Imath::V2f& key, const Tangent& left, const Tangent& right, bool broken_tangents=true, bool selected=false);

      Imath::V2f key;

      Tangent left;

      Tangent right;

      bool broken_tangents = false;

      bool selected = false;
    };

    AnimCurveFloat();


    AnimCurveFloat(const Value &v);

    AnimCurveFloat(const std::vector<Key> &keys, bool repeat);

    size_t size() const;

    const Key operator[](size_t n) const;

    class Iterator
    {
      int _index;
      AnimCurveFloat *_parent;
      bool _only_selected;
      void _skip_unselected()
      {
        if (_only_selected)
        {
          // Point on the first selected key
          const int size = int(_parent->size());
          while (_index < size)
          {
            if ((*_parent)[_index].selected)
              break;
            ++_index;
          }
        }
      }
    public:
      using iterator_category = std::input_iterator_tag;
      using value_type = Key;
      using difference_type = std::ptrdiff_t;
      using pointer = Key*;
      using reference = Key&;

      Iterator(int index, AnimCurveFloat *parent, bool only_selected) : _index(index), _parent(parent), _only_selected(only_selected)
      {
        _skip_unselected();
      }
      bool operator==(const Iterator& o) { return _index == o._index;}
      bool operator!=(const Iterator& o) { return _index != o._index;}
      Iterator& operator++()
      {
        ++_index;
        _skip_unselected();
        return *this;
      }
      Key operator*() {return (*_parent)[_index];}
    };

    Iterator begin(bool only_selected = false) { return {0, this, only_selected}; }

    Iterator end() { return {int(size()), this, false}; }

    class Keys
    {
      AnimCurveFloat *_parent;
      bool _only_selected;
    public:
      Keys(AnimCurveFloat *parent, bool only_selected) : _parent(parent), _only_selected(only_selected) {}
      Iterator begin() { return _parent->begin(_only_selected); }
      Iterator end() { return _parent->end(); }
    private:
    };

    Keys keys(
      bool only_selected = false  
    )
    {
      return {this, only_selected};
    }

    void set_key(size_t n, const Key& key);


    size_t set_key(const Key& key);


    size_t insert_key(const Key& key, bool before=true);

    void remove_key(size_t i);

    Value interpolate(float t, CycleMode left_mode=CycleMode::constant, CycleMode right_mode=CycleMode::constant) const;


    void normalize(bool repeat);
};
}