merged effects into node structure

effects/internal/audionoiseeffect.cpp

@@ -23,7 +23,7 @@
 #include <QDateTime>
 #include <QtMath>
 
-AudioNoiseEffect::AudioNoiseEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
+AudioNoiseEffect::AudioNoiseEffect(Clip* c) : Node(c) {
   amount_val = new DoubleInput(this, "amount", tr("Amount"));
   amount_val->SetMinimum(0);
   amount_val->SetDefault(20);
@@ -33,6 +33,36 @@ AudioNoiseEffect::AudioNoiseEffect(Clip* c, const EffectMeta *em) : Effect(c, em
   mix_val->SetValueAt(0, true);
 }
 
+QString AudioNoiseEffect::name()
+{
+  return tr("Noise");
+}
+
+QString AudioNoiseEffect::id()
+{
+  return "org.olivevideoeditor.Olive.noise";
+}
+
+QString AudioNoiseEffect::description()
+{
+  return tr("Generate audio noise that can be mixed with this clip.");
+}
+
+EffectType AudioNoiseEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType AudioNoiseEffect::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr AudioNoiseEffect::Create(Clip *c)
+{
+  return std::make_shared<AudioNoiseEffect>(c);
+}
+
 void AudioNoiseEffect::process_audio(double timecode_start,
                                      double timecode_end,
                                      float **samples,

effects/internal/audionoiseeffect.h

@@ -21,12 +21,20 @@
 #ifndef AUDIONOISEEFFECT_H
 #define AUDIONOISEEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class AudioNoiseEffect : public Effect {
+class AudioNoiseEffect : public Node {
   Q_OBJECT
 public:
-  AudioNoiseEffect(Clip* c, const EffectMeta* em);
+  AudioNoiseEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/cornerpineffect.cpp

@@ -24,8 +24,8 @@
 #include "timeline/clip.h"
 #include "global/debug.h"
 
-CornerPinEffect::CornerPinEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
-  SetFlags(Effect::CoordsFlag | Effect::ShaderFlag);
+CornerPinEffect::CornerPinEffect(Clip* c) : Node(c) {
+  SetFlags(Node::CoordsFlag | Node::ShaderFlag);
 
   top_left = new Vec2Input(this, "topleft", tr("Top Left"));
 
@@ -58,6 +58,41 @@ CornerPinEffect::CornerPinEffect(Clip* c, const EffectMeta *em) : Effect(c, em)
   shader_frag_path_ = "cornerpin.frag";
 }
 
+QString CornerPinEffect::name()
+{
+  return tr("Corner Pin");
+}
+
+QString CornerPinEffect::id()
+{
+  return "org.olivevideoeditor.Olive.cornerpin";
+}
+
+QString CornerPinEffect::category()
+{
+  return tr("Distort");
+}
+
+QString CornerPinEffect::description()
+{
+  return tr("Distort/warp this clip by pinning each of its four corners.");
+}
+
+EffectType CornerPinEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType CornerPinEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr CornerPinEffect::Create(Clip *c)
+{
+  return std::make_shared<CornerPinEffect>(c);
+}
+
 void CornerPinEffect::process_coords(double timecode, GLTextureCoords &coords, int) {
   coords.vertex_top_left += top_left->GetVector2DAt(timecode);
   coords.vertex_top_right += top_right->GetVector2DAt(timecode);

effects/internal/cornerpineffect.h

@@ -21,12 +21,21 @@
 #ifndef CORNERPINEFFECT_H
 #define CORNERPINEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class CornerPinEffect : public Effect {
+class CornerPinEffect : public Node {
   Q_OBJECT
 public:
-  CornerPinEffect(Clip* c, const EffectMeta* em);
+  CornerPinEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   void process_coords(double timecode, GLTextureCoords& coords, int data);
   void process_shader(double timecode, GLTextureCoords& coords, int iterations);
   void gizmo_draw(double timecode, GLTextureCoords& coords);

effects/internal/crossdissolvetransition.cpp

@@ -22,8 +22,43 @@
 
 #include <QOpenGLFunctions>
 
-CrossDissolveTransition::CrossDissolveTransition(Clip* c, Clip* s, const EffectMeta* em) : Transition(c, s, em) {
-  SetFlags(Effect::CoordsFlag);
+CrossDissolveTransition::CrossDissolveTransition(Clip* c) : Transition(c) {
+  SetFlags(Node::CoordsFlag);
+}
+
+QString CrossDissolveTransition::name()
+{
+  return tr("Cross Dissolve");
+}
+
+QString CrossDissolveTransition::id()
+{
+  return "org.olivevideoeditor.Olive.crossdissolve";
+}
+
+QString CrossDissolveTransition::category()
+{
+  return tr("Dissolves");
+}
+
+QString CrossDissolveTransition::description()
+{
+  return tr("Dissolve clips evenly.");
+}
+
+EffectType CrossDissolveTransition::type()
+{
+  return EFFECT_TYPE_TRANSITION;
+}
+
+olive::TrackType CrossDissolveTransition::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr CrossDissolveTransition::Create(Clip *c)
+{
+  return std::make_shared<CrossDissolveTransition>(c);
 }
 
 void CrossDissolveTransition::process_coords(double progress, GLTextureCoords& coords, int data) {

effects/internal/crossdissolvetransition.h

@@ -25,8 +25,17 @@
 
 class CrossDissolveTransition : public Transition {
 public:
-  CrossDissolveTransition(Clip *c, Clip *s, const EffectMeta* em);
-  void process_coords(double timecode, GLTextureCoords &, int data);
+  CrossDissolveTransition(Clip *c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
+  virtual void process_coords(double timecode, GLTextureCoords &, int data) override;
 };
 
 #endif // CROSSDISSOLVETRANSITION_H

effects/internal/cubetransition.h

@@ -25,7 +25,7 @@
 
 class CubeTransition : public Transition {
 public:
-  CubeTransition(Clip* c, Clip* s, const EffectMeta* em);
+  CubeTransition(Clip* c, Clip* s);
   void process_coords(double timecode, GLTextureCoords &, int data);
 };
 

effects/internal/exponentialfadetransition.cpp

@@ -22,7 +22,40 @@
 
 #include <QtMath>
 
-ExponentialFadeTransition::ExponentialFadeTransition(Clip* c, Clip* s, const EffectMeta* em) : Transition(c, s, em) {}
+ExponentialFadeTransition::ExponentialFadeTransition(Clip* c) :
+  Transition(c)
+{
+}
+
+QString ExponentialFadeTransition::name()
+{
+  return tr("Exponential Fade");
+}
+
+QString ExponentialFadeTransition::id()
+{
+  return "org.olivevideoeditor.Olive.exponentialfade";
+}
+
+QString ExponentialFadeTransition::description()
+{
+  return tr("An exponential audio fade that starts slow and ends fast.");
+}
+
+EffectType ExponentialFadeTransition::type()
+{
+  return EFFECT_TYPE_TRANSITION;
+}
+
+olive::TrackType ExponentialFadeTransition::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr ExponentialFadeTransition::Create(Clip *c)
+{
+  return std::make_shared<ExponentialFadeTransition>(c);
+}
 
 void ExponentialFadeTransition::process_audio(double timecode_start,
                                               double timecode_end,

effects/internal/exponentialfadetransition.h

@@ -25,7 +25,15 @@
 
 class ExponentialFadeTransition : public Transition {
 public:
-  ExponentialFadeTransition(Clip* c, Clip* s, const EffectMeta* em);
+  ExponentialFadeTransition(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/fillleftrighteffect.cpp

@@ -25,12 +25,42 @@ enum FillType {
   FILL_TYPE_RIGHT
 };
 
-FillLeftRightEffect::FillLeftRightEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
+FillLeftRightEffect::FillLeftRightEffect(Clip* c) : Node(c) {
   fill_type = new ComboInput(this, "type", tr("Type"));
   fill_type->AddItem(tr("Fill Left with Right"), FILL_TYPE_LEFT);
   fill_type->AddItem(tr("Fill Right with Left"), FILL_TYPE_RIGHT);
 }
 
+QString FillLeftRightEffect::name()
+{
+  return tr("Fill Left/Right");
+}
+
+QString FillLeftRightEffect::id()
+{
+  return "org.olivevideoeditor.Olive.fillleftright";
+}
+
+QString FillLeftRightEffect::description()
+{
+  return tr("Replaces either the left or right channel with the other");
+}
+
+EffectType FillLeftRightEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType FillLeftRightEffect::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr FillLeftRightEffect::Create(Clip *c)
+{
+  return std::make_shared<FillLeftRightEffect>(c);
+}
+
 void FillLeftRightEffect::process_audio(double timecode_start,
                                         double timecode_end,
                                         float **samples,

effects/internal/fillleftrighteffect.h

@@ -21,12 +21,20 @@
 #ifndef FILLLEFTRIGHTEFFECT_H
 #define FILLLEFTRIGHTEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class FillLeftRightEffect : public Effect {
+class FillLeftRightEffect : public Node {
   Q_OBJECT
 public:
-  FillLeftRightEffect(Clip* c, const EffectMeta* em);
+  FillLeftRightEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/linearfadetransition.cpp

@@ -20,7 +20,37 @@
 
 #include "linearfadetransition.h"
 
-LinearFadeTransition::LinearFadeTransition(Clip* c, Clip* s, const EffectMeta* em) : Transition(c, s, em) {}
+LinearFadeTransition::LinearFadeTransition(Clip* c) : Transition(c) {}
+
+QString LinearFadeTransition::name()
+{
+  return tr("Linear Fade");
+}
+
+QString LinearFadeTransition::id()
+{
+  return "org.olivevideoeditor.Olive.linearfade";
+}
+
+QString LinearFadeTransition::description()
+{
+  return tr("An linear audio fade that fades evenly at a constant rate.");
+}
+
+EffectType LinearFadeTransition::type()
+{
+  return EFFECT_TYPE_TRANSITION;
+}
+
+olive::TrackType LinearFadeTransition::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr LinearFadeTransition::Create(Clip *c)
+{
+  return std::make_shared<LinearFadeTransition>(c);
+}
 
 void LinearFadeTransition::process_audio(double timecode_start,
                                          double timecode_end,

effects/internal/linearfadetransition.h

@@ -25,7 +25,15 @@
 
 class LinearFadeTransition : public Transition {
 public:
-  LinearFadeTransition(Clip* c, Clip* s, const EffectMeta* em);
+  LinearFadeTransition(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/logarithmicfadetransition.cpp

@@ -22,7 +22,40 @@
 
 #include <QtMath>
 
-LogarithmicFadeTransition::LogarithmicFadeTransition(Clip* c, Clip* s, const EffectMeta* em) : Transition(c, s, em) {}
+LogarithmicFadeTransition::LogarithmicFadeTransition(Clip* c) :
+  Transition(c)
+{
+}
+
+QString LogarithmicFadeTransition::name()
+{
+  return tr("Logarithmic Fade");
+}
+
+QString LogarithmicFadeTransition::id()
+{
+  return "org.olivevideoeditor.Olive.logarithmicfade";
+}
+
+QString LogarithmicFadeTransition::description()
+{
+  return tr("An logarithmic audio fade that starts fast and ends slow.");
+}
+
+EffectType LogarithmicFadeTransition::type()
+{
+  return EFFECT_TYPE_TRANSITION;
+}
+
+olive::TrackType LogarithmicFadeTransition::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr LogarithmicFadeTransition::Create(Clip *c)
+{
+  return std::make_shared<LogarithmicFadeTransition>(c);
+}
 
 void LogarithmicFadeTransition::process_audio(double timecode_start,
                                               double timecode_end,

effects/internal/logarithmicfadetransition.h

@@ -25,7 +25,15 @@
 
 class LogarithmicFadeTransition : public Transition {
 public:
-  LogarithmicFadeTransition(Clip* c, Clip* s, const EffectMeta* em);
+  LogarithmicFadeTransition(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip* c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/paneffect.cpp

@@ -28,13 +28,43 @@
 #include "ui/labelslider.h"
 #include "ui/collapsiblewidget.h"
 
-PanEffect::PanEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
+PanEffect::PanEffect(Clip* c) : Node(c) {
   pan_val = new DoubleInput(this, "pan", tr("Pan"));
   pan_val->SetMinimum(-100);
   pan_val->SetDefault(0);
   pan_val->SetMaximum(100);
 }
 
+QString PanEffect::name()
+{
+  return tr("Pan");
+}
+
+QString PanEffect::id()
+{
+  return "org.olivevideoeditor.Olive.pan";
+}
+
+QString PanEffect::description()
+{
+  return tr("Modifying the panning on a stereo audio clip.");
+}
+
+EffectType PanEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType PanEffect::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr PanEffect::Create(Clip *c)
+{
+  return std::make_shared<PanEffect>(c);
+}
+
 void PanEffect::process_audio(double timecode_start,
                               double timecode_end,
                               float **samples,

effects/internal/paneffect.h

@@ -21,12 +21,20 @@
 #ifndef PANEFFECT_H
 #define PANEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class PanEffect : public Effect {
+class PanEffect : public Node {
   Q_OBJECT
 public:
-  PanEffect(Clip* c, const EffectMeta* em);
+  PanEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,

effects/internal/richtexteffect.cpp

@@ -34,10 +34,10 @@ enum AutoscrollDirection {
   SCROLL_RIGHT,
 };
 
-RichTextEffect::RichTextEffect(Clip *c, const EffectMeta *em) :
-  Effect(c, em)
+RichTextEffect::RichTextEffect(Clip *c) :
+  Node(c)
 {
-  SetFlags(Effect::SuperimposeFlag);
+  SetFlags(Node::SuperimposeFlag);
 
   text_val = new StringInput(this, "text", tr("Text"));
 
@@ -82,6 +82,41 @@ RichTextEffect::RichTextEffect(Clip *c, const EffectMeta *em) :
                           "</html>");
 }
 
+QString RichTextEffect::name()
+{
+  return tr("Rich Text");
+}
+
+QString RichTextEffect::id()
+{
+  return "org.olivevideoeditor.Olive.richtext";
+}
+
+QString RichTextEffect::category()
+{
+  return tr("Render");
+}
+
+QString RichTextEffect::description()
+{
+  return tr("Render formatted rich text over a clip.");
+}
+
+EffectType RichTextEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType RichTextEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr RichTextEffect::Create(Clip *c)
+{
+  return std::make_shared<RichTextEffect>(c);
+}
+
 void RichTextEffect::redraw(double timecode)
 {
   QPainter p(&img);

effects/internal/richtexteffect.h

@@ -21,13 +21,23 @@
 #ifndef RICHTEXTEFFECT_H
 #define RICHTEXTEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class RichTextEffect : public Effect {
+class RichTextEffect : public Node {
   Q_OBJECT
 public:
-  RichTextEffect(Clip* c, const EffectMeta *em);
+  RichTextEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void redraw(double timecode) override;
+
 protected:
   virtual bool AlwaysUpdate() override;
 private:

effects/internal/shakeeffect.cpp

@@ -32,8 +32,8 @@
 #include "panels/timeline.h"
 #include "global/debug.h"
 
-ShakeEffect::ShakeEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
-  SetFlags(Effect::CoordsFlag);
+ShakeEffect::ShakeEffect(Clip* c) : Node(c) {
+  SetFlags(Node::CoordsFlag);
 
   intensity_val = new DoubleInput(this, "intensity", tr("Intensity"));
   intensity_val->SetMinimum(0);
@@ -79,3 +79,38 @@ void ShakeEffect::process_coords(double timecode, GLTextureCoords& coords, int)
 
   coords.matrix.rotate(QQuaternion::fromEulerAngles(0.0f, 0.0f, rotoff));
 }
+
+QString ShakeEffect::name()
+{
+  return tr("Shake");
+}
+
+QString ShakeEffect::id()
+{
+  return "org.olivevideoeditor.Olive.shake";
+}
+
+QString ShakeEffect::category()
+{
+  return tr("Distort");
+}
+
+QString ShakeEffect::description()
+{
+  return tr("Simulate a camera shake movement.");
+}
+
+EffectType ShakeEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType ShakeEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr ShakeEffect::Create(Clip *c)
+{
+  return std::make_shared<ShakeEffect>(c);
+}

effects/internal/shakeeffect.h

@@ -21,16 +21,24 @@
 #ifndef SHAKEEFFECT_H
 #define SHAKEEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
 #define RANDOM_VAL_SIZE 30
 
-class ShakeEffect : public Effect {
+class ShakeEffect : public Node {
   Q_OBJECT
 public:
-  ShakeEffect(Clip* c, const EffectMeta* em);
+  ShakeEffect(Clip* c);
   virtual void process_coords(double timecode, GLTextureCoords& coords, int data) override;
 
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   DoubleInput* intensity_val;
   DoubleInput* rotation_val;
   DoubleInput* frequency_val;

effects/internal/solideffect.cpp

@@ -34,10 +34,10 @@ const int SMPTE_BARS = 7;
 const int SMPTE_STRIP_COUNT = 3;
 const int SMPTE_LOWER_BARS = 4;
 
-SolidEffect::SolidEffect(Clip* c, const EffectMeta* em) :
-  Effect(c, em)
+SolidEffect::SolidEffect(Clip* c) :
+  Node(c)
 {
-  SetFlags(Effect::SuperimposeFlag);
+  SetFlags(Node::SuperimposeFlag);
 
   // Field for solid type
   solid_type = new ComboInput(this, "type", tr("Type"));
@@ -69,6 +69,41 @@ SolidEffect::SolidEffect(Clip* c, const EffectMeta* em) :
   fragPath = ":/shaders/solideffect.frag";*/
 }
 
+QString SolidEffect::name()
+{
+  return tr("Solid");
+}
+
+QString SolidEffect::id()
+{
+  return "org.olivevideoeditor.Olive.solid";
+}
+
+QString SolidEffect::category()
+{
+  return tr("Render");
+}
+
+QString SolidEffect::description()
+{
+  return tr("Render a solid color over this clip.");
+}
+
+EffectType SolidEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType SolidEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr SolidEffect::Create(Clip *c)
+{
+  return std::make_shared<SolidEffect>(c);
+}
+
 void SolidEffect::redraw(double timecode) {
   int w = img.width();
   int h = img.height();

effects/internal/solideffect.h

@@ -21,11 +21,11 @@
 #ifndef SOLIDEFFECT_H
 #define SOLIDEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
 #include <QImage>
 
-class SolidEffect : public Effect {
+class SolidEffect : public Node {
   Q_OBJECT
 public:
   enum SolidType {
@@ -34,7 +34,16 @@ public:
     SOLID_TYPE_CHECKERBOARD
   };
 
-  SolidEffect(Clip* c, const EffectMeta *em);
+  SolidEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void redraw(double timecode) override;
 
   void SetType(SolidType type);

effects/internal/texteffect.cpp

@@ -42,10 +42,10 @@
 #include "ui/blur.h"
 #include "global/config.h"
 
-TextEffect::TextEffect(Clip* c, const EffectMeta* em) :
-  Effect(c, em)
+TextEffect::TextEffect(Clip* c) :
+  Node(c)
 {
-  SetFlags(Effect::SuperimposeFlag);
+  SetFlags(Node::SuperimposeFlag);
 
   text_val = new StringInput(this, "text", tr("Text"), false);
 
@@ -121,6 +121,41 @@ TextEffect::TextEffect(Clip* c, const EffectMeta* em) :
   shader_frag_path_ = "dropshadow.frag";
 }
 
+QString TextEffect::name()
+{
+  return tr("Text");
+}
+
+QString TextEffect::id()
+{
+  return "org.olivevideoeditor.Olive.text";
+}
+
+QString TextEffect::category()
+{
+  return tr("Render");
+}
+
+QString TextEffect::description()
+{
+  return tr("Generate simple text over this clip");
+}
+
+EffectType TextEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType TextEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr TextEffect::Create(Clip *c)
+{
+  return std::make_shared<TextEffect>(c);
+}
+
 void TextEffect::redraw(double timecode) {
   QColor bkg = set_color_button->GetColorAt(timecode);
   bkg.setAlpha(0);

effects/internal/texteffect.h

@@ -21,15 +21,24 @@
 #ifndef TEXTEFFECT_H
 #define TEXTEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
 #include <QFont>
 #include <QImage>
 
-class TextEffect : public Effect {
+class TextEffect : public Node {
   Q_OBJECT
 public:
-  TextEffect(Clip* c, const EffectMeta *em);
+  TextEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void redraw(double timecode) override;
 private slots:
   void outline_enable(bool);

effects/internal/timecodeeffect.cpp

@@ -42,10 +42,10 @@
 #include "ui/colorbutton.h"
 #include "global/config.h"
 
-TimecodeEffect::TimecodeEffect(Clip* c, const EffectMeta* em) :
-  Effect(c, em)
+TimecodeEffect::TimecodeEffect(Clip* c) :
+  Node(c)
 {
-  SetFlags(Effect::SuperimposeFlag);
+  SetFlags(Node::SuperimposeFlag);
 
   tc_select = new ComboInput(this, "tc_selector", tr("Timecode"));
   tc_select->AddItem(tr("Sequence"), true);
@@ -74,6 +74,41 @@ TimecodeEffect::TimecodeEffect(Clip* c, const EffectMeta* em) :
   prepend_text = new StringInput(this, "prepend", tr("Prepend"), false);
 }
 
+QString TimecodeEffect::name()
+{
+  return tr("Timecode");
+}
+
+QString TimecodeEffect::id()
+{
+  return "org.olivevideoeditor.Olive.timecode";
+}
+
+QString TimecodeEffect::category()
+{
+  return tr("Render");
+}
+
+QString TimecodeEffect::description()
+{
+  return tr("Render the media or sequence timecode on this clip.");
+}
+
+EffectType TimecodeEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType TimecodeEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr TimecodeEffect::Create(Clip *c)
+{
+  return std::make_shared<TimecodeEffect>(c);
+}
+
 
 void TimecodeEffect::redraw(double timecode) {
   Sequence* sequence = parent_clip->track()->sequence();

effects/internal/timecodeeffect.h

@@ -21,15 +21,24 @@
 #ifndef TIMECODEEFFECT_H
 #define TIMECODEEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
 #include <QFont>
 #include <QImage>
 
-class TimecodeEffect : public Effect {
+class TimecodeEffect : public Node {
   Q_OBJECT
 public:
-  TimecodeEffect(Clip* c, const EffectMeta *em);
+  TimecodeEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void redraw(double timecode) override;
   DoubleInput* scale_val;
   ColorInput* color_val;

effects/internal/toneeffect.cpp

@@ -27,7 +27,7 @@
 #include "timeline/clip.h"
 #include "timeline/sequence.h"
 
-ToneEffect::ToneEffect(Clip* c, const EffectMeta *em) : Effect(c, em), sinX(INT_MIN) {
+ToneEffect::ToneEffect(Clip* c) : Node(c), sinX(INT_MIN) {
   type_val = new ComboInput(this, "type", tr("Type"));
   type_val->AddItem(tr("Sine"), TONE_TYPE_SINE);
 
@@ -45,6 +45,36 @@ ToneEffect::ToneEffect(Clip* c, const EffectMeta *em) : Effect(c, em), sinX(INT_
   mix_val->SetValueAt(0, true);
 }
 
+QString ToneEffect::name()
+{
+  return tr("Tone");
+}
+
+QString ToneEffect::id()
+{
+  return "org.olivevideoeditor.Olive.tone";
+}
+
+QString ToneEffect::description()
+{
+  return tr("Generate a sine wave tone to mix into this clip's audio.");
+}
+
+EffectType ToneEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType ToneEffect::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr ToneEffect::Create(Clip *c)
+{
+  return std::make_shared<ToneEffect>(c);
+}
+
 void ToneEffect::process_audio(double timecode_start,
                                double timecode_end,
                                float **samples,

effects/internal/toneeffect.h

@@ -21,12 +21,20 @@
 #ifndef TONEEFFECT_H
 #define TONEEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class ToneEffect : public Effect {
+class ToneEffect : public Node {
   Q_OBJECT
 public:
-  ToneEffect(Clip* c, const EffectMeta* em);
+  ToneEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,
@@ -34,11 +42,12 @@ public:
                              int channel_count,
                              int type) override;
 
+private:
   ComboInput* type_val;
   DoubleInput* freq_val;
   DoubleInput* amount_val;
   BoolInput* mix_val;
-private:
+
   int sinX;
 };
 

effects/internal/transformeffect.cpp

@@ -43,8 +43,8 @@
 #include "panels/viewer.h"
 #include "ui/viewerwidget.h"
 
-TransformEffect::TransformEffect(Clip* c, const EffectMeta* em) : Effect(c, em) {
-  SetFlags(Effect::CoordsFlag);
+TransformEffect::TransformEffect(Clip* c) : Node(c) {
+  SetFlags(Node::CoordsFlag);
 
   position = new Vec2Input(this, "pos", tr("Position"));
 
@@ -125,6 +125,41 @@ TransformEffect::TransformEffect(Clip* c, const EffectMeta* em) : Effect(c, em)
   refresh();
 }
 
+QString TransformEffect::name()
+{
+  return tr("Transform");
+}
+
+QString TransformEffect::id()
+{
+  return "org.olivevideoeditor.Olive.transform";
+}
+
+QString TransformEffect::category()
+{
+  return tr("Distort");
+}
+
+QString TransformEffect::description()
+{
+  return tr("Transform the position, scale, and rotation of this clip.");
+}
+
+EffectType TransformEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType TransformEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+NodePtr TransformEffect::Create(Clip *c)
+{
+  return std::make_shared<TransformEffect>(c);
+}
+
 void TransformEffect::refresh() {
   if (parent_clip != nullptr && parent_clip->track()->sequence() != nullptr) {
 

effects/internal/transformeffect.h

@@ -21,12 +21,21 @@
 #ifndef TRANSFORMEFFECT_H
 #define TRANSFORMEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class TransformEffect : public Effect {
+class TransformEffect : public Node {
   Q_OBJECT
 public:
-  TransformEffect(Clip* c, const EffectMeta* em);
+  TransformEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString category() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void refresh() override;
   virtual void process_coords(double timecode, GLTextureCoords& coords, int data) override;
 

effects/internal/voideffect.cpp

@@ -27,24 +27,55 @@
 #include "ui/collapsiblewidget.h"
 #include "global/debug.h"
 
-VoidEffect::VoidEffect(Clip* c, const QString& n) : Effect(c, nullptr) {
-  QString display_name;
-  if (n.isEmpty()) {
-    display_name = tr("(unknown)");
-  } else {
-    display_name = n;
+VoidEffect::VoidEffect(Clip* c, const QString& n, const QString& id) :
+  Node(c),
+  display_name_(n),
+  id_(id)
+{
+  if (display_name_.isEmpty()) {
+    display_name_ = tr("(unknown)");
   }
 
-  new LabelWidget(this, tr("Missing Effect"), display_name);
-
-  name = display_name;
-
-  void_meta.type = EFFECT_TYPE_EFFECT;
-  meta = &void_meta;
+  new LabelWidget(this, tr("Missing Effect"), display_name_);
 }
 
-EffectPtr VoidEffect::copy(Clip* c) {
-  EffectPtr copy = std::make_shared<VoidEffect>(c, name);
+QString VoidEffect::name()
+{
+  return display_name_;
+}
+
+QString VoidEffect::id()
+{
+  return id_;
+}
+
+QString VoidEffect::description()
+{
+  return QString();
+}
+
+EffectType VoidEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType VoidEffect::subtype()
+{
+  return olive::kTypeVideo;
+}
+
+bool VoidEffect::IsCreatable()
+{
+  return false;
+}
+
+NodePtr VoidEffect::Create(Clip *)
+{
+  return nullptr;
+}
+
+NodePtr VoidEffect::copy(Clip* c) {
+  NodePtr copy = std::make_shared<VoidEffect>(c, display_name_, id_);
   copy->SetEnabled(IsEnabled());
   copy_field_keyframes(copy);
   return copy;
@@ -53,7 +84,7 @@ EffectPtr VoidEffect::copy(Clip* c) {
 void VoidEffect::load(QXmlStreamReader &stream) {
   QString tag = stream.name().toString();
 
-  QXmlStreamWriter writer(&bytes);
+  QXmlStreamWriter writer(&bytes_);
 
   // copy XML from reader to writer
   while (!stream.atEnd() && !(stream.name() == tag && stream.isEndElement())) {
@@ -75,18 +106,18 @@ void VoidEffect::load(QXmlStreamReader &stream) {
 }
 
 void VoidEffect::save(QXmlStreamWriter &stream) {
-  if (!name.isEmpty()) {
-    stream.writeAttribute("name", name);
+  if (!display_name_.isEmpty()) {
+    stream.writeAttribute("name", display_name_);
     stream.writeAttribute("enabled", QString::number(IsEnabled()));
 
     // force xml writer to expand <effect> tag, ignored when loading
     stream.writeStartElement("void");
     stream.writeEndElement();
 
-    if (!bytes.isEmpty()) {
+    if (!bytes_.isEmpty()) {
       // write stored data
       QIODevice* device = stream.device();
-      device->write(bytes);
+      device->write(bytes_);
     }
   }
 }

effects/internal/voideffect.h

@@ -27,19 +27,28 @@
  * isn't lost if the user saves over the project.
  */
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class VoidEffect : public Effect {
+class VoidEffect : public Node {
   Q_OBJECT
 public:
-  VoidEffect(Clip* c, const QString& n);
+  VoidEffect(Clip* c, const QString& n, const QString &id);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual bool IsCreatable() override;
+  virtual NodePtr Create(Clip *c) override;
+  virtual NodePtr copy(Clip* c) override;
 
-  virtual EffectPtr copy(Clip* c) override;
   virtual void load(QXmlStreamReader &stream) override;
   virtual void save(QXmlStreamWriter &stream) override;
 private:
-  QByteArray bytes;
-  EffectMeta void_meta;
+  QByteArray bytes_;
+  QString display_name_;
+  QString id_;
 };
 
 #endif // VOIDEFFECT_H

effects/internal/volumeeffect.cpp

@@ -28,7 +28,7 @@
 #include "ui/labelslider.h"
 #include "ui/collapsiblewidget.h"
 
-VolumeEffect::VolumeEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
+VolumeEffect::VolumeEffect(Clip* c) : Node(c) {
   volume_val = new DoubleInput(this, "volume", tr("Volume"));
 
   // set defaults
@@ -36,6 +36,36 @@ VolumeEffect::VolumeEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
   volume_val->SetDisplayType(LabelSlider::Decibel);
 }
 
+QString VolumeEffect::name()
+{
+  return tr("Volume");
+}
+
+QString VolumeEffect::id()
+{
+  return "org.olivevideoeditor.Olive.volume";
+}
+
+QString VolumeEffect::description()
+{
+  return tr("Adjust the volume of this clip's audio");
+}
+
+EffectType VolumeEffect::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType VolumeEffect::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr VolumeEffect::Create(Clip *c)
+{
+  return std::make_shared<VolumeEffect>(c);
+}
+
 void VolumeEffect::process_audio(double timecode_start,
                                  double timecode_end,
                                  float **samples,

effects/internal/volumeeffect.h

@@ -21,12 +21,20 @@
 #ifndef VOLUMEEFFECT_H
 #define VOLUMEEFFECT_H
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 
-class VolumeEffect : public Effect {
+class VolumeEffect : public Node {
   Q_OBJECT
 public:
-  VolumeEffect(Clip* c, const EffectMeta* em);
+  VolumeEffect(Clip* c);
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,
@@ -34,6 +42,7 @@ public:
                              int channel_count,
                              int type) override;
 
+private:
   DoubleInput* volume_val;
 };
 

effects/internal/vsthost.cpp

@@ -227,8 +227,8 @@ void VSTHost::send_data_cache_to_plugin()
   dispatcher(plugin, effSetChunk, 0, int32_t(data_cache.size()), static_cast<void*>(data_cache.data()), 0);
 }
 
-VSTHost::VSTHost(Clip* c, const EffectMeta *em) :
-  Effect(c, em),
+VSTHost::VSTHost(Clip* c) :
+  Node(c),
   plugin(nullptr),
   dialog(nullptr),
   input_cache(BLOCK_SIZE),
@@ -249,6 +249,36 @@ VSTHost::~VSTHost() {
   freePlugin();
 }
 
+QString VSTHost::name()
+{
+  return tr("VST Plugin 2.x");
+}
+
+QString VSTHost::id()
+{
+  return "org.olivevideoeditor.Olive.vst2x";
+}
+
+QString VSTHost::description()
+{
+  return tr("Use a VST 2.x plugin on this clip's audio.");
+}
+
+EffectType VSTHost::type()
+{
+  return EFFECT_TYPE_EFFECT;
+}
+
+olive::TrackType VSTHost::subtype()
+{
+  return olive::kTypeAudio;
+}
+
+NodePtr VSTHost::Create(Clip *c)
+{
+  return std::make_shared<VSTHost>(c);
+}
+
 void VSTHost::process_audio(double timecode_start,
                             double timecode_end,
                             float **samples,
@@ -291,7 +321,7 @@ void VSTHost::custom_load(QXmlStreamReader &stream) {
 }
 
 void VSTHost::save(QXmlStreamWriter &stream) {
-  Effect::save(stream);
+  Node::save(stream);
   if (plugin != nullptr) {
     char* p = nullptr;
     int32_t length = int32_t(dispatcher(plugin, effGetChunk, 0, 0, &p, 0));

effects/internal/vsthost.h

@@ -24,7 +24,7 @@
 #include <QDialog>
 #include <QLibrary>
 
-#include "effects/effect.h"
+#include "nodes/node.h"
 #include "include/vestige.h"
 
 // Plugin's dispatcher function
@@ -46,11 +46,19 @@ private:
   void destroy();
 };
 
-class VSTHost : public Effect {
+class VSTHost : public Node {
   Q_OBJECT
 public:
-  VSTHost(Clip* c, const EffectMeta* em);
-  ~VSTHost();
+  VSTHost(Clip* c);
+  virtual ~VSTHost() override;
+
+  virtual QString name() override;
+  virtual QString id() override;
+  virtual QString description() override;
+  virtual EffectType type() override;
+  virtual olive::TrackType subtype() override;
+  virtual NodePtr Create(Clip *c) override;
+
   virtual void process_audio(double timecode_start,
                              double timecode_end,
                              float **samples,