began new infrastructure

Yep, this is another one of my "famous" sweeping rewrites. Expect things to break. Goals for this are: - Greatly simplify node connections (particularly with arrays) so the code requires less maintenance/is more stable - Redesign node structure to address issues where UI would stall for lengthy periods of time - Less reliance on shared ptrs/greater reliance on QObject system for inheritance/memory management - General code cleanup and improvements
2021-01-05 11:20:38 +11:00
parent 19eabf2830
commit 181235f6ce
152 changed files with 3932 additions and 8166 deletions
@@ -22,19 +22,189 @@
 #define VALUE_H

 #include <QString>
-
-#include "input.h"
-#include "render/shadervalue.h"
+#include <QVariant>

 namespace olive {

+class Node;
+class NodeInput;
+
 class NodeValue
 {
 public:
-  NodeValue();
-  NodeValue(const NodeParam::DataType& type, const QVariant& data, const Node* from, const QString& tag = QString());
+  /**
+   * @brief The types of data that can be passed between Nodes
+   */
+  enum Type {
+    kNone,

-  const NodeParam::DataType& type() const
+    /**
+     ****************************** SPECIFIC IDENTIFIERS ******************************
+     */
+
+    /**
+     * Integer type
+     *
+     * Resolves to int64_t.
+     */
+    kInt,
+
+    /**
+     * Decimal (floating-point) type
+     *
+     * Resolves to `double`.
+     */
+    kFloat,
+
+    /**
+     * Decimal (rational) type
+     *
+     * Resolves to `double`.
+     */
+    kRational,
+
+    /**
+     * Boolean type
+     *
+     * Resolves to `bool`.
+     */
+    kBoolean,
+
+    /**
+     * Floating-point type
+     *
+     * Resolves to `Color`.
+     *
+     * Colors passed around the nodes should always be in reference space and preferably use
+     */
+    kColor,
+
+    /**
+     * Matrix type
+     *
+     * Resolves to `QMatrix4x4`.
+     */
+    kMatrix,
+
+    /**
+     * Text type
+     *
+     * Resolves to `QString`.
+     */
+    kText,
+
+    /**
+     * Font type
+     *
+     * Resolves to `QFont`.
+     */
+    kFont,
+
+    /**
+     * File type
+     *
+     * Resolves to a `QString` containing an absolute file path.
+     */
+    kFile,
+
+    /**
+     * Image buffer type
+     *
+     * True value type depends on the render engine used.
+     */
+    kTexture,
+
+    /**
+     * Audio samples type
+     *
+     * Resolves to `SampleBufferPtr`.
+     */
+    kSamples,
+
+    /**
+     * Footage stream identifier type
+     *
+     * Resolves to `StreamPtr`.
+     */
+    kFootage,
+
+    /**
+     * Two-dimensional vector (XY) type
+     *
+     * Resolves to `QVector2D`.
+     */
+    kVec2,
+
+    /**
+     * Three-dimensional vector (XYZ) type
+     *
+     * Resolves to `QVector3D`.
+     */
+    kVec3,
+
+    /**
+     * Four-dimensional vector (XYZW) type
+     *
+     * Resolves to `QVector4D`.
+     */
+    kVec4,
+
+    /**
+     * ComboBox type
+     *
+     * Resolves to `int` - the index currently selected
+     */
+    kCombo,
+
+    /**
+     * Job type
+     *
+     * An internal type used to indicate to the renderer that an accelerated shader job needs to
+     * run. This value will usually be taken from a table and a kTexture value will be pushed to
+     * take its place.
+     */
+    kShaderJob,
+
+    /**
+     * Job type
+     *
+     * An internal type used to indicate to the renderer that an accelerated sample job needs to
+     * take place. This value will usually be taken from a table and a kSamples value will be
+     * pushed to take its place.
+     */
+    kSampleJob,
+
+    /**
+     * Job type
+     *
+     * An internal type used to indicate to the renderer that an accelerated sample job needs to
+     * take place. This value will usually be taken from a table and a kSamples value will be
+     * pushed to take its place.
+     */
+    kGenerateJob
+  };
+
+  static const QVector<Type> kNumber;
+  static const QVector<Type> kBuffer;
+  static const QVector<Type> kVector;
+
+  NodeValue() :
+    type_(kNone),
+    from_(nullptr),
+    array_(false)
+  {
+  }
+
+  NodeValue(Type type, const QVariant& data, const Node* from = nullptr, bool array = false, const QString& tag = QString()) :
+    type_(type),
+    data_(data),
+    from_(from),
+    tag_(tag),
+    array_(array)
+  {
+  }
+
+  Type type() const
  {
    return type_;
  }
@@ -54,13 +224,63 @@ public:
    return from_;
  }

-  bool operator==(const NodeValue& rhs) const;
+  bool array() const
+  {
+    return array_;
+  }
+
+  bool operator==(const NodeValue& rhs) const
+  {
+    return type_ == rhs.type_ && tag_ == rhs.tag_ && data_ == rhs.data_;
+  }
+
+  static QString GetPrettyDataTypeName(Type type);
+
+  static QString ValueToString(Type data_type, const QVariant& value, bool value_is_a_key_track);
+
+  static QVariant StringToValue(Type data_type, const QString &string, bool value_is_a_key_track);
+
+  /**
+   * @brief Convert a value from a NodeParam into bytes
+   */
+  static QByteArray ValueToBytes(Type type, const QVariant& value);
+
+  static QVector<QVariant> split_normal_value_into_track_values(Type type, const QVariant &value);
+
+  static QVariant combine_track_values_into_normal_value(Type type, const QVector<QVariant>& split);
+
+  /**
+   * @brief Returns whether a data type can be interpolated or not
+   */
+  static bool type_can_be_interpolated(NodeValue::Type type)
+  {
+    return type == kFloat
+        || type == kVec2
+        || type == kVec3
+        || type == kVec4
+        || type == kColor;
+  }
+
+  static bool type_is_numeric(NodeValue::Type type)
+  {
+    return kNumber.contains(type);
+  }
+
+  static bool type_is_vector(NodeValue::Type type)
+  {
+    return kVector.contains(type);
+  }
+
+  static int get_number_of_keyframe_tracks(Type type);
+
+  static void ValidateVectorString(QStringList* list, int count);

 private:
-  NodeParam::DataType type_;
+  Type type_;
  QVariant data_;
  const Node* from_;
  QString tag_;
+  bool array_;

 };

@@ -69,24 +289,52 @@ class NodeValueTable
 public:
  NodeValueTable() = default;

-  QVariant Get(const NodeParam::DataType& type, const QString& tag = QString()) const;
-  NodeValue GetWithMeta(const NodeParam::DataType& type, const QString& tag = QString()) const;
-  QVariant Take(const NodeParam::DataType& type, const QString& tag = QString());
-  NodeValue TakeWithMeta(const NodeParam::DataType& type, const QString& tag = QString());
+  QVariant Get(NodeValue::Type type, const QString& tag = QString()) const
+  {
+    QVector<NodeValue::Type> types = {type};
+    return Get(types, tag);
+  }
+
+  QVariant Get(const QVector<NodeValue::Type>& type, const QString& tag = QString()) const
+  {
+    return GetWithMeta(type, tag).data();
+  }
+
+  NodeValue GetWithMeta(NodeValue::Type type, const QString& tag = QString()) const
+  {
+    QVector<NodeValue::Type> types = {type};
+    return GetWithMeta(types, tag);
+  }
+
+  NodeValue GetWithMeta(const QVector<NodeValue::Type>& type, const QString& tag = QString()) const;
+
+  QVariant Take(NodeValue::Type type, const QString& tag = QString())
+  {
+    QVector<NodeValue::Type> types = {type};
+    return Take(types, tag);
+  }
+
+  QVariant Take(const QVector<NodeValue::Type>& type, const QString& tag = QString())
+  {
+    return TakeWithMeta(type, tag).data();
+  }
+
+  NodeValue TakeWithMeta(NodeValue::Type type, const QString& tag = QString())
+  {
+    QVector<NodeValue::Type> types = {type};
+    return TakeWithMeta(types, tag);
+  }
+
+  NodeValue TakeWithMeta(const QVector<NodeValue::Type>& type, const QString& tag = QString());

  void Push(const NodeValue& value)
  {
    values_.append(value);
  }

-  void Push(const NodeParam::DataType& type, const QVariant& data, const Node *from, const QString& tag = QString())
+  void Push(NodeValue::Type type, const QVariant& data, const Node *from, bool array = false, const QString& tag = QString())
  {
-    Push(NodeValue(type, data, from, tag));
-  }
-
-  void Push(const ShaderValue &value, const Node *from)
-  {
-    Push(value.type, value.data, from, value.tag);
+    Push(NodeValue(type, data, from, array, tag));
  }

  void Prepend(const NodeValue& value)
@@ -94,14 +342,9 @@ public:
    values_.prepend(value);
  }

-  void Prepend(const NodeParam::DataType& type, const QVariant& data, const Node *from, const QString& tag = QString())
+  void Prepend(NodeValue::Type type, const QVariant& data, const Node *from, bool array = false, const QString& tag = QString())
  {
-    Prepend(NodeValue(type, data, from, tag));
-  }
-
-  void Prepend(const ShaderValue &value, const Node *from)
-  {
-    Prepend(value.type, value.data, from, value.tag);
+    Prepend(NodeValue(type, data, from, array, tag));
  }

  const NodeValue& at(int index) const
@@ -118,7 +361,7 @@ public:
    return values_.size();
  }

-  bool Has(const NodeParam::DataType& type) const;
+  bool Has(NodeValue::Type type) const;
  void Remove(const NodeValue& v);

  bool isEmpty() const
@@ -129,7 +372,7 @@ public:
  static NodeValueTable Merge(QList<NodeValueTable> tables);

 private:
-  int GetInternal(const NodeParam::DataType& type, const QString& tag) const;
+  int GetInternal(const QVector<NodeValue::Type> &type, const QString& tag) const;

  QList<NodeValue> values_;

@@ -145,20 +388,14 @@ public:
    return tables_[input_id];
  }

-  NodeValueTable& operator[](const NodeInput* input)
-  {
-    return tables_[input->id()];
-  }
+  NodeValueTable& operator[](const NodeInput* input);

  void Insert(const QString& key, const NodeValueTable &value)
  {
    tables_.insert(key, value);
  }

-  void Insert(const NodeInput* key, const NodeValueTable& value)
-  {
-    tables_.insert(key->id(), value);
-  }
+  void Insert(const NodeInput* key, const NodeValueTable& value);

  NodeValueTable Merge() const;

@@ -184,6 +421,8 @@ private:

 };

+using NodeValueMap = QHash<QString, NodeValue>;
+
 }

 Q_DECLARE_METATYPE(olive::NodeValue)