Merge branch 'master' into nodeviewredux

app/CMakeLists.txt

@@ -94,6 +94,7 @@ if(MSVC)
     /external:anglebrackets
     /external:W0
     "$<$<CONFIG:RELEASE>:/O2>"
+    "$<$<COMPILE_LANGUAGE:CXX>:/MP>"
   )
 else()
   target_compile_options(
@@ -155,6 +156,12 @@ if (WIN32)
     PRIVATE
     DbgHelp
   )
+elseif (APPLE)
+  target_link_libraries(
+    ${OLIVE_TARGET}
+    PRIVATE
+    "-framework ApplicationServices"
+  )
 endif()
 
 set(OLIVE_TS_FILES

app/codec/oiio/oiiodecoder.cpp

@@ -174,9 +174,10 @@ FramePtr OIIODecoder::RetrieveVideo(const rational &timecode, const int& divider
 
   FramePtr frame = Frame::Create();
 
-  frame->set_video_params(VideoRenderingParams(buffer_->spec().width / divider,
-                                               buffer_->spec().height / divider,
-                                               pix_fmt_));
+  frame->set_video_params(VideoRenderingParams(buffer_->spec().width,
+                                               buffer_->spec().height,
+                                               pix_fmt_,
+                                               divider));
   frame->allocate();
 
   if (divider == 1) {

app/config/config.cpp

@@ -83,15 +83,15 @@ void Config::SetDefaults()
   config_map_["DropWithoutSequenceBehavior"] = TimelineWidget::kDWSAsk;
   config_map_["Loop"] = false;
 
-  config_map_["NodeCatColor0"] = QVariant::fromValue(Color(0.25, 0.25, 0.65));
-  config_map_["NodeCatColor1"] = QVariant::fromValue(Color(0.6, 0.6, 0.85));
-  config_map_["NodeCatColor2"] = QVariant::fromValue(Color(0.75, 0.75, 0.45));
-  config_map_["NodeCatColor3"] = QVariant::fromValue(Color(0.25, 0.5, 0.25));
-  config_map_["NodeCatColor4"] = QVariant::fromValue(Color(0.25, 0.65, 0.25));
-  config_map_["NodeCatColor5"] = QVariant::fromValue(Color(0.35, 0.35, 0.35));
-  config_map_["NodeCatColor6"] = QVariant::fromValue(Color(0.45, 0.45, 0.45));
-  config_map_["NodeCatColor7"] = QVariant::fromValue(Color(0.7, 0.3, 0.7));
-  config_map_["NodeCatColor8"] = QVariant::fromValue(Color(0.85, 0.65, 0.4));
+  config_map_["NodeCatColor0"] = QVariant::fromValue(Color(0.25f, 0.25f, 0.65f));
+  config_map_["NodeCatColor1"] = QVariant::fromValue(Color(0.6f, 0.6f, 0.85f));
+  config_map_["NodeCatColor2"] = QVariant::fromValue(Color(0.75f, 0.75f, 0.45f));
+  config_map_["NodeCatColor3"] = QVariant::fromValue(Color(0.25f, 0.5f, 0.25f));
+  config_map_["NodeCatColor4"] = QVariant::fromValue(Color(0.25f, 0.65f, 0.25f));
+  config_map_["NodeCatColor5"] = QVariant::fromValue(Color(0.35f, 0.35f, 0.35f));
+  config_map_["NodeCatColor6"] = QVariant::fromValue(Color(0.45f, 0.45f, 0.45f));
+  config_map_["NodeCatColor7"] = QVariant::fromValue(Color(0.7f, 0.3f, 0.7f));
+  config_map_["NodeCatColor8"] = QVariant::fromValue(Color(0.85f, 0.65f, 0.4f));
 
   config_map_["AudioOutput"] = QString();
   config_map_["AudioInput"] = QString();

app/dialog/footageproperties/footageproperties.cpp

@@ -109,7 +109,7 @@ FootagePropertiesDialog::FootagePropertiesDialog(QWidget *parent, Footage *foota
 
   // Auto-select first item that actually has properties
   if (first_usable_stream >= 0) {
-    track_list->item(first_usable_stream)->setSelected(true);
+    track_list->setCurrentRow(first_usable_stream);
   }
   track_list->setFocus();
 }

app/dialog/projectproperties/projectproperties.cpp

@@ -44,10 +44,12 @@ ProjectPropertiesDialog::ProjectPropertiesDialog(Project* p, QWidget *parent) :
 
   setWindowTitle(tr("Project Properties for '%1'").arg(working_project_->name()));
 
+  QTabWidget* tabs = new QTabWidget;
+  layout->addWidget(tabs);
+
   {
     // Color management group
-    QGroupBox* color_group = new QGroupBox();
-    color_group->setTitle(tr("Color Management"));
+    QWidget* color_group = new QWidget();
 
     QGridLayout* color_layout = new QGridLayout(color_group);
 
@@ -72,18 +74,19 @@ ProjectPropertiesDialog::ProjectPropertiesDialog(Project* p, QWidget *parent) :
     color_layout->addWidget(browse_btn, 0, 2);
     connect(browse_btn, &QPushButton::clicked, this, &ProjectPropertiesDialog::BrowseForOCIOConfig);
 
-    layout->addWidget(color_group);
-
     ocio_filename_->setText(working_project_->color_manager()->GetConfigFilename());
 
     connect(ocio_filename_, &QLineEdit::textChanged, this, &ProjectPropertiesDialog::OCIOFilenameUpdated);
     OCIOFilenameUpdated();
+
+    tabs->addTab(color_group, tr("Color Management"));
   }
 
+  
+
   {
     // Paths group
-    QGroupBox* paths_group = new QGroupBox();
-    paths_group->setTitle(tr("Paths"));
+    QWidget* paths_group = new QWidget();
 
     QGridLayout* paths_layout = new QGridLayout(paths_group);
 
@@ -104,7 +107,7 @@ ProjectPropertiesDialog::ProjectPropertiesDialog(Project* p, QWidget *parent) :
     paths_layout->addWidget(proxy_path_->browse_btn(), row, 2);
     paths_layout->addWidget(proxy_path_->default_box(), row, 3);
 
-    layout->addWidget(paths_group);
+    tabs->addTab(paths_group, tr("Paths"));
   }
 
   QDialogButtonBox* dialog_btns = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
@@ -177,7 +180,7 @@ void ProjectPropertiesDialog::OCIOFilenameUpdated()
     if (ocio_filename_->text().isEmpty()) {
       c = ColorManager::GetDefaultConfig();
     } else {
-      c = OCIO::Config::CreateFromFile(ocio_filename_->text().toUtf8());
+      c = ColorManager::CreateConfigFromFile(ocio_filename_->text());
     }
 
     ocio_filename_->setStyleSheet(QString());

app/node/CMakeLists.txt

@@ -16,6 +16,7 @@
 
 add_subdirectory(audio)
 add_subdirectory(block)
+add_subdirectory(filter)
 add_subdirectory(generator)
 add_subdirectory(input)
 add_subdirectory(math)
@@ -27,8 +28,6 @@ set(OLIVE_SOURCES
   node/dependency.cpp
   node/edge.h
   node/edge.cpp
-  node/external.h
-  node/external.cpp
   node/factory.h
   node/factory.cpp
   node/graph.h
@@ -39,8 +38,6 @@ set(OLIVE_SOURCES
   node/inputarray.cpp
   node/keyframe.h
   node/keyframe.cpp
-  node/metareader.h
-  node/metareader.cpp
   node/node.h
   node/node.cpp
   node/output.h

app/node/block/block.cpp

@@ -365,4 +365,9 @@ void Block::InvalidateCache(const TimeRange &range, NodeInput *from, NodeInput *
   Node::InvalidateCache(range, from, source);
 }
 
+void Block::Hash(QCryptographicHash &, const rational &) const
+{
+  // A block does nothing by default
+}
+
 OLIVE_NAMESPACE_EXIT

app/node/block/block.h

@@ -99,6 +99,8 @@ public:
 
   virtual void InvalidateCache(const TimeRange& range, NodeInput* from, NodeInput* source) override;
 
+  virtual void Hash(QCryptographicHash &hash, const rational &time) const override;
+
 public slots:
 
 signals:

app/node/block/clip/clip.cpp

@@ -119,4 +119,13 @@ void ClipBlock::Retranslate()
   texture_input_->set_name(tr("Buffer"));
 }
 
+void ClipBlock::Hash(QCryptographicHash &hash, const rational &time) const
+{
+  if (texture_input_->IsConnected()) {
+    rational t = InputTimeAdjustment(texture_input_, TimeRange(time, time)).in();
+
+    texture_input_->get_connected_node()->Hash(hash, t);
+  }
+}
+
 OLIVE_NAMESPACE_EXIT

app/node/block/clip/clip.h

@@ -54,6 +54,8 @@ public:
 
   virtual void Retranslate() override;
 
+  virtual void Hash(QCryptographicHash &hash, const rational &time) const override;
+
 signals:
   void PreviewUpdated();
 

app/node/block/transition/CMakeLists.txt

@@ -16,8 +16,6 @@
 
 set(OLIVE_SOURCES
   ${OLIVE_SOURCES}
-  node/block/transition/externaltransition.h
-  node/block/transition/externaltransition.cpp
   node/block/transition/transition.h
   node/block/transition/transition.cpp
   PARENT_SCOPE

app/node/block/transition/externaltransition.cpp

@@ -1,93 +0,0 @@
-/***
-
-  Olive - Non-Linear Video Editor
-  Copyright (C) 2019 Olive Team
-
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-***/
-
-#include "externaltransition.h"
-
-OLIVE_NAMESPACE_ENTER
-
-ExternalTransition::ExternalTransition(const QString &xml_meta_filename) :
-  meta_(xml_meta_filename)
-{
-  foreach (NodeInput* input, meta_.inputs()) {
-    AddInput(input);
-  }
-}
-
-Node *ExternalTransition::copy() const
-{
-  return new ExternalTransition(meta_.filename());
-}
-
-QString ExternalTransition::Name() const
-{
-  return meta_.Name();
-}
-
-QString ExternalTransition::ShortName() const
-{
-  return meta_.ShortName();
-}
-
-QString ExternalTransition::id() const
-{
-  return meta_.id();
-}
-
-QList<Node::CategoryID> ExternalTransition::Category() const
-{
-  return meta_.Category();
-}
-
-QString ExternalTransition::Description() const
-{
-  return meta_.Description();
-}
-
-void ExternalTransition::Retranslate()
-{
-  meta_.Retranslate();
-}
-
-Node::Capabilities ExternalTransition::GetCapabilities(const NodeValueDatabase &) const
-{
-  return kShader;
-}
-
-QString ExternalTransition::ShaderVertexCode(const NodeValueDatabase &) const
-{
-  return meta_.vert_code();
-}
-
-QString ExternalTransition::ShaderFragmentCode(const NodeValueDatabase&) const
-{
-  return meta_.frag_code();
-}
-
-int ExternalTransition::ShaderIterations() const
-{
-  return meta_.iterations();
-}
-
-NodeInput *ExternalTransition::ShaderIterativeInput() const
-{
-  return meta_.iteration_input();
-}
-
-OLIVE_NAMESPACE_EXIT

app/node/block/transition/transition.cpp

@@ -131,8 +131,6 @@ double TransitionBlock::GetInProgress(const rational &time) const
 
 void TransitionBlock::Hash(QCryptographicHash &hash, const rational &time) const
 {
-  Block::Hash(hash, time);
-
   double all_prog = GetTotalProgress(time);
   double in_prog = GetInProgress(time);
   double out_prog = GetOutProgress(time);
@@ -140,6 +138,14 @@ void TransitionBlock::Hash(QCryptographicHash &hash, const rational &time) const
   hash.addData(reinterpret_cast<const char*>(&all_prog), sizeof(double));
   hash.addData(reinterpret_cast<const char*>(&in_prog), sizeof(double));
   hash.addData(reinterpret_cast<const char*>(&out_prog), sizeof(double));
+
+  if (out_block_input_->IsConnected()) {
+    out_block_input_->get_connected_node()->Hash(hash, time);
+  }
+
+  if (in_block_input_->IsConnected()) {
+    in_block_input_->get_connected_node()->Hash(hash, time);
+  }
 }
 
 double TransitionBlock::GetInternalTransitionTime(const rational &time) const

app/node/external.cpp

@@ -1,95 +0,0 @@
-/***
-
-  Olive - Non-Linear Video Editor
-  Copyright (C) 2019 Olive Team
-
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-***/
-
-#include "external.h"
-
-#include <QFile>
-
-OLIVE_NAMESPACE_ENTER
-
-ExternalNode::ExternalNode(const QString &xml_meta_filename) :
-  meta_(xml_meta_filename)
-{
-  foreach (NodeInput* input, meta_.inputs()) {
-    AddInput(input);
-  }
-}
-
-Node *ExternalNode::copy() const
-{
-  return new ExternalNode(meta_.filename());
-}
-
-QString ExternalNode::Name() const
-{
-  return meta_.Name();
-}
-
-QString ExternalNode::ShortName() const
-{
-  return meta_.ShortName();
-}
-
-QString ExternalNode::id() const
-{
-  return meta_.id();
-}
-
-QList<Node::CategoryID> ExternalNode::Category() const
-{
-  return meta_.Category();
-}
-
-QString ExternalNode::Description() const
-{
-  return meta_.Description();
-}
-
-void ExternalNode::Retranslate()
-{
-  meta_.Retranslate();
-}
-
-Node::Capabilities ExternalNode::GetCapabilities(const NodeValueDatabase &) const
-{
-  return kShader;
-}
-
-QString ExternalNode::ShaderVertexCode(const NodeValueDatabase&) const
-{
-  return meta_.vert_code();
-}
-
-QString ExternalNode::ShaderFragmentCode(const NodeValueDatabase&) const
-{
-  return meta_.frag_code();
-}
-
-int ExternalNode::ShaderIterations() const
-{
-  return meta_.iterations();
-}
-
-NodeInput *ExternalNode::ShaderIterativeInput() const
-{
-  return meta_.iteration_input();
-}
-
-OLIVE_NAMESPACE_EXIT

app/node/factory.cpp

@@ -24,16 +24,19 @@
 #include "audio/volume/volume.h"
 #include "block/clip/clip.h"
 #include "block/gap/gap.h"
-#include "block/transition/externaltransition.h"
 #include "generator/matrix/matrix.h"
+#include "generator/polygon/polygon.h"
+#include "generator/solid/solid.h"
+#include "filter/blur/blur.h"
+#include "filter/stroke/stroke.h"
 #include "input/media/video/video.h"
 #include "input/media/audio/audio.h"
 #include "input/time/timeinput.h"
 #include "math/math/math.h"
+#include "math/merge/merge.h"
 #include "math/trigonometry/trigonometry.h"
 #include "output/track/track.h"
 #include "output/viewer/viewer.h"
-#include "external.h"
 
 OLIVE_NAMESPACE_ENTER
 QList<Node*> NodeFactory::library_;
@@ -47,13 +50,10 @@ void NodeFactory::Initialize()
     library_.append(CreateInternal(static_cast<InternalID>(i)));
   }
 
-  library_.append(new ExternalNode(":/shaders/blur.xml"));
-  library_.append(new ExternalNode(":/shaders/solid.xml"));
-  library_.append(new ExternalNode(":/shaders/stroke.xml"));
-  library_.append(new ExternalNode(":/shaders/alphaover.xml"));
-  library_.append(new ExternalNode(":/shaders/dropshadow.xml"));
+  /*
   library_.append(new ExternalTransition(":/shaders/crossdissolve.xml"));
   library_.append(new ExternalTransition(":/shaders/diptoblack.xml"));
+  */
 }
 
 void NodeFactory::Destroy()
@@ -132,6 +132,8 @@ Node *NodeFactory::CreateInternal(const NodeFactory::InternalID &id)
     return new ClipBlock();
   case kGapBlock:
     return new GapBlock();
+  case kPolygonGenerator:
+    return new PolygonGenerator();
   case kMatrixGenerator:
     return new MatrixGenerator();
   case kVideoInput:
@@ -152,6 +154,14 @@ Node *NodeFactory::CreateInternal(const NodeFactory::InternalID &id)
     return new TrigonometryNode();
   case kTime:
     return new TimeInput();
+  case kBlurFilter:
+    return new BlurFilterNode();
+  case kSolidGenerator:
+    return new SolidGenerator();
+  case kMerge:
+    return new MergeNode();
+  case kStrokeFilter:
+    return new StrokeFilterNode();
 
   case kInternalNodeCount:
     break;

app/node/factory.h

@@ -36,6 +36,7 @@ public:
     kClipBlock,
     kGapBlock,
     kAudioInput,
+    kPolygonGenerator,
     kMatrixGenerator,
     kVideoInput,
     kTrackOutput,
@@ -44,6 +45,10 @@ public:
     kMath,
     kTime,
     kTrigonometry,
+    kBlurFilter,
+    kSolidGenerator,
+    kMerge,
+    kStrokeFilter,
 
     // Count value
     kInternalNodeCount

app/node/filter/CMakeLists.txt

@@ -0,0 +1,23 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+add_subdirectory(blur)
+add_subdirectory(stroke)
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  PARENT_SCOPE
+)

app/node/filter/blur/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  node/filter/blur/blur.h
+  node/filter/blur/blur.cpp
+  PARENT_SCOPE
+)

app/node/filter/blur/blur.cpp

@@ -0,0 +1,104 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "blur.h"
+
+OLIVE_NAMESPACE_ENTER
+
+BlurFilterNode::BlurFilterNode()
+{
+  texture_input_ = new NodeInput("tex_in", NodeParam::kTexture);
+  AddInput(texture_input_);
+
+  method_input_ = new NodeInput("method_in", NodeParam::kCombo, 0);
+  AddInput(method_input_);
+
+  radius_input_ = new NodeInput("radius_in", NodeParam::kFloat, 10.0f);
+  radius_input_->set_property(QStringLiteral("min"), 0.0f);
+  AddInput(radius_input_);
+
+  horiz_input_ = new NodeInput("horiz_in", NodeParam::kBoolean, true);
+  AddInput(horiz_input_);
+
+  vert_input_ = new NodeInput("vert_in", NodeParam::kBoolean, true);
+  AddInput(vert_input_);
+
+  repeat_edge_pixels_input_ = new NodeInput("repeat_edge_pixels_in", NodeParam::kBoolean, false);
+  AddInput(repeat_edge_pixels_input_);
+}
+
+Node *BlurFilterNode::copy() const
+{
+  return new BlurFilterNode();
+}
+
+QString BlurFilterNode::Name() const
+{
+  return tr("Blur");
+}
+
+QString BlurFilterNode::id() const
+{
+  return QStringLiteral("org.olivevideoeditor.Olive.blur");
+}
+
+QList<Node::CategoryID> BlurFilterNode::Category() const
+{
+  return {kCategoryFilter};
+}
+
+QString BlurFilterNode::Description() const
+{
+  return tr("Blurs an image.");
+}
+
+void BlurFilterNode::Retranslate()
+{
+  texture_input_->set_name(tr("Input"));
+  method_input_->set_name(tr("Method"));
+  method_input_->set_combobox_strings({ tr("Box"), tr("Gaussian") });
+  radius_input_->set_name(tr("Radius"));
+  horiz_input_->set_name(tr("Horizontal"));
+  vert_input_->set_name(tr("Vertical"));
+  repeat_edge_pixels_input_->set_name(tr("Repeat Edge Pixels"));
+}
+
+Node::Capabilities BlurFilterNode::GetCapabilities(const NodeValueDatabase &) const
+{
+  return kShader;
+}
+
+QString BlurFilterNode::ShaderFragmentCode(const NodeValueDatabase &) const
+{
+  return ReadFileAsString(":/shaders/blur.frag");
+}
+
+int BlurFilterNode::ShaderIterations() const
+{
+  // FIXME: Optimize if horiz_in or vert_in is disabled
+  return 2;
+}
+
+NodeInput *BlurFilterNode::ShaderIterativeInput() const
+{
+  return texture_input_;
+}
+
+OLIVE_NAMESPACE_EXIT

app/node/filter/blur/blur.h

@@ -18,24 +18,21 @@
 
 ***/
 
-#ifndef EXTERNALTRANSITION_H
-#define EXTERNALTRANSITION_H
+#ifndef BLURFILTERNODE_H
+#define BLURFILTERNODE_H
 
-#include "transition.h"
-
-#include "node/metareader.h"
+#include "node/node.h"
 
 OLIVE_NAMESPACE_ENTER
 
-class ExternalTransition : public TransitionBlock
+class BlurFilterNode : public Node
 {
 public:
-  ExternalTransition(const QString& xml_meta_filename);
+  BlurFilterNode();
 
   virtual Node* copy() const override;
 
   virtual QString Name() const override;
-  virtual QString ShortName() const override;
   virtual QString id() const override;
   virtual QList<CategoryID> Category() const override;
   virtual QString Description() const override;
@@ -43,15 +40,26 @@ public:
   virtual void Retranslate() override;
 
   virtual Capabilities GetCapabilities(const NodeValueDatabase&) const override;
-  virtual QString ShaderVertexCode(const NodeValueDatabase&) const override;
   virtual QString ShaderFragmentCode(const NodeValueDatabase&) const override;
+
   virtual int ShaderIterations() const override;
   virtual NodeInput* ShaderIterativeInput() const override;
 
 private:
-  NodeMetaReader meta_;
+  NodeInput* texture_input_;
+
+  NodeInput* method_input_;
+
+  NodeInput* radius_input_;
+
+  NodeInput* horiz_input_;
+
+  NodeInput* vert_input_;
+
+  NodeInput* repeat_edge_pixels_input_;
+
 };
 
 OLIVE_NAMESPACE_EXIT
 
-#endif // EXTERNALTRANSITION_H
+#endif // BLURFILTERNODE_H

app/node/filter/stroke/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  node/filter/stroke/stroke.h
+  node/filter/stroke/stroke.cpp
+  PARENT_SCOPE
+)

app/node/filter/stroke/stroke.cpp

@@ -0,0 +1,95 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "stroke.h"
+
+#include "render/color.h"
+
+OLIVE_NAMESPACE_ENTER
+
+StrokeFilterNode::StrokeFilterNode()
+{
+  tex_input_ = new NodeInput("tex_in", NodeParam::kTexture);
+  AddInput(tex_input_);
+
+  color_input_ = new NodeInput("color_in",
+                               NodeParam::kColor,
+                               QVariant::fromValue(Color(1.0f, 1.0f, 1.0f, 1.0f)));
+  AddInput(color_input_);
+
+  radius_input_ = new NodeInput("radius_in", NodeParam::kFloat, 10.0f);
+  radius_input_->set_property("min", 0.0f);
+  AddInput(radius_input_);
+
+  opacity_input_ = new NodeInput("opacity_in", NodeParam::kFloat, 1.0f);
+  opacity_input_->set_property("view", "percent");
+  opacity_input_->set_property("min", 0.0f);
+  opacity_input_->set_property("max", 1.0f);
+  AddInput(opacity_input_);
+
+  inner_input_ = new NodeInput("inner_in", NodeParam::kBoolean, false);
+  AddInput(inner_input_);
+}
+
+Node *StrokeFilterNode::copy() const
+{
+  return new StrokeFilterNode();
+}
+
+QString StrokeFilterNode::Name() const
+{
+  return tr("Stroke");
+}
+
+QString StrokeFilterNode::id() const
+{
+  return QStringLiteral("org.olivevideoeditor.Olive.stroke");
+}
+
+QList<Node::CategoryID> StrokeFilterNode::Category() const
+{
+  return {kCategoryFilter};
+}
+
+QString StrokeFilterNode::Description() const
+{
+  return tr("Creates a stroke outline around an image.");
+}
+
+void StrokeFilterNode::Retranslate()
+{
+  tex_input_->set_name(tr("Input"));
+  color_input_->set_name(tr("Color"));
+  radius_input_->set_name(tr("Radius"));
+  opacity_input_->set_name(tr("Opacity"));
+  inner_input_->set_name(tr("Inner"));
+}
+
+Node::Capabilities StrokeFilterNode::GetCapabilities(const NodeValueDatabase &) const
+{
+  return kShader;
+}
+
+QString StrokeFilterNode::ShaderFragmentCode(const NodeValueDatabase &) const
+{
+  return ReadFileAsString(":/shaders/stroke.frag");
+}
+
+OLIVE_NAMESPACE_EXIT

app/node/filter/stroke/stroke.h

@@ -18,28 +18,21 @@
 
 ***/
 
-#ifndef EXTERNALNODE_H
-#define EXTERNALNODE_H
+#ifndef STROKEFILTERNODE_H
+#define STROKEFILTERNODE_H
 
-#include <QXmlStreamReader>
-
-#include "node.h"
-#include "metareader.h"
+#include "node/node.h"
 
 OLIVE_NAMESPACE_ENTER
 
-/**
- * @brief A node generated from an external XML metadata file
- */
-class ExternalNode : public Node
+class StrokeFilterNode : public Node
 {
 public:
-  ExternalNode(const QString& xml_meta_filename);
+  StrokeFilterNode();
 
   virtual Node* copy() const override;
 
   virtual QString Name() const override;
-  virtual QString ShortName() const override;
   virtual QString id() const override;
   virtual QList<CategoryID> Category() const override;
   virtual QString Description() const override;
@@ -47,15 +40,21 @@ public:
   virtual void Retranslate() override;
 
   virtual Capabilities GetCapabilities(const NodeValueDatabase&) const override;
-  virtual QString ShaderVertexCode(const NodeValueDatabase&) const override;
   virtual QString ShaderFragmentCode(const NodeValueDatabase&) const override;
-  virtual int ShaderIterations() const override;
-  virtual NodeInput* ShaderIterativeInput() const override;
 
 private:
-  NodeMetaReader meta_;
+  NodeInput* tex_input_;
+
+  NodeInput* color_input_;
+
+  NodeInput* radius_input_;
+
+  NodeInput* opacity_input_;
+
+  NodeInput* inner_input_;
+
 };
 
 OLIVE_NAMESPACE_EXIT
 
-#endif // EXTERNALNODE_H
+#endif // STROKEFILTERNODE_H

app/node/generator/CMakeLists.txt

@@ -15,6 +15,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 add_subdirectory(matrix)
+add_subdirectory(polygon)
+add_subdirectory(solid)
 
 set(OLIVE_SOURCES
   ${OLIVE_SOURCES}

app/node/generator/matrix/matrix.cpp

@@ -89,30 +89,58 @@ void MatrixGenerator::Retranslate()
 }
 
 NodeValueTable MatrixGenerator::Value(NodeValueDatabase &value) const
+{
+  // Push matrix output
+  QMatrix4x4 mat = GenerateMatrix(value);
+  NodeValueTable output = value.Merge();
+  output.Push(NodeParam::kMatrix, mat);
+  return output;
+}
+
+bool MatrixGenerator::HasGizmos() const
+{
+  return true;
+}
+
+void MatrixGenerator::DrawGizmos(NodeValueDatabase &db, QPainter *p, const QVector2D &scale) const
+{
+  // FIXME: Implement this properly
+  /*
+  p->setPen(Qt::white);
+
+  // Fold values into a matrix
+  QMatrix4x4 matrix = GenerateMatrix(db);
+
+  // Set QPainter transform to our matrix
+  p->setTransform(matrix.toTransform());
+
+  // Draw ellipse
+  p->drawEllipse(QRect(0, 0, 100, 100));
+  */
+}
+
+QMatrix4x4 MatrixGenerator::GenerateMatrix(NodeValueDatabase &value) const
 {
   QMatrix4x4 mat;
 
   // Position translate
-  QVector2D pos = value[position_input_].Get(NodeParam::kVec2).value<QVector2D>();
+  QVector2D pos = value[position_input_].Take(NodeParam::kVec2).value<QVector2D>();
   mat.translate(pos);
 
   // Rotation
-  mat.rotate(value[rotation_input_].Get(NodeParam::kFloat).toFloat(), 0, 0, 1);
+  mat.rotate(value[rotation_input_].Take(NodeParam::kFloat).toFloat(), 0, 0, 1);
 
   // Scale and Uniform Scale
-  QVector2D scale = value[scale_input_].Get(NodeParam::kVec2).value<QVector2D>();
-  if (value[uniform_scale_input_].Get(NodeParam::kBoolean).toBool()) {
+  QVector2D scale = value[scale_input_].Take(NodeParam::kVec2).value<QVector2D>();
+  if (value[uniform_scale_input_].Take(NodeParam::kBoolean).toBool()) {
     scale.setY(scale.x());
   }
   mat.scale(scale);
 
   // Anchor Point
-  mat.translate(-value[anchor_input_].Get(NodeParam::kVec2).value<QVector2D>());
+  mat.translate(-value[anchor_input_].Take(NodeParam::kVec2).value<QVector2D>());
 
-  // Push matrix output
-  NodeValueTable output;
-  output.Push(NodeParam::kMatrix, mat);
-  return output;
+  return mat;
 }
 
 void MatrixGenerator::UniformScaleChanged()

app/node/generator/matrix/matrix.h

@@ -43,7 +43,12 @@ public:
 
   virtual NodeValueTable Value(NodeValueDatabase& value) const override;
 
+  virtual bool HasGizmos() const override;
+  virtual void DrawGizmos(NodeValueDatabase& db, QPainter *p, const QVector2D &scale) const override;
+
 private:
+  QMatrix4x4 GenerateMatrix(NodeValueDatabase& value) const;
+
   NodeInput* position_input_;
 
   NodeInput* rotation_input_;

app/node/generator/polygon/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  node/generator/polygon/polygon.h
+  node/generator/polygon/polygon.cpp
+  PARENT_SCOPE
+)

app/node/generator/polygon/polygon.cpp

@@ -0,0 +1,133 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "polygon.h"
+
+#include <QVector2D>
+
+OLIVE_NAMESPACE_ENTER
+
+PolygonGenerator::PolygonGenerator()
+{
+  points_input_ = new NodeInputArray("points_in", NodeParam::kVec2);
+  AddInput(points_input_);
+
+  color_input_ = new NodeInput("color_in", NodeParam::kColor);
+  AddInput(color_input_);
+
+  // Default to "a color" that isn't
+  color_input_->set_standard_value(1.0, 0);
+  color_input_->set_standard_value(1.0, 1);
+  color_input_->set_standard_value(1.0, 2);
+  color_input_->set_standard_value(1.0, 3);
+
+  // FIXME: Test code
+  points_input_->SetSize(5);
+  points_input_->At(0)->set_standard_value(960, 0);
+  points_input_->At(0)->set_standard_value(240, 1);
+  points_input_->At(1)->set_standard_value(640, 0);
+  points_input_->At(1)->set_standard_value(480, 1);
+  points_input_->At(2)->set_standard_value(760, 0);
+  points_input_->At(2)->set_standard_value(800, 1);
+  points_input_->At(3)->set_standard_value(1100, 0);
+  points_input_->At(3)->set_standard_value(800, 1);
+  points_input_->At(4)->set_standard_value(1280, 0);
+  points_input_->At(4)->set_standard_value(480, 1);
+  // End test
+}
+
+Node *PolygonGenerator::copy() const
+{
+  return new PolygonGenerator();
+}
+
+QString PolygonGenerator::Name() const
+{
+  return tr("Polygon");
+}
+
+QString PolygonGenerator::id() const
+{
+  return QStringLiteral("org.olivevideoeditor.Olive.polygon");
+}
+
+QList<Node::CategoryID> PolygonGenerator::Category() const
+{
+  return {kCategoryGenerator};
+}
+
+QString PolygonGenerator::Description() const
+{
+  return tr("Generate a 2D polygon of any amount of points.");
+}
+
+void PolygonGenerator::Retranslate()
+{
+  points_input_->set_name(tr("Points"));
+  color_input_->set_name(tr("Color"));
+}
+
+Node::Capabilities PolygonGenerator::GetCapabilities(const NodeValueDatabase &) const
+{
+  return kShader;
+}
+
+QString PolygonGenerator::ShaderFragmentCode(const NodeValueDatabase &) const
+{
+  return Node::ReadFileAsString(":/shaders/polygon.frag");
+}
+
+bool PolygonGenerator::HasGizmos() const
+{
+  return true;
+}
+
+void PolygonGenerator::DrawGizmos(NodeValueDatabase &db, QPainter *p, const QVector2D &scale) const
+{
+  if (!points_input_->GetSize()) {
+    return;
+  }
+
+  QVector<QPointF> points(points_input_->GetSize());
+
+  p->setPen(Qt::white);
+  p->setBrush(Qt::white);
+
+  int rect_sz = p->fontMetrics().height() / 8;
+
+  for (int i=0;i<points_input_->GetSize();i++) {
+    QVector2D v = db[points_input_->At(i)].Take(NodeParam::kVec2).value<QVector2D>();
+
+    v *= scale;
+
+    QPointF pt = v.toPointF();
+    points[i] = pt;
+
+    QRectF rect(pt - QPointF(rect_sz, rect_sz),
+                pt + QPointF(rect_sz, rect_sz));
+    p->drawRect(rect);
+  }
+
+  points.append(points.first());
+
+  p->drawPolyline(points.constData(), points.size());
+}
+
+OLIVE_NAMESPACE_EXIT

app/node/generator/polygon/polygon.h

@@ -0,0 +1,63 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef POLYGONGENERATOR_H
+#define POLYGONGENERATOR_H
+
+#include "node/node.h"
+
+OLIVE_NAMESPACE_ENTER
+
+class PolygonGenerator : public Node
+{
+public:
+  PolygonGenerator();
+
+  virtual Node* copy() const override;
+
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QList<CategoryID> Category() const override;
+  virtual QString Description() const override;
+
+  virtual void Retranslate() override;
+
+  virtual Capabilities GetCapabilities(const NodeValueDatabase&) const override;
+  virtual QString ShaderFragmentCode(const NodeValueDatabase&) const override;
+
+  virtual bool HasGizmos() const override;
+  virtual void DrawGizmos(NodeValueDatabase& db, QPainter *p, const QVector2D &scale) const override;
+
+  /*
+  virtual bool GizmoPress(const QPointF &p) override;
+  virtual void GizmoMove(const QPointF &p) override;
+  virtual void GizmoRelease(const QPointF &p) override;
+  */
+
+private:
+  NodeInputArray* points_input_;
+
+  NodeInput* color_input_;
+
+};
+
+OLIVE_NAMESPACE_EXIT
+
+#endif // POLYGONGENERATOR_H

app/node/generator/solid/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  node/generator/solid/solid.h
+  node/generator/solid/solid.cpp
+  PARENT_SCOPE
+)

app/node/generator/solid/solid.cpp

@@ -0,0 +1,76 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "solid.h"
+
+#include "render/color.h"
+
+OLIVE_NAMESPACE_ENTER
+
+SolidGenerator::SolidGenerator()
+{
+  // Default to a color that isn't black
+  color_input_ = new NodeInput("color_in",
+                               NodeInput::kColor,
+                               QVariant::fromValue(Color(1.0f, 0.0f, 0.0f, 1.0f)));
+  AddInput(color_input_);
+}
+
+Node *SolidGenerator::copy() const
+{
+  return new SolidGenerator();
+}
+
+QString SolidGenerator::Name() const
+{
+  return tr("Solid");
+}
+
+QString SolidGenerator::id() const
+{
+  return QStringLiteral("org.olivevideoeditor.Olive.solidgenerator");
+}
+
+QList<Node::CategoryID> SolidGenerator::Category() const
+{
+  return {kCategoryGenerator};
+}
+
+QString SolidGenerator::Description() const
+{
+  return tr("Generate a solid color.");
+}
+
+void SolidGenerator::Retranslate()
+{
+  color_input_->set_name(tr("Color"));
+}
+
+Node::Capabilities SolidGenerator::GetCapabilities(const NodeValueDatabase &) const
+{
+  return kShader;
+}
+
+QString SolidGenerator::ShaderFragmentCode(const NodeValueDatabase &) const
+{
+  return ReadFileAsString(":/shaders/solid.frag");
+}
+
+OLIVE_NAMESPACE_EXIT

app/node/generator/solid/solid.h

@@ -0,0 +1,52 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef SOLIDGENERATOR_H
+#define SOLIDGENERATOR_H
+
+#include "node/node.h"
+
+OLIVE_NAMESPACE_ENTER
+
+class SolidGenerator : public Node
+{
+public:
+  SolidGenerator();
+
+  virtual Node* copy() const override;
+
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QList<CategoryID> Category() const override;
+  virtual QString Description() const override;
+
+  virtual void Retranslate() override;
+
+  virtual Capabilities GetCapabilities(const NodeValueDatabase&) const override;
+  virtual QString ShaderFragmentCode(const NodeValueDatabase&) const override;
+
+private:
+  NodeInput* color_input_;
+
+};
+
+OLIVE_NAMESPACE_EXIT
+
+#endif // SOLIDGENERATOR_H

app/node/math/CMakeLists.txt

@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 add_subdirectory(math)
+add_subdirectory(merge)
 add_subdirectory(trigonometry)
 
 set(OLIVE_SOURCES

app/node/math/merge/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  node/math/merge/merge.h
+  node/math/merge/merge.cpp
+  PARENT_SCOPE
+)

app/node/math/merge/merge.cpp

@@ -0,0 +1,96 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "merge.h"
+
+OLIVE_NAMESPACE_ENTER
+
+MergeNode::MergeNode()
+{
+  base_in_ = new NodeInput("base_in", NodeParam::kTexture);
+  AddInput(base_in_);
+
+  blend_in_ = new NodeInput("blend_in", NodeParam::kTexture);
+  AddInput(blend_in_);
+}
+
+Node *MergeNode::copy() const
+{
+  return new MergeNode();
+}
+
+QString MergeNode::Name() const
+{
+  return tr("Merge");
+}
+
+QString MergeNode::id() const
+{
+  return QStringLiteral("org.olivevideoeditor.Olive.merge");
+}
+
+QList<Node::CategoryID> MergeNode::Category() const
+{
+  return {kCategoryMath};
+}
+
+QString MergeNode::Description() const
+{
+  return tr("Merge two textures together.");
+}
+
+void MergeNode::Retranslate()
+{
+  base_in_->set_name(tr("Base"));
+  blend_in_->set_name(tr("Blend"));
+}
+
+Node::Capabilities MergeNode::GetCapabilities(const NodeValueDatabase &) const
+{
+  return kShader;
+}
+
+QString MergeNode::ShaderFragmentCode(const NodeValueDatabase &) const
+{
+  return ReadFileAsString(":/shaders/alphaover.frag");
+}
+
+NodeInput *MergeNode::base_in() const
+{
+  return base_in_;
+}
+
+NodeInput *MergeNode::blend_in() const
+{
+  return blend_in_;
+}
+
+void MergeNode::Hash(QCryptographicHash &hash, const rational &time) const
+{
+  if (base_in_->IsConnected()) {
+    base_in_->get_connected_node()->Hash(hash, time);
+  }
+
+  if (blend_in_->IsConnected()) {
+    blend_in_->get_connected_node()->Hash(hash, time);
+  }
+}
+
+OLIVE_NAMESPACE_EXIT

app/node/math/merge/merge.h

@@ -0,0 +1,59 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef MERGENODE_H
+#define MERGENODE_H
+
+#include "node/node.h"
+
+OLIVE_NAMESPACE_ENTER
+
+class MergeNode : public Node
+{
+public:
+  MergeNode();
+
+  virtual Node* copy() const override;
+
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QList<CategoryID> Category() const override;
+  virtual QString Description() const override;
+
+  virtual void Retranslate() override;
+
+  virtual Capabilities GetCapabilities(const NodeValueDatabase&) const override;
+  virtual QString ShaderFragmentCode(const NodeValueDatabase&) const override;
+
+  NodeInput* base_in() const;
+  NodeInput* blend_in() const;
+
+  virtual void Hash(QCryptographicHash &hash, const rational &time) const override;
+
+private:
+  NodeInput* base_in_;
+
+  NodeInput* blend_in_;
+
+};
+
+OLIVE_NAMESPACE_EXIT
+
+#endif // MERGENODE_H

app/node/metareader.cpp

@@ -1,398 +0,0 @@
-/***
-
-  Olive - Non-Linear Video Editor
-  Copyright (C) 2019 Olive Team
-
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-***/
-
-#include "metareader.h"
-
-#include <QFile>
-
-#include "common/xmlutils.h"
-#include "config/config.h"
-#include "node.h"
-
-OLIVE_NAMESPACE_ENTER
-
-NodeMetaReader::NodeMetaReader(const QString &xml_meta_filename) :
-  xml_filename_(xml_meta_filename),
-  iterations_(1),
-  iteration_input_(nullptr)
-{
-  QFile metadata_file(xml_filename_);
-
-  if (metadata_file.open(QFile::ReadOnly)) {
-    QXmlStreamReader reader(&metadata_file);
-
-    while (XMLReadNextStartElement(&reader)) {
-      if (reader.name() == QStringLiteral("effect")) {
-        XMLReadEffect(&reader);
-      } else {
-        reader.skipCurrentElement();
-      }
-    }
-
-    metadata_file.close();
-  } else {
-    qWarning() << "Failed to load node metadata file" << xml_filename_;
-  }
-}
-
-QString NodeMetaReader::Name() const
-{
-  return GetStringForCurrentLanguage(&names_);
-}
-
-QString NodeMetaReader::ShortName() const
-{
-  if (short_names_.isEmpty()) {
-    return Name();
-  } else {
-    return GetStringForCurrentLanguage(&short_names_);
-  }
-}
-
-const QString &NodeMetaReader::id() const
-{
-  return id_;
-}
-
-QList<Node::CategoryID> NodeMetaReader::Category() const
-{
-  return categories_;
-}
-
-QString NodeMetaReader::Description() const
-{
-  return GetStringForCurrentLanguage(&descriptions_);
-}
-
-const QString &NodeMetaReader::filename() const
-{
-  return xml_filename_;
-}
-
-const QString &NodeMetaReader::frag_code() const
-{
-  return frag_code_;
-}
-
-const QString &NodeMetaReader::vert_code() const
-{
-  return vert_code_;
-}
-
-const int &NodeMetaReader::iterations() const
-{
-  return iterations_;
-}
-
-NodeInput *NodeMetaReader::iteration_input() const
-{
-  return iteration_input_;
-}
-
-const QList<NodeInput *> &NodeMetaReader::inputs() const
-{
-  return inputs_;
-}
-
-void NodeMetaReader::Retranslate()
-{
-  {
-    // Re-translate every parameter name
-    QMap<QString, LanguageMap>::const_iterator iterator;
-
-    // Iterate through parameter language tables that we have
-    for (iterator=param_names_.begin();iterator!=param_names_.end();iterator++) {
-      NodeInput* this_input = GetInputWithID(iterator.key());
-      this_input->set_name(GetStringForCurrentLanguage(&iterator.value()));
-    }
-  }
-
-  {
-    // Re-translate any combobox items
-    QMap<QString, QList<LanguageMap> >::const_iterator param_it;
-
-    for (param_it=combo_names_.begin(); param_it!=combo_names_.end(); param_it++) {
-      NodeInput* input = GetInputWithID(param_it.key());
-
-      QStringList combo_items;
-
-      foreach (const LanguageMap& lang_map, param_it.value()) {
-        combo_items.append(GetStringForCurrentLanguage(&lang_map));
-      }
-
-      input->set_combobox_strings(combo_items);
-    }
-  }
-}
-
-void NodeMetaReader::XMLReadLanguageString(QXmlStreamReader* reader, LanguageMap* map)
-{
-  QString lang;
-
-  // Traverse through name attributes for its language
-  XMLAttributeLoop(reader, attr) {
-    if (attr.name() == QStringLiteral("lang")) {
-      lang = attr.value().toString();
-
-      // We don't recognize any other "name" attributes at this time
-      break;
-    }
-  }
-
-  // Insert name with language into map
-  map->insert(lang, reader->readElementText().trimmed());
-}
-
-void NodeMetaReader::XMLReadEffect(QXmlStreamReader* reader)
-{
-  // Traverse through effect attributes for an ID
-  XMLAttributeLoop(reader, attr) {
-    if (attr.name() == QStringLiteral("id")) {
-      id_ = attr.value().toString();
-
-      // We don't recognize any other "effect" attributes at this time
-      break;
-    }
-  }
-
-  if (id_.isEmpty()) {
-    qWarning() << "Effect metadata" << xml_filename_ << "has no ID";
-    return;
-  }
-
-  // Continue reading for other metadata
-  while (XMLReadNextStartElement(reader)) {
-    if (reader->name() == QStringLiteral("name")) {
-      // Pick up name
-      XMLReadLanguageString(reader, &names_);
-    } else if (reader->name() == QStringLiteral("shortnames")) {
-      // Pick up short name
-      XMLReadLanguageString(reader, &short_names_);
-    } else if (reader->name() == QStringLiteral("category")) {
-      // Pick up category
-      QStringList category_ids = reader->readElementText().split(':');
-
-      foreach (const QString& id, category_ids) {
-        bool ok;
-
-        int try_parse = id.toInt(&ok);
-
-        if (!ok || try_parse < 0 || try_parse >= Node::kCategoryCount) {
-          continue;
-        }
-
-        categories_.append(static_cast<Node::CategoryID>(try_parse));
-      }
-    } else if (reader->name() == QStringLiteral("description")) {
-      // Pick up description
-      XMLReadLanguageString(reader, &descriptions_);
-    } else if (reader->name() == QStringLiteral("iterations")) {
-      // Pick up iterations
-      XMLReadIterations(reader);
-    } else if (reader->name() == QStringLiteral("fragment")) {
-      // Pick up fragment shader code
-      XMLReadShader(reader, frag_code_);
-    } else if (reader->name() == QStringLiteral("vertex")) {
-      // Pick up vertex shader code
-      XMLReadShader(reader, vert_code_);
-    } else if (reader->name() == QStringLiteral("param")) {
-      // Pick up a parameter
-      XMLReadParam(reader);
-    } else {
-      reader->skipCurrentElement();
-    }
-  }
-}
-
-void NodeMetaReader::XMLReadIterations(QXmlStreamReader* reader)
-{
-  int iteration_pickup = reader->readElementText().toInt();
-
-  if (iterations_ > 0) {
-    iterations_ = iteration_pickup;
-  } else {
-    // If the iteration value is invalid, don't set it, print an error instead
-    qWarning() << "Invalid iteration number in" << xml_filename_ << "- setting to default (1)";
-  }
-}
-
-void NodeMetaReader::XMLReadParam(QXmlStreamReader *reader)
-{
-  QString param_id;
-  NodeParam::DataType param_type = NodeParam::kAny;
-  bool is_iterative = false;
-
-  // Traverse through parameter attributes for an ID
-  XMLAttributeLoop(reader, attr) {
-    if (attr.name() == QStringLiteral("id")) {
-      param_id = attr.value().toString();
-    } else if (attr.name() == QStringLiteral("type")) {
-      param_type = NodeParam::StringToDataType(attr.value().toString());
-    } else if (attr.name() == QStringLiteral("iterative_input")) {
-      is_iterative = true;
-    }
-  }
-
-  if (param_id.isEmpty()) {
-    qWarning() << "Effect metadata" << xml_filename_ << "contains a parameter with no ID - parameter was not added";
-    return;
-  }
-
-  QVector<QVariant> default_val;
-  QHash<QString, QVariant> properties;
-  LanguageMap param_names;
-  QList<LanguageMap> combo_names;
-  QList<LanguageMap> combo_descriptions;
-
-  // Traverse through param contents for more data
-  while (XMLReadNextStartElement(reader)) {
-    // NOTE: readElementText() returns a string, but for number types (which min and max apply to), QVariant will
-    // convert them automatically
-    if (reader->name() == QStringLiteral("name")) {
-
-      // Insert language into map
-      XMLReadLanguageString(reader, &param_names);
-
-    } else if (reader->name() == QStringLiteral("default")) {
-
-      // Reads the default value
-      while (XMLReadNextStartElement(reader)) {
-        if (reader->name() == QStringLiteral("value")) {
-          default_val.append(NodeInput::StringToValue(param_type, reader->readElementText()));
-        } else {
-          reader->skipCurrentElement();
-        }
-      }
-
-    } else if (reader->name() == QStringLiteral("option")) {
-
-      // Read names and descriptions
-      LanguageMap names;
-      LanguageMap descriptions;
-
-      while (XMLReadNextStartElement(reader)) {
-        if (reader->name() == QStringLiteral("name")) {
-          XMLReadLanguageString(reader, &names);
-        } else if (reader->name() == QStringLiteral("description")) {
-          XMLReadLanguageString(reader, &descriptions);
-        } else {
-          reader->skipCurrentElement();
-        }
-      }
-
-      combo_names.append(names);
-      combo_descriptions.append(descriptions);
-
-    } else {
-      properties.insert(reader->name().toString(), reader->readElementText());
-    }
-  }
-
-  param_names_.insert(param_id, param_names);
-
-  // Insert combo options if they exist
-  if (!combo_names.isEmpty()) {
-    combo_names_.insert(param_id, combo_names);
-    combo_descriptions_.insert(param_id, combo_descriptions);
-  }
-
-  NodeInput* input = new NodeInput(param_id, param_type, default_val);
-
-  QHash<QString, QVariant>::const_iterator iterator;
-
-  for (iterator=properties.begin();iterator!=properties.end();iterator++) {
-    input->set_property(iterator.key(), iterator.value());
-  }
-
-  if (is_iterative) {
-    iteration_input_ = input;
-  }
-
-  inputs_.append(input);
-}
-
-void NodeMetaReader::XMLReadShader(QXmlStreamReader *reader, QString &destination)
-{
-  QString code_url;
-
-  // Traverse through parameter attributes for an ID
-  XMLAttributeLoop(reader, attr) {
-    if (attr.name() == QStringLiteral("url")) {
-      code_url = attr.value().toString();
-
-      // We don't recognize any other "shader" attributes at this time
-      break;
-    }
-  }
-
-  // Add code in file from URL
-  if (!code_url.isEmpty()) {
-    destination.append(Node::ReadFileAsString(code_url));
-  }
-
-  // Add any code that's inline in the XML
-  QString element_text = reader->readElementText().trimmed();
-  if (!element_text.isEmpty()) {
-    destination.append(element_text);
-  }
-}
-
-QString NodeMetaReader::GetStringForCurrentLanguage(const LanguageMap *language_map)
-{
-  if (language_map->isEmpty()) {
-    // There are no entries for this map, this must be an empty string
-    return QString();
-  }
-
-  // Get current language config
-  QString language = Config::Current()[QStringLiteral("Language")].toString();
-
-  // See if our map has an exact language match
-  QString str_for_lang = language_map->value(language);
-  if (!str_for_lang.isEmpty()) {
-    return str_for_lang;
-  }
-
-  // If not, try to find a match with the same language but not the same derivation
-  QString base_lang = language.split('_').first();
-  QList<QString> available_languages = language_map->keys();
-  foreach (const QString& l, available_languages) {
-    if (l.startsWith(base_lang)) {
-      // This is the same language, so we can return this
-      return language_map->value(l);
-    }
-  }
-
-  // We couldn't find an exact or close match, just return the first in the list
-  // (assume a string in the wrong language is better than no string at all)
-  return language_map->first();
-}
-
-NodeInput *NodeMetaReader::GetInputWithID(const QString &id) const
-{
-  foreach (NodeInput* input, inputs_) {
-    if (input->id() == id) {
-      return input;
-    }
-  }
-  return nullptr;
-}
-
-OLIVE_NAMESPACE_EXIT

app/node/metareader.h

@@ -1,92 +0,0 @@
-/***
-
-  Olive - Non-Linear Video Editor
-  Copyright (C) 2019 Olive Team
-
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-***/
-
-#ifndef NODEMETAREADER_H
-#define NODEMETAREADER_H
-
-#include <QMap>
-#include <QString>
-#include <QXmlStreamReader>
-
-#include "input.h"
-#include "node/node.h"
-
-OLIVE_NAMESPACE_ENTER
-
-class NodeMetaReader
-{
-public:
-  NodeMetaReader(const QString& xml_meta_filename);
-
-  QString Name() const;
-  QString ShortName() const;
-  const QString& id() const;
-  QList<Node::CategoryID> Category() const;
-  QString Description() const;
-
-  const QString& filename() const;
-
-  const QString& frag_code() const;
-  const QString& vert_code() const;
-
-  const int& iterations() const;
-  NodeInput* iteration_input() const;
-
-  const QList<NodeInput*>& inputs() const;
-
-  void Retranslate();
-
-private:
-  using LanguageMap = QMap<QString, QString>;
-
-  void XMLReadLanguageString(QXmlStreamReader* reader, LanguageMap *map);
-  void XMLReadEffect(QXmlStreamReader *reader);
-  void XMLReadIterations(QXmlStreamReader* reader);
-  void XMLReadParam(QXmlStreamReader* reader);
-  void XMLReadShader(QXmlStreamReader* reader, QString& destination);
-
-  static QString GetStringForCurrentLanguage(const LanguageMap *language_map);
-
-  NodeInput* GetInputWithID(const QString& id) const;
-
-  QString xml_filename_;
-
-  LanguageMap names_;
-  LanguageMap short_names_;
-  LanguageMap descriptions_;
-  QList<Node::CategoryID> categories_;
-  QMap<QString, LanguageMap > param_names_;
-  QMap<QString, QList<LanguageMap> > combo_names_;
-  QMap<QString, QList<LanguageMap> > combo_descriptions_;
-
-  QString id_;
-
-  QString frag_code_;
-  QString vert_code_;
-
-  int iterations_;
-  NodeInput* iteration_input_;
-
-  QList<NodeInput*> inputs_;
-};
-
-OLIVE_NAMESPACE_EXIT
-
-#endif // NODEMETAREADER_H

app/node/node.cpp

@@ -282,6 +282,28 @@ QList<NodeOutput *> Node::GetOutputs() const
   return {output_};
 }
 
+bool Node::HasGizmos() const
+{
+  return false;
+}
+
+void Node::DrawGizmos(NodeValueDatabase &, QPainter *, const QVector2D &) const
+{
+}
+
+bool Node::GizmoPress(const QPointF &)
+{
+  return false;
+}
+
+void Node::GizmoMove(const QPointF &)
+{
+}
+
+void Node::GizmoRelease(const QPointF &)
+{
+}
+
 const QString &Node::GetLabel() const
 {
   return label_;

app/node/node.h

@@ -23,6 +23,7 @@
 
 #include <QCryptographicHash>
 #include <QObject>
+#include <QPainter>
 #include <QPointF>
 #include <QXmlStreamWriter>
 
@@ -380,6 +381,14 @@ public:
 
   QList<NodeOutput*> GetOutputs() const;
 
+  virtual bool HasGizmos() const;
+
+  virtual void DrawGizmos(NodeValueDatabase& db, QPainter* p, const QVector2D &scale) const;
+
+  virtual bool GizmoPress(const QPointF& p);
+  virtual void GizmoMove(const QPointF& p);
+  virtual void GizmoRelease(const QPointF& p);
+
   const QString& GetLabel() const;
   void SetLabel(const QString& s);
 

app/node/output/track/track.cpp

@@ -420,11 +420,11 @@ NodeInputArray *TrackOutput::block_input() const
 
 void TrackOutput::Hash(QCryptographicHash &hash, const rational &time) const
 {
-  // Resolve block list
   Block* b = BlockAtTime(time);
 
+  // Defer to block at this time, don't add any of our own information to the hash
   if (b) {
-    return b->Hash(hash, time);
+    b->Hash(hash, time);
   }
 }
 

app/node/output/track/tracklist.cpp

@@ -22,6 +22,7 @@
 
 #include "node/factory.h"
 #include "node/math/math/math.h"
+#include "node/math/merge/merge.h"
 #include "node/output/viewer/viewer.h"
 
 OLIVE_NAMESPACE_ENTER
@@ -104,11 +105,11 @@ TrackOutput* TrackList::AddTrack()
           switch (type_) {
           case Timeline::kTrackTypeVideo:
           {
-            Node* blend = NodeFactory::CreateFromID(QStringLiteral("org.olivevideoeditor.Olive.alphaoverblend"));
+            MergeNode* blend = new MergeNode();
             GetParentGraph()->AddNode(blend);
 
-            NodeParam::ConnectEdge(track->output(), static_cast<NodeInput*>(blend->GetInputWithID("blend_in")));
-            NodeParam::ConnectEdge(last_track->output(), static_cast<NodeInput*>(blend->GetInputWithID("base_in")));
+            NodeParam::ConnectEdge(track->output(), blend->blend_in());
+            NodeParam::ConnectEdge(last_track->output(), blend->base_in());
             NodeParam::ConnectEdge(blend->output(), edge->input());
             break;
           }

app/node/param.cpp

@@ -71,14 +71,13 @@ Node *NodeParam::parentNode() const
 {
   QObject* p = parent();
 
-  while (p != nullptr) {
-    // Determine if this object is a Node or not
+  while (p) {
     Node* cast_test = dynamic_cast<Node*>(p);
-    if (cast_test != nullptr) {
+    if (cast_test) {
       return cast_test;
+    } else {
+      p = p->parent();
     }
-
-    p = p->parent();
   }
 
   return nullptr;

app/node/traverser.cpp

@@ -29,21 +29,29 @@ NodeValueDatabase NodeTraverser::GenerateDatabase(const Node* node, const TimeRa
   NodeValueDatabase database;
 
   // We need to insert tables into the database for each input
-  foreach (NodeParam* param, node->parameters()) {
+  QList<NodeInput*> inputs = node->GetInputsIncludingArrays();
+
+  foreach (NodeInput* input, inputs) {
     if (IsCancelled()) {
       return NodeValueDatabase();
     }
 
-    if (param->type() == NodeParam::kInput) {
-      NodeInput* input = static_cast<NodeInput*>(param);
-      TimeRange input_time = node->InputTimeAdjustment(input, range);
+    TimeRange input_time = node->InputTimeAdjustment(input, range);
 
-      NodeValueTable table = ProcessInput(input, input_time);
+    NodeValueTable table = ProcessInput(input, input_time);
 
-      InputProcessingEvent(input, input_time, &table);
+    // Exception for Footage types where we actually retrieve some Footage data from a decoder
+    if (input->data_type() == NodeParam::kFootage) {
+      StreamPtr stream = ResolveStreamFromInput(input);
 
-      database.Insert(input, table);
+      if (stream) {
+
+        FootageProcessingEvent(stream, input_time, &table);
+
+      }
     }
+
+    database.Insert(input, table);
   }
 
   // Insert global variables
@@ -79,8 +87,21 @@ NodeValueTable NodeTraverser::ProcessNode(const NodeDependency& dep)
 
 NodeValueTable NodeTraverser::RenderBlock(const TrackOutput *track, const TimeRange &range)
 {
-  // By default, don't bother traversing blocks
-  return NodeValueTable();
+  // By default, just follow the in point
+  Block* active_block = track->BlockAtTime(range.in());
+
+  NodeValueTable table;
+
+  if (active_block) {
+    table = ProcessNode(NodeDependency(active_block, range));
+  }
+
+  return table;
+}
+
+StreamPtr NodeTraverser::ResolveStreamFromInput(NodeInput *input)
+{
+  return input->get_standard_value().value<StreamPtr>();
 }
 
 NodeValueTable NodeTraverser::ProcessInput(const NodeInput *input, const TimeRange& range)

app/node/traverser.h

@@ -37,17 +37,20 @@ public:
 
   NodeValueTable ProcessNode(const NodeDependency &dep);
 
-protected:
   NodeValueDatabase GenerateDatabase(const Node *node, const TimeRange &range);
 
+protected:
   virtual NodeValueTable RenderBlock(const TrackOutput *track, const TimeRange& range);
 
   NodeValueTable ProcessInput(const NodeInput* input, const TimeRange &range);
 
-  virtual void InputProcessingEvent(NodeInput*, const TimeRange&, NodeValueTable*){}
+  virtual void FootageProcessingEvent(StreamPtr, const TimeRange&, NodeValueTable*){}
 
   virtual void ProcessNodeEvent(const Node*, const TimeRange&, NodeValueDatabase&, NodeValueTable&){}
 
+private:
+  StreamPtr ResolveStreamFromInput(NodeInput* input);
+
 };
 
 OLIVE_NAMESPACE_EXIT

app/panel/param/param.cpp

@@ -33,6 +33,7 @@ ParamPanel::ParamPanel(QWidget* parent) :
   connect(view, &NodeParamView::RequestSelectNode, this, &ParamPanel::RequestSelectNode);
   connect(view, &NodeParamView::OpenedNode, this, &ParamPanel::OpeningNode);
   connect(view, &NodeParamView::ClosedNode, this, &ParamPanel::ClosingNode);
+  connect(view, &NodeParamView::FoundGizmos, this, &ParamPanel::FoundGizmos);
   SetTimeBasedWidget(view);
 
   Retranslate();

app/panel/param/param.h

@@ -45,6 +45,8 @@ signals:
 
   void RequestSelectNode(const QList<Node*>& target);
 
+  void FoundGizmos(Node* node);
+
 protected:
   virtual void Retranslate() override;
 

app/panel/pixelsampler/pixelsamplerpanel.h

@@ -22,7 +22,7 @@
 #define PIXELSAMPLERPANEL_H
 
 #include "widget/panel/panel.h"
-#include "widget/viewer/pixelsamplerwidget.h"
+#include "widget/pixelsampler/pixelsampler.h"
 
 OLIVE_NAMESPACE_ENTER
 

app/panel/viewer/viewerbase.cpp

@@ -90,6 +90,11 @@ void ViewerPanelBase::SetFullScreen(QScreen *screen)
   static_cast<ViewerWidget*>(GetTimeBasedWidget())->SetFullScreen(screen);
 }
 
+void ViewerPanelBase::SetGizmos(Node *node)
+{
+  static_cast<ViewerWidget*>(GetTimeBasedWidget())->SetGizmos(node);
+}
+
 void ViewerPanelBase::CreateScopePanel(ScopePanel::Type type)
 {
   ViewerWidget* vw = static_cast<ViewerWidget*>(GetTimeBasedWidget());

app/panel/viewer/viewerbase.h

@@ -56,6 +56,9 @@ public:
    */
   void SetFullScreen(QScreen* screen = nullptr);
 
+public slots:
+  void SetGizmos(Node* node);
+
 protected:
   void CreateScopePanel(ScopePanel::Type type);
 

app/render/backend/audiorenderbackend.cpp

@@ -124,7 +124,7 @@ TimeRange AudioRenderBackend::PopNextFrameFromQueue()
   return range;
 }
 
-void AudioRenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range)
+void AudioRenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible)
 {
   if (!ic_from_conform_) {
     // Cancel any ranges waiting on a conform here since obviously the contents have changed
@@ -153,7 +153,7 @@ void AudioRenderBackend::InvalidateCacheInternal(const rational &start_range, co
     }
   }
 
-  RenderBackend::InvalidateCacheInternal(start_range, end_range);
+  RenderBackend::InvalidateCacheInternal(start_range, end_range, only_visible);
 }
 
 void AudioRenderBackend::ListenForConformSignal(AudioStreamPtr s)

app/render/backend/audiorenderbackend.h

@@ -67,7 +67,7 @@ protected:
 
   virtual TimeRange PopNextFrameFromQueue() override;
 
-  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range) override;
+  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible) override;
 
 private:
   struct ConformWaitInfo {

app/render/backend/opengl/openglproxy.cpp

@@ -110,7 +110,10 @@ void OpenGLProxy::FrameToValue(FramePtr frame, StreamPtr stream, NodeValueTable*
       bool has_alpha = PixelFormat::FormatHasAlphaChannel(frame->format());
 
       // Convert frame to float for OCIO
-      frame = PixelFormat::ConvertPixelFormat(frame, has_alpha ? PixelFormat::PIX_FMT_RGBA32F : PixelFormat::PIX_FMT_RGB32F);
+      frame = PixelFormat::ConvertPixelFormat(frame,
+                                              has_alpha
+                                              ? PixelFormat::PIX_FMT_RGBA32F
+                                              : PixelFormat::PIX_FMT_RGB32F);
 
       // If alpha is associated, disassociate for the color transform
       if (has_alpha && video_stream->premultiplied_alpha()) {
@@ -281,7 +284,25 @@ void OpenGLProxy::RunNodeAccelerated(const Node *node, const TimeRange &range, N
           shader->setUniformValue(variable_location, value.toFloat());
           break;
         case NodeInput::kVec2:
-          shader->setUniformValue(variable_location, value.value<QVector2D>());
+          if (input->IsArray()) {
+            NodeInputArray* array = static_cast<NodeInputArray*>(input);
+            QVector<QVector2D> a(array->GetSize());
+
+            for (int i=0;i<a.size();i++) {
+              a[i] = input_params[array->At(i)].Get(NodeParam::kVec2).value<QVector2D>();
+            }
+
+            shader->setUniformValueArray(variable_location, a.constData(), a.size());
+
+            int count_location = shader->uniformLocation(QStringLiteral("%1_count").arg(input->id()));
+            if (count_location > -1) {
+              shader->setUniformValue(count_location,
+                                      array->GetSize());
+            }
+
+          } else {
+            shader->setUniformValue(variable_location, value.value<QVector2D>());
+          }
           break;
         case NodeInput::kVec3:
           shader->setUniformValue(variable_location, value.value<QVector3D>());

app/render/backend/renderbackend.cpp

@@ -259,6 +259,8 @@ void RenderBackend::CacheNext()
       SetWorkerBusyState(worker, true);
       cancel_dialog_->WorkerStarted();
 
+      WorkerAboutToStartEvent(worker);
+
       QMetaObject::invokeMethod(worker,
                                 "Render",
                                 Qt::QueuedConnection,
@@ -290,24 +292,14 @@ void RenderBackend::CancelQueue()
   cancel_dialog_->RunIfWorkersAreBusy();
 }
 
+void RenderBackend::InvalidateVisible(const TimeRange &range, NodeInput *from)
+{
+  InvalidateCacheVeryInternal(range, from, true);
+}
+
 void RenderBackend::InvalidateCache(const TimeRange &range, NodeInput *from)
 {
-  // Adjust range to min/max values
-  rational start_range_adj = qMax(rational(0), range.in());
-  rational end_range_adj = qMin(GetSequenceLength(), range.out());
-
-  qDebug() << "Cache invalidated between"
-           << start_range_adj.toDouble()
-           << "and"
-           << end_range_adj.toDouble();
-
-  if (from) {
-    // Queue value update
-    qDebug() << "  from" << from->parentNode()->id() << "::" << from->id();
-    QueueValueUpdate(from);
-  }
-
-  InvalidateCacheInternal(start_range_adj, end_range_adj);
+  InvalidateCacheVeryInternal(range, from, false);
 }
 
 bool RenderBackend::ViewerIsConnected() const
@@ -349,6 +341,26 @@ void RenderBackend::SetWorkerBusyState(RenderWorker *worker, bool busy)
   processor_busy_state_.replace(processors_.indexOf(worker), busy);
 }
 
+void RenderBackend::InvalidateCacheVeryInternal(const TimeRange &range, NodeInput *from, bool only_visible)
+{
+  // Adjust range to min/max values
+  rational start_range_adj = qMax(rational(0), range.in());
+  rational end_range_adj = qMin(GetSequenceLength(), range.out());
+
+  qDebug() << "Cache invalidated between"
+           << start_range_adj.toDouble()
+           << "and"
+           << end_range_adj.toDouble();
+
+  if (from) {
+    // Queue value update
+    qDebug() << "  from" << from->parentNode()->id() << "::" << from->id();
+    QueueValueUpdate(from);
+  }
+
+  InvalidateCacheInternal(start_range_adj, end_range_adj, only_visible);
+}
+
 void RenderBackend::CopyNodeInputValue(NodeInput *input)
 {
   // Find our copy of this parameter
@@ -446,8 +458,10 @@ const QVector<QThread *> &RenderBackend::threads()
   return threads_;
 }
 
-void RenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range)
+void RenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible)
 {
+  Q_UNUSED(only_visible)
+
   // Add the range to the list
   cache_queue_.InsertTimeRange(TimeRange(start_range, end_range));
 
@@ -459,6 +473,11 @@ void RenderBackend::CacheIDChangedEvent(const QString &id)
   Q_UNUSED(id)
 }
 
+void RenderBackend::WorkerAboutToStartEvent(RenderWorker *worker)
+{
+  Q_UNUSED(worker)
+}
+
 void RenderBackend::InitWorkers()
 {
   for (int i=0;i<processors_.size();i++) {

app/render/backend/renderbackend.h

@@ -51,6 +51,8 @@ public:
 
   void CancelQueue();
 
+  void InvalidateVisible(const TimeRange &range, NodeInput *from);
+
 public slots:
   void InvalidateCache(const TimeRange &range, NodeInput *from);
 
@@ -77,10 +79,12 @@ protected:
    */
   virtual bool GenerateCacheIDInternal(QCryptographicHash& hash) = 0;
 
-  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range);
+  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible);
 
   virtual void CacheIDChangedEvent(const QString& id);
 
+  virtual void WorkerAboutToStartEvent(RenderWorker* worker);
+
   void SetError(const QString& error);
 
   virtual void ConnectViewer(ViewerOutput* node);
@@ -120,6 +124,8 @@ protected:
   NodeGraph copied_graph_;
 
 private:
+  void InvalidateCacheVeryInternal(const TimeRange &range, NodeInput *from, bool only_visible);
+
   void CopyNodeInputValue(NodeInput* input);
   Node *CopyNodeConnections(Node *src_node);
   void CopyNodeMakeConnection(NodeInput *src_input, NodeInput *dst_input);

app/render/backend/renderworker.cpp

@@ -76,11 +76,6 @@ void RenderWorker::RunNodeAccelerated(const Node *node, const TimeRange &range,
   Q_UNUSED(output_params)
 }
 
-StreamPtr RenderWorker::ResolveStreamFromInput(NodeInput *input)
-{
-  return input->get_standard_value().value<StreamPtr>();
-}
-
 DecoderPtr RenderWorker::ResolveDecoderFromInput(StreamPtr stream)
 {
   // Access a map of Node inputs and decoder instances and retrieve a frame!
@@ -108,21 +103,12 @@ bool RenderWorker::IsStarted()
   return started_;
 }
 
-void RenderWorker::InputProcessingEvent(NodeInput* input, const TimeRange& input_time, NodeValueTable *table)
+void RenderWorker::FootageProcessingEvent(StreamPtr stream, const TimeRange& input_time, NodeValueTable *table)
 {
-  // Exception for Footage types where we actually retrieve some Footage data from a decoder
-  if (input->data_type() == NodeParam::kFootage) {
-    StreamPtr stream = ResolveStreamFromInput(input);
+  DecoderPtr decoder = ResolveDecoderFromInput(stream);
 
-    if (stream) {
-      DecoderPtr decoder = ResolveDecoderFromInput(stream);
-
-      if (decoder) {
-
-        FrameToValue(decoder, stream, input_time, table);
-
-      }
-    }
+  if (decoder) {
+    FrameToValue(decoder, stream, input_time, table);
   }
 }
 

app/render/backend/renderworker.h

@@ -59,12 +59,10 @@ protected:
 
   virtual void FrameToValue(DecoderPtr decoder, StreamPtr stream, const TimeRange &range, NodeValueTable* table) = 0;
 
-  virtual void InputProcessingEvent(NodeInput *input, const TimeRange &input_time, NodeValueTable* table) override;
+  virtual void FootageProcessingEvent(StreamPtr stream, const TimeRange &input_time, NodeValueTable* table) override;
 
   virtual void ProcessNodeEvent(const Node *node, const TimeRange &range, NodeValueDatabase &input_params, NodeValueTable &output_params) override;
 
-  StreamPtr ResolveStreamFromInput(NodeInput* input);
-
   DecoderPtr ResolveDecoderFromInput(StreamPtr stream);
 
   const NodeDependency& CurrentPath() const;

app/render/backend/videorenderbackend.cpp

@@ -41,7 +41,8 @@ VideoRenderBackend::VideoRenderBackend(QObject *parent) :
   operating_mode_(VideoRenderWorker::kHashRenderCache),
   only_signal_last_frame_requested_(true),
   limit_caching_(true),
-  pop_toggle_(false)
+  pop_toggle_(false),
+  queue_is_visible_only_(false)
 {
   connect(DiskManager::instance(), &DiskManager::DeletedFrame, this, &VideoRenderBackend::FrameRemovedFromDiskCache);
 }
@@ -152,7 +153,7 @@ void VideoRenderBackend::ConnectWorkerToThis(RenderWorker *processor)
   connect(video_processor, &VideoRenderWorker::GeneratedFrame, this, &VideoRenderBackend::ThreadGeneratedFrame, Qt::QueuedConnection);
 }
 
-void VideoRenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range)
+void VideoRenderBackend::InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible)
 {
   TimeRange invalidated(start_range, end_range);
 
@@ -160,7 +161,39 @@ void VideoRenderBackend::InvalidateCacheInternal(const rational &start_range, co
 
   emit RangeInvalidated(invalidated);
 
-  Requeue();
+  queue_is_visible_only_ = only_visible;
+
+  if (only_visible) {
+
+    // We're only caching this frame, and for maximum responsiveness, should cancel the rest of the
+    // queue
+    cache_queue_.clear();
+    cache_queue_.InsertTimeRange(TimeRange(start_range, end_range));
+
+    CacheNext();
+
+  } else {
+
+    // Rework the queue
+    Requeue();
+
+  }
+}
+
+void VideoRenderBackend::WorkerAboutToStartEvent(RenderWorker *worker)
+{
+  if (operating_mode_ & VideoRenderWorker::kDownloadOnly) {
+    int mode = operating_mode_;
+
+    if (queue_is_visible_only_) {
+      mode &= ~VideoRenderWorker::kDownloadOnly;
+    } else {
+      mode |= VideoRenderWorker::kDownloadOnly;
+    }
+
+    static_cast<VideoRenderWorker*>(worker)->
+        SetOperatingMode(static_cast<VideoRenderWorker::OperatingMode>(mode));
+  }
 }
 
 VideoRenderFrameCache *VideoRenderBackend::frame_cache()
@@ -201,9 +234,11 @@ QString VideoRenderBackend::GetCachedFrame(const rational &time)
 
 void VideoRenderBackend::UpdateLastRequestedTime(const rational &time)
 {
-  last_time_requested_ = time;
+  if (last_time_requested_ != time) {
+    last_time_requested_ = time;
 
-  Requeue();
+    Requeue();
+  }
 }
 
 NodeInput *VideoRenderBackend::GetDependentInput()

app/render/backend/videorenderbackend.h

@@ -99,10 +99,12 @@ protected:
 
   virtual void ConnectWorkerToThis(RenderWorker* processor) override;
 
-  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range) override;
+  virtual void InvalidateCacheInternal(const rational &start_range, const rational &end_range, bool only_visible) override;
 
   virtual void ParamsChangedEvent(){}
 
+  virtual void WorkerAboutToStartEvent(RenderWorker* worker) override;
+
   VideoRenderWorker::OperatingMode operating_mode_;
 
 signals:
@@ -135,6 +137,8 @@ private:
 
   bool pop_toggle_;
 
+  bool queue_is_visible_only_;
+
 private slots:
   void ThreadCompletedDownload(NodeDependency dep, qint64 job_time, QByteArray hash);
   void ThreadSkippedFrame(NodeDependency dep, qint64 job_time, QByteArray hash);

app/render/backend/videorenderworker.cpp

@@ -201,20 +201,6 @@ void VideoRenderWorker::ResizeDownloadBuffer()
   download_buffer_.resize(PixelFormat::GetBufferSize(video_params_.format(), video_params_.effective_width(), video_params_.effective_height()));
 }
 
-NodeValueTable VideoRenderWorker::RenderBlock(const TrackOutput *track, const TimeRange &range)
-{
-  // A frame can only have one active block so we just validate the in point of the range
-  Block* active_block = track->BlockAtTime(range.in());
-
-  NodeValueTable table;
-
-  if (active_block) {
-    table = ProcessNode(NodeDependency(active_block, range));
-  }
-
-  return table;
-}
-
 ColorProcessorCache *VideoRenderWorker::color_cache()
 {
   return &color_cache_;

app/render/backend/videorenderworker.h

@@ -92,14 +92,12 @@ protected:
 
   virtual void ParametersChangedEvent(){}
 
-  virtual void TextureToBuffer(const QVariant& texture, void *buffer, int linesize);
+  void TextureToBuffer(const QVariant& texture, void *buffer, int linesize);
 
   virtual void TextureToBuffer(const QVariant& texture, int width, int height, const QMatrix4x4& matrix, void *buffer, int linesize) = 0;
 
   virtual NodeValueTable RenderInternal(const NodeDependency& CurrentPath, const qint64& job_time) override;
 
-  virtual NodeValueTable RenderBlock(const TrackOutput *track, const TimeRange& range) override;
-
   ColorProcessorCache* color_cache();
 
 private:

app/render/colormanager.cpp

@@ -49,6 +49,13 @@ OCIO::ConstConfigRcPtr ColorManager::GetConfig() const
   return config_;
 }
 
+OCIO::ConstConfigRcPtr ColorManager::CreateConfigFromFile(const QString &filename)
+{
+  OCIO_SET_C_LOCALE_FOR_SCOPE;
+
+  return OCIO::Config::CreateFromFile(filename.toUtf8());
+}
+
 const QString &ColorManager::GetConfigFilename() const
 {
   return config_filename_;
@@ -61,7 +68,10 @@ OCIO::ConstConfigRcPtr ColorManager::GetDefaultConfig()
 
 void ColorManager::SetUpDefaultConfig()
 {
+  OCIO_SET_C_LOCALE_FOR_SCOPE;
+
   if (!qgetenv("OCIO").isEmpty()) {
+    // Attempt to set config from "OCIO" environment variable
     try {
       default_config_ = OCIO::Config::CreateFromEnv();
 
@@ -71,7 +81,7 @@ void ColorManager::SetUpDefaultConfig()
     }
   }
 
-  // Kind of hacky, but it'll work
+  // Extract OCIO config - kind of hacky, but it'll work
   QString dir = QDir(FileFunctions::GetTempFilePath()).filePath(QStringLiteral("ocioconf"));
 
   FileFunctions::CopyDirectory(QStringLiteral(":/ocioconf"),
@@ -80,7 +90,7 @@ void ColorManager::SetUpDefaultConfig()
 
   qDebug() << "Extracting default OCIO config to" << dir;
 
-  default_config_ = OCIO::Config::CreateFromFile(QDir(dir).filePath(QStringLiteral("config.ocio")).toUtf8());
+  default_config_ = CreateConfigFromFile(QDir(dir).filePath(QStringLiteral("config.ocio")));
 }
 
 void ColorManager::SetConfig(const QString &filename)
@@ -372,4 +382,15 @@ void ColorManager::AssociateAlphaInternal(ColorManager::AlphaAction action, T *d
   }
 }
 
+ColorManager::SetLocale::SetLocale(const char* new_locale)
+{
+  old_locale_ = setlocale(LC_NUMERIC, nullptr);
+  setlocale(LC_NUMERIC, new_locale);
+}
+
+ColorManager::SetLocale::~SetLocale()
+{
+  setlocale(LC_NUMERIC, old_locale_.toUtf8());
+}
+
 OLIVE_NAMESPACE_EXIT

app/render/colormanager.h

@@ -26,6 +26,8 @@
 #include "codec/frame.h"
 #include "colorprocessor.h"
 
+#define OCIO_SET_C_LOCALE_FOR_SCOPE ColorManager::SetLocale d("C")
+
 OLIVE_NAMESPACE_ENTER
 
 class ColorManager : public QObject
@@ -36,6 +38,8 @@ public:
 
   OCIO::ConstConfigRcPtr GetConfig() const;
 
+  static OCIO::ConstConfigRcPtr CreateConfigFromFile(const QString& filename);
+
   const QString& GetConfigFilename() const;
 
   static OCIO::ConstConfigRcPtr GetDefaultConfig();
@@ -90,6 +94,18 @@ public:
 
   static void SetOCIOMethodForMode(RenderMode::Mode mode, OCIOMethod method);
 
+  class SetLocale
+  {
+  public:
+    SetLocale(const char* new_locale);
+
+    ~SetLocale();
+
+  private:
+    QString old_locale_;
+
+  };
+
 signals:
   void ConfigChanged();
 

app/render/colorprocessor.cpp

@@ -44,10 +44,12 @@ ColorProcessor::ColorProcessor(ColorManager *config, const QString &input, const
       display_transform->setLooksOverrideEnabled(true);
     }
 
+    OCIO_SET_C_LOCALE_FOR_SCOPE;
     processor_ = config->GetConfig()->getProcessor(display_transform);
 
   } else {
 
+    OCIO_SET_C_LOCALE_FOR_SCOPE;
     processor_ = config->GetConfig()->getProcessor(input.toUtf8(),
                                                    output.toUtf8());
 

app/render/ocioconf/CMakeLists.txt

@@ -14,8 +14,16 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+file(GLOB_RECURSE OCIOCONF_RESOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.ocio *.spi3d *.spi1d)
+set(QRC_BODY "")
+foreach(OCIOCONF_FILE ${OCIOCONF_RESOURCES})
+  string(APPEND QRC_BODY "<file>${OCIOCONF_FILE}</file>\n")
+  configure_file(${OCIOCONF_FILE} ${OCIOCONF_FILE} COPYONLY)
+endforeach()
+configure_file(ocioconf.qrc.in ocioconf.qrc @ONLY)
+
 set(OLIVE_RESOURCES
   ${OLIVE_RESOURCES}
-  render/ocioconf/ocioconf.qrc
+  ${CMAKE_CURRENT_BINARY_DIR}/ocioconf.qrc
   PARENT_SCOPE
 )

app/render/ocioconf/gen-qrc.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-ourbasename=$(basename "$0")
-
-rm ocioconf.qrc
-echo "<RCC>" >> ocioconf.qrc
-echo "  <qresource prefix=\"/ocioconf\">" >> ocioconf.qrc
-
-for f in $(find * -type f)
-do
-    if [ "$f" != "CMakeLists.txt" ] && [ "$f" != "ocioconf.qrc" ] && [ "$f" != "$ourbasename" ]
-    then
-        echo "    <file>$f</file>" >> ocioconf.qrc
-    fi
-done
-
-echo "  </qresource>" >> ocioconf.qrc
-echo "</RCC>" >> ocioconf.qrc

app/render/ocioconf/ocioconf.qrc

@@ -1,19 +0,0 @@
-<RCC>
-  <qresource prefix="/ocioconf">
-    <file>config.ocio</file>
-    <file>looks/Filmic_False_Colour.spi3d</file>
-    <file>looks/Filmic_to_0-35_1-30.spi1d</file>
-    <file>looks/Filmic_to_0-48_1-09.spi1d</file>
-    <file>looks/Filmic_to_0-60_1-04.spi1d</file>
-    <file>looks/Filmic_to_0-70_1-03.spi1d</file>
-    <file>looks/Filmic_to_0-85_1-011.spi1d</file>
-    <file>looks/Filmic_to_0.99_1-0075.spi1d</file>
-    <file>looks/Filmic_to_1.20_1-00.spi1d</file>
-    <file>luts/F-Log_to_Linear.spi1d</file>
-    <file>luts/V-Log_to_linear.spi1d</file>
-    <file>luts/V3_LogC_400_to_linear.spi1d</file>
-    <file>luts/V3_LogC_800_to_linear.spi1d</file>
-    <file>luts/desat65cube.spi3d</file>
-    <file>luts/sRGB_OETF_to_Linear.spi1d</file>
-  </qresource>
-</RCC>

app/render/ocioconf/ocioconf.qrc.in

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="/ocioconf">
+    @QRC_BODY@
+  </qresource>
+</RCC>

app/shaders/CMakeLists.txt

@@ -14,8 +14,16 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+file(GLOB_RECURSE SHADER_RESOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.frag *.vert)
+set(QRC_BODY "")
+foreach(SHADER_FILE ${SHADER_RESOURCES})
+  string(APPEND QRC_BODY "<file>${SHADER_FILE}</file>\n")
+  configure_file(${SHADER_FILE} ${SHADER_FILE} COPYONLY)
+endforeach()
+configure_file(shaders.qrc.in shaders.qrc @ONLY)
+
 set(OLIVE_RESOURCES
   ${OLIVE_RESOURCES}
-  shaders/shaders.qrc
+  ${CMAKE_CURRENT_BINARY_DIR}/shaders.qrc
   PARENT_SCOPE
 )

app/shaders/alphaover.xml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.alphaoverblend">
-    <!-- Effect Name -->
-    <name lang="en_US">Alpha Over</name>
-    
-    <!-- Effect Category -->
-    <category>3</category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        A blending node that composites one texture over another using its alpha channel.
-    </description>
-
-    <!-- Blending Parameters -->
-    <param id="base_in" type="texture">
-        <name lang="en_US">Base</name>
-    </param>
-    <param id="blend_in" type="texture">
-        <name lang="en_US">Blend</name>
-    </param>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/alphaover.frag" />
-</effect>

app/shaders/blur.xml

@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.blur">
-    <!-- Effect Name -->
-    <name lang="en_US">Blur</name>
-
-    <!-- Effect Category -->
-    <category>4</category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        Blurs an image.
-    </description>
-
-    <!-- Parameter: Texture Input -->
-    <param id="tex_in" type="texture" iterative_input="1">
-        <name lang="en_US">Input</name>
-    </param>
-
-    <!-- Parameter: Method Input -->
-    <param id="method_in" type="combo">
-        <name lang="en_US">Method</name>
-        <option>
-            <name lang="en_US">Box</name>
-            <description lang="en_US">A fast blur calculated by averaging a square of pixels around each pixel. Fast, but can have a "striated" look to it.</description>
-        </option>
-        <option>
-            <name lang="en_US">Gaussian</name>
-            <description lang="en_US">A smooth blur using the gaussian function. Slower than box blur but much prettier.</description>
-        </option>
-    </param>
-
-    <!-- Parameter: Radius Input -->
-    <param id="radius_in" type="float">
-        <name lang="en_US">Radius</name>
-        <min>0</min>
-        <default>
-            <value>10</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Horizontal Enable -->
-    <param id="horiz_in" type="bool">
-        <name lang="en_US">Horizontal</name>
-        <default>
-            <value>1</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Vertical Enable -->
-    <param id="vert_in" type="bool">
-        <name lang="en_US">Vertical</name>
-        <default>
-            <value>1</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Repeat Edge Pixels -->
-    <param id="repeat_edge_pixels_in" type="bool">
-        <name lang="en_US">Repeat Edge Pixels</name>
-        <default>
-            <value>0</value>
-        </default>
-    </param>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/blur.frag"/>
-
-    <!-- Blur uses two iterations for horizontal and vertical since calculating 2*radius is faster than radius^2 -->
-    <iterations>2</iterations>
-</effect>

app/shaders/crossdissolve.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.crossdissolve">
-    <!-- Effect Name -->
-    <name lang="en_US">Cross Dissolve</name>
-
-    <!-- Effect Category -->
-    <category></category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        A smooth fade transition from one video clip to another.
-    </description>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/crossdissolve.frag"/>
-</effect>

app/shaders/diptoblack.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.diptoblack">
-    <!-- Effect Name -->
-    <name lang="en_US">Dip to Black</name>
-
-    <!-- Effect Category -->
-    <category></category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        A smooth dip to transparency and back into another clip.
-    </description>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/diptoblack.frag"/>
-</effect>

app/shaders/dropshadow.frag

@@ -1,62 +0,0 @@
-#version 150
-
-#define M_PI 3.1415926535897932384626433832795
-
-uniform sampler2D tex_in;
-uniform vec3 color_in;
-uniform float softness_in;
-uniform float opacity_in;
-uniform float distance_in;
-uniform float direction_in;
-
-uniform vec2 ove_resolution;
-
-in vec2 ove_texcoord;
-
-out vec4 fragColor;
-
-void main(void) {
-    // Use pythagoras with the distance (hypotenuse) to find the shadow offset
-    float direction_radians = direction_in * (M_PI / 180.0);
-
-    float opposite = sin(direction_radians) * distance_in;
-    float adjacent = cos(direction_radians) * distance_in;
-
-    vec2 angle = vec2(adjacent, opposite);
-
-    // Convert distance from pixels to 0.0 - 1.0 texture coordinates
-    angle /= ove_resolution;
-
-    float shadow_alpha;
-
-    // For a soft shadow, we use a box blur-like formula
-    if (softness_in > 0.0) {
-        float radius = ceil(softness_in);
-        float divider = 1.0 / pow(softness_in, 2.0);
-        shadow_alpha = 0.0;
-
-        for (float x = -radius + 0.5; x <= radius; x += 2.0) {
-            for (float y = -radius + 0.5; y <= radius; y += 2.0) {
-                vec2 pixel_coord = ove_texcoord - angle;
-                pixel_coord.x += x / ove_resolution.x;
-                pixel_coord.y += y / ove_resolution.y;
-                vec4 pixel_color = texture(tex_in, pixel_coord);
-
-                shadow_alpha += pixel_color.a * divider;
-            }
-        }
-    } else {
-        // Perfectly hard shadow
-        vec4 src_color = texture(tex_in, ove_texcoord - angle);
-        shadow_alpha = src_color.a;
-    }
-
-    vec4 shadow_px = vec4(color_in, shadow_alpha * opacity_in * 0.01);
-
-    // Get current pixel and perform an alpha over for it over the shadow we've made
-    vec4 dst_color = texture(tex_in, ove_texcoord);
-    shadow_px *= (1.0 - dst_color.a);
-    shadow_px += dst_color;
-
-    fragColor = shadow_px;
-}

app/shaders/dropshadow.xml

@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.dropshadow">
-    <!-- Effect Name -->
-    <name lang="en_US">Drop Shadow</name>
-
-    <!-- Effect Category -->
-    <category lang="en_US">Stylize</category>
-    <category lang="en_GB">Stylise</category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        Generate a drop shadow of a clip.
-    </description>
-
-    <!-- Parameter: Texture Input -->
-    <param id="tex_in" type="texture">
-        <name lang="en_US">Input</name>
-    </param>
-
-    <!-- Parameter: Color Input -->
-    <param id="color_in" type="color">
-        <name lang="en_US">Color</name>
-        <name lang="en_GB">Colour</name>
-    </param>
-
-    <!-- Parameter: Softness Input -->
-    <param id="softness_in" type="float">
-        <name lang="en_US">Softness</name>
-        <min>0</min>
-        <default>
-            <value>10</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Opacity Input -->
-    <param id="opacity_in" type="float">
-        <name lang="en_US">Opacity</name>
-        <min>0</min>
-        <default>
-            <value>80</value>
-        </default>
-        <max>100</max>
-    </param>
-
-    <!-- Parameter: Distance Input -->
-    <param id="distance_in" type="float">
-        <name lang="en_US">Distance</name>
-        <min>0</min>
-        <default>
-            <value>10</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Direction Input -->
-    <param id="direction_in" type="float">
-        <name lang="en_US">Direction</name>
-        <default>
-            <value>45</value>
-        </default>
-    </param>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/dropshadow.frag"/>
-</effect>

app/shaders/polygon.frag

@@ -0,0 +1,44 @@
+#version 150
+
+uniform vec2[256] points_in;
+uniform int points_in_count;
+uniform vec4 color_in;
+
+uniform vec2 ove_resolution;
+
+in vec2 ove_texcoord;
+
+out vec4 fragColor;
+
+/*
+int pnpoly(int npol, float *xp, float *yp, float x, float y) {
+  int i, j, c = 0;
+  for (i = 0, j = npol-1; i < npol; j = i++) {
+    if ((((yp[i] <= y) && (y < yp[j])) ||
+         ((yp[j] <= y) && (y < yp[i]))) &&
+        (x < (xp[j] - xp[i]) * (y - yp[i]) / (yp[j] - yp[i]) + xp[i]))
+      c = !c;
+  }
+  return c;
+}
+*/
+
+bool pnpoly(vec2 p) {
+  bool c = false;
+  int i, j;
+  for (i = 0, j = points_in_count-1; i < points_in_count; j = i++) {
+    if ((((points_in[i].y <= p.y) && (p.y < points_in[j].y)) ||
+         ((points_in[j].y <= p.y) && (p.y < points_in[i].y))) &&
+        (p.x < (points_in[j].x - points_in[i].x) * (p.y - points_in[i].y) / (points_in[j].y - points_in[i].y) + points_in[i].x))
+      c = !c;
+  }
+  return c;
+}
+
+void main(void) {
+    if (points_in_count > 0 && pnpoly(ove_texcoord * ove_resolution)) {
+        fragColor = color_in;
+    } else {
+        fragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    }
+}

app/shaders/rgbwaveform.frag

@@ -52,7 +52,7 @@ void main(void) {
         float waveform_x = (ove_texcoord.x - waveform_uv.x) / waveform_scale;
         float waveform_y = (ove_texcoord.y - waveform_uv.y) / waveform_scale;
         for (int i = 0; i < waveform_dims.y; i++) {
-            ratio = float(i) / float(waveform_dims.y);
+            ratio = float(i) / float(waveform_dims.y - 1);
             cur_col = texture(
                 ove_maintex,
                 vec2(waveform_x, ratio)

app/shaders/shaders.qrc

@@ -1,22 +0,0 @@
-<RCC>
-    <qresource prefix="/shaders">
-        <file>alphaover.frag</file>
-        <file>alphaover.xml</file>
-        <file>blur.frag</file>
-        <file>blur.xml</file>
-        <file>colorgradient.frag</file>
-        <file>colorwheel.frag</file>
-        <file>crossdissolve.frag</file>
-        <file>crossdissolve.xml</file>
-        <file>dropshadow.frag</file>
-        <file>dropshadow.xml</file>
-        <file>diptoblack.frag</file>
-        <file>diptoblack.xml</file>
-        <file>rgbwaveform.frag</file>
-        <file>solid.frag</file>
-        <file>solid.xml</file>
-        <file>stroke.frag</file>
-        <file>stroke.xml</file>
-        <file>matrix.vert</file>
-    </qresource>
-</RCC>

app/shaders/shaders.qrc.in

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="/shaders">
+    @QRC_BODY@
+  </qresource>
+</RCC>

app/shaders/solid.xml

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.solidgenerator">
-    <!-- Effect Name -->
-    <name lang="en_US">Solid</name>
-    
-    <!-- Effect Category -->
-    <category lang="en_US">Generator</category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        Generate a solid color.
-    </description>
-    <description lang="en_GB">
-        Generate a solid colour.
-    </description>
-
-    <!-- Parameter: Color Value -->
-    <param id="color_in" type="color">
-        <name lang="en_US">Color</name>
-        <name lang="en_GB">Colour</name>
-        <default>
-            <value>1.0</value>
-            <value>0.0</value>
-            <value>0.0</value>
-            <value>1.0</value>
-        </default>
-    </param>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/solid.frag" />
-</effect>

app/shaders/stroke.frag

@@ -2,7 +2,7 @@
 
 // Node parameter inputs
 uniform sampler2D tex_in;
-uniform vec3 color_in;
+uniform vec4 color_in;
 uniform float radius_in;
 uniform float opacity_in;
 uniform bool inner_in;
@@ -61,15 +61,14 @@ void main(void) {
         }
     }
 
-    stroke_weight *= opacity_in * 0.01;
+    stroke_weight *= opacity_in;
 
     if (inner_in) {
         stroke_weight *= pixel_here.a;
     }
 
     // Make RGBA color
-    vec4 stroke_col = vec4(vec3(1.0) * stroke_weight, stroke_weight);
-    //vec4 stroke_col = vec4(color_in * stroke_weight, stroke_weight);
+    vec4 stroke_col = color_in * stroke_weight;
 
     if (inner_in) {
         // Alpha over the stroke over the texture

app/shaders/stroke.xml

@@ -1,55 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<effect id="org.olivevideoeditor.Olive.stroke">
-    <!-- Effect Name -->
-    <name lang="en_US">Stroke</name>
-    
-    <!-- Effect Category -->
-    <category lang="en_US">Stylize</category>
-    <category lang="en_GB">Stylise</category>
-
-    <!-- Effect Description -->
-    <description lang="en_US">
-        Creates a stroke outline around an image.
-    </description>
-
-    <!-- Parameter: Texture Input -->
-    <param id="tex_in" type="texture">
-        <name lang="en_US">Input</name>
-    </param>
-
-    <!-- Parameter: Color Value -->
-    <param id="color_in" type="color">
-        <name lang="en_US">Color</name>
-        <name lang="en_GB">Colour</name>
-    </param>
-
-    <!-- Parameter: Radius Value -->
-    <param id="radius_in" type="float">
-        <name lang="en_US">Radius</name>
-        <min>0</min>
-        <default>
-            <value>10</value>
-        </default>
-    </param>
-
-    <!-- Parameter: Opacity Value -->
-    <param id="opacity_in" type="float">
-        <name lang="en_US">Opacity</name>
-        <min>0</min>
-        <default>
-            <value>100</value>
-        </default>
-        <max>100</max>
-    </param>
-
-    <!-- Parameter: Inner Value -->
-    <param id="inner_in" type="bool">
-        <name lang="en_US">Inner</name>
-        <default>
-            <value>false</value>
-        </default>
-    </param>
-
-    <!-- Qt Resource path to fragment shader -->
-    <fragment url=":/shaders/stroke.frag" />
-</effect>

app/widget/CMakeLists.txt

@@ -31,6 +31,7 @@ add_subdirectory(nodecopypaste)
 add_subdirectory(nodeview)
 add_subdirectory(nodeparamview)
 add_subdirectory(panel)
+add_subdirectory(pixelsampler)
 add_subdirectory(playbackcontrols)
 add_subdirectory(projectexplorer)
 add_subdirectory(projecttoolbar)
@@ -41,6 +42,7 @@ add_subdirectory(taskview)
 add_subdirectory(timebased)
 add_subdirectory(timelinewidget)
 add_subdirectory(timeruler)
+add_subdirectory(timetarget)
 add_subdirectory(toolbar)
 add_subdirectory(viewer)
 

app/widget/keyframeview/CMakeLists.txt

@@ -24,7 +24,5 @@ set(OLIVE_SOURCES
   widget/keyframeview/keyframeviewitem.cpp
   widget/keyframeview/keyframeviewundo.h
   widget/keyframeview/keyframeviewundo.cpp
-  widget/keyframeview/timetargetobject.h
-  widget/keyframeview/timetargetobject.cpp
   PARENT_SCOPE
 )

app/widget/keyframeview/keyframeviewbase.h

@@ -23,7 +23,7 @@
 
 #include "keyframeviewitem.h"
 #include "node/keyframe.h"
-#include "timetargetobject.h"
+#include "widget/timetarget/timetarget.h"
 #include "widget/curvewidget/beziercontrolpointitem.h"
 #include "widget/timelinewidget/view/timelineviewbase.h"
 

app/widget/keyframeview/keyframeviewitem.h

@@ -24,7 +24,7 @@
 #include <QGraphicsRectItem>
 
 #include "node/keyframe.h"
-#include "timetargetobject.h"
+#include "widget/timetarget/timetarget.h"
 
 OLIVE_NAMESPACE_ENTER
 

app/widget/nodeparamview/CMakeLists.txt

@@ -18,6 +18,8 @@ set(OLIVE_SOURCES
   ${OLIVE_SOURCES}
   widget/nodeparamview/nodeparamview.h
   widget/nodeparamview/nodeparamview.cpp
+  widget/nodeparamview/nodeparamviewarraywidget.h
+  widget/nodeparamview/nodeparamviewarraywidget.cpp
   widget/nodeparamview/nodeparamviewconnectedlabel.h
   widget/nodeparamview/nodeparamviewconnectedlabel.cpp
   widget/nodeparamview/nodeparamviewitem.h

app/widget/nodeparamview/nodeparamview.cpp

@@ -127,7 +127,7 @@ void NodeParamView::SetNodes(QList<Node *> nodes)
   // If we already have item widgets, delete them all now
   foreach (NodeParamViewItem* item, items_) {
     emit ClosedNode(item->GetNode());
-
+    emit FoundGizmos(nullptr);
     delete item;
   }
   items_.clear();
@@ -142,6 +142,8 @@ void NodeParamView::SetNodes(QList<Node *> nodes)
 
   if (!nodes_.isEmpty()) {
     // For each node, create a widget
+    bool found_gizmos = false;
+
     foreach (Node* node, nodes_) {
       NodeParamViewItem* item = new NodeParamViewItem(node);
 
@@ -161,6 +163,11 @@ void NodeParamView::SetNodes(QList<Node *> nodes)
                                 Qt::QueuedConnection);
 
       emit OpenedNode(node);
+
+      if (!found_gizmos && node->HasGizmos()) {
+        emit FoundGizmos(node);
+        found_gizmos = true;
+      }
     }
 
     ViewerOutput* viewer = nodes_.first()->FindOutputNode<ViewerOutput>();

app/widget/nodeparamview/nodeparamview.h

@@ -55,6 +55,8 @@ signals:
 
   void ClosedNode(Node* n);
 
+  void FoundGizmos(Node* n);
+
 protected:
   virtual void resizeEvent(QResizeEvent *event) override;
 

app/widget/nodeparamview/nodeparamviewarraywidget.cpp

@@ -0,0 +1,55 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "nodeparamviewarraywidget.h"
+
+#include <QHBoxLayout>
+
+OLIVE_NAMESPACE_ENTER
+
+NodeParamViewArrayWidget::NodeParamViewArrayWidget(NodeInputArray* array, QWidget* parent) :
+  QWidget(parent),
+  array_(array)
+{
+  QHBoxLayout* layout = new QHBoxLayout(this);
+
+  count_lbl_ = new QLabel();
+  layout->addWidget(count_lbl_, 1);
+
+  plus_btn_ = new QPushButton(tr("+"));
+  layout->addWidget(plus_btn_);
+
+  connect(plus_btn_, &QPushButton::clicked, this, &NodeParamViewArrayWidget::AddElement);
+  connect(array_, &NodeInputArray::SizeChanged, this, &NodeParamViewArrayWidget::UpdateCounter);
+
+  UpdateCounter();
+}
+
+void NodeParamViewArrayWidget::UpdateCounter()
+{
+  count_lbl_->setText(tr("%1 elements").arg(array_->GetSize()));
+}
+
+void NodeParamViewArrayWidget::AddElement()
+{
+  array_->Append();
+}
+
+OLIVE_NAMESPACE_EXIT

app/widget/nodeparamview/nodeparamviewarraywidget.h

@@ -0,0 +1,54 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2019 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef NODEPARAMVIEWARRAYWIDGET_H
+#define NODEPARAMVIEWARRAYWIDGET_H
+
+#include <QLabel>
+#include <QPushButton>
+#include <QWidget>
+
+#include "node/inputarray.h"
+
+OLIVE_NAMESPACE_ENTER
+
+class NodeParamViewArrayWidget : public QWidget
+{
+  Q_OBJECT
+public:
+  NodeParamViewArrayWidget(NodeInputArray* array, QWidget* parent = nullptr);
+
+private:
+  NodeInputArray* array_;
+
+  QLabel* count_lbl_;
+
+  QPushButton* plus_btn_;
+
+private slots:
+  void UpdateCounter();
+
+  void AddElement();
+
+};
+
+OLIVE_NAMESPACE_EXIT
+
+#endif // NODEPARAMVIEWARRAYWIDGET_H

app/widget/nodeparamview/nodeparamviewitem.cpp

@@ -167,6 +167,7 @@ NodeParamViewItemBody::NodeParamViewItemBody(const QVector<NodeInput *> &inputs,
       content_layout->addLayout(array_label_layout, row_count, 0);
 
       NodeParamViewItemBody* sub_body = new NodeParamViewItemBody(static_cast<NodeInputArray*>(input)->sub_params());
+      sub_bodies_.append(sub_body);
       sub_body->layout()->setMargin(0);
       content_layout->addWidget(sub_body, row_count + 1, 0, 1, max_col + 1);
 

app/widget/nodeparamview/nodeparamviewkeyframecontrol.h

@@ -25,7 +25,7 @@
 #include <QWidget>
 
 #include "node/input.h"
-#include "widget/keyframeview/timetargetobject.h"
+#include "widget/timetarget/timetarget.h"
 
 OLIVE_NAMESPACE_ENTER
 

app/widget/nodeparamview/nodeparamviewwidgetbridge.cpp

@@ -29,6 +29,7 @@
 
 #include "core.h"
 #include "node/node.h"
+#include "nodeparamviewarraywidget.h"
 #include "nodeparamviewundo.h"
 #include "project/item/sequence/sequence.h"
 #include "undo/undostack.h"
@@ -67,113 +68,122 @@ const QList<QWidget *> &NodeParamViewWidgetBridge::widgets() const
 
 void NodeParamViewWidgetBridge::CreateWidgets()
 {
-  // We assume the first data type is the "primary" type
-  switch (input_->data_type()) {
-  // None of these inputs have applicable UI widgets
-  case NodeParam::kNone:
-  case NodeParam::kAny:
-  case NodeParam::kTexture:
-  case NodeParam::kMatrix:
-  case NodeParam::kRational:
-  case NodeParam::kSamples:
-  case NodeParam::kDecimal:
-  case NodeParam::kNumber:
-  case NodeParam::kString:
-  case NodeParam::kBuffer:
-  case NodeParam::kVector:
-    break;
-  case NodeParam::kInt:
-  {
-    IntegerSlider* slider = new IntegerSlider();
-    widgets_.append(slider);
-    connect(slider, &IntegerSlider::ValueChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
-    break;
-  }
-  case NodeParam::kFloat:
-  {
-    CreateSliders(1);
-    break;
-  }
-  case NodeParam::kVec2:
-  {
-    CreateSliders(2);
-    break;
-  }
-  case NodeParam::kVec3:
-  {
-    CreateSliders(3);
-    break;
-  }
-  case NodeParam::kVec4:
-  {
-    CreateSliders(4);
-    break;
-  }
-  case NodeParam::kCombo:
-  {
-    QComboBox* combobox = new QComboBox();
+  if (input_->IsArray()) {
 
-    QStringList items = input_->get_combobox_strings();
-    foreach (const QString& s, items) {
-      combobox->addItem(s);
+    NodeParamViewArrayWidget* w = new NodeParamViewArrayWidget(static_cast<NodeInputArray*>(input_));
+    widgets_.append(w);
+
+  } else {
+
+    // We assume the first data type is the "primary" type
+    switch (input_->data_type()) {
+    // None of these inputs have applicable UI widgets
+    case NodeParam::kNone:
+    case NodeParam::kAny:
+    case NodeParam::kTexture:
+    case NodeParam::kMatrix:
+    case NodeParam::kRational:
+    case NodeParam::kSamples:
+    case NodeParam::kDecimal:
+    case NodeParam::kNumber:
+    case NodeParam::kString:
+    case NodeParam::kBuffer:
+    case NodeParam::kVector:
+      break;
+    case NodeParam::kInt:
+    {
+      IntegerSlider* slider = new IntegerSlider();
+      widgets_.append(slider);
+      connect(slider, &IntegerSlider::ValueChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
+      break;
+    }
+    case NodeParam::kFloat:
+    {
+      CreateSliders(1);
+      break;
+    }
+    case NodeParam::kVec2:
+    {
+      CreateSliders(2);
+      break;
+    }
+    case NodeParam::kVec3:
+    {
+      CreateSliders(3);
+      break;
+    }
+    case NodeParam::kVec4:
+    {
+      CreateSliders(4);
+      break;
+    }
+    case NodeParam::kCombo:
+    {
+      QComboBox* combobox = new QComboBox();
+
+      QStringList items = input_->get_combobox_strings();
+      foreach (const QString& s, items) {
+        combobox->addItem(s);
+      }
+
+      widgets_.append(combobox);
+      connect(combobox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &NodeParamViewWidgetBridge::WidgetCallback);
+      break;
+    }
+    case NodeParam::kFile:
+      // FIXME: File selector
+      break;
+    case NodeParam::kColor:
+    {
+      // NOTE: Very convoluted way to get back to the project's color manager
+      ColorButton* color_button = new ColorButton(static_cast<Sequence*>(input_->parentNode()->parent())->project()->color_manager());
+      widgets_.append(color_button);
+      connect(color_button, &ColorButton::ColorChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
+      break;
+    }
+    case NodeParam::kText:
+    {
+      QLineEdit* line_edit = new QLineEdit();
+      widgets_.append(line_edit);
+      connect(line_edit, &QLineEdit::textEdited, this, &NodeParamViewWidgetBridge::WidgetCallback);
+      break;
+    }
+    case NodeParam::kBoolean:
+    {
+      QCheckBox* check_box = new QCheckBox();
+      widgets_.append(check_box);
+      connect(check_box, &QCheckBox::clicked, this, &NodeParamViewWidgetBridge::WidgetCallback);
+      break;
+    }
+    case NodeParam::kFont:
+    {
+      QFontComboBox* font_combobox = new QFontComboBox();
+      widgets_.append(font_combobox);
+      break;
+    }
+    case NodeParam::kFootage:
+    {
+      FootageComboBox* footage_combobox = new FootageComboBox();
+      footage_combobox->SetRoot(static_cast<Sequence*>(input_->parentNode()->parent())->project()->root());
+
+      connect(footage_combobox, &FootageComboBox::FootageChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
+
+      widgets_.append(footage_combobox);
+
+      break;
+    }
     }
 
-    widgets_.append(combobox);
-    connect(combobox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &NodeParamViewWidgetBridge::WidgetCallback);
-    break;
-  }
-  case NodeParam::kFile:
-    // FIXME: File selector
-    break;
-  case NodeParam::kColor:
-  {
-    // NOTE: Very convoluted way to get back to the project's color manager
-    ColorButton* color_button = new ColorButton(static_cast<Sequence*>(input_->parentNode()->parent())->project()->color_manager());
-    widgets_.append(color_button);
-    connect(color_button, &ColorButton::ColorChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
-    break;
-  }
-  case NodeParam::kText:
-  {
-    QLineEdit* line_edit = new QLineEdit();
-    widgets_.append(line_edit);
-    connect(line_edit, &QLineEdit::textEdited, this, &NodeParamViewWidgetBridge::WidgetCallback);
-    break;
-  }
-  case NodeParam::kBoolean:
-  {
-    QCheckBox* check_box = new QCheckBox();
-    widgets_.append(check_box);
-    connect(check_box, &QCheckBox::clicked, this, &NodeParamViewWidgetBridge::WidgetCallback);
-    break;
-  }
-  case NodeParam::kFont:
-  {
-    QFontComboBox* font_combobox = new QFontComboBox();
-    widgets_.append(font_combobox);
-    break;
-  }
-  case NodeParam::kFootage:
-  {
-    FootageComboBox* footage_combobox = new FootageComboBox();
-    footage_combobox->SetRoot(static_cast<Sequence*>(input_->parentNode()->parent())->project()->root());
+    // Check all properties
+    QHash<QString, QVariant>::const_iterator iterator;
 
-    connect(footage_combobox, &FootageComboBox::FootageChanged, this, &NodeParamViewWidgetBridge::WidgetCallback);
+    for (iterator=input_->properties().begin();iterator!=input_->properties().end();iterator++) {
+      PropertyChanged(iterator.key(), iterator.value());
+    }
 
-    widgets_.append(footage_combobox);
+    UpdateWidgetValues();
 
-    break;
   }
-  }
-
-  // Check all properties
-  QHash<QString, QVariant>::const_iterator iterator;
-
-  for (iterator=input_->properties().begin();iterator!=input_->properties().end();iterator++) {
-    PropertyChanged(iterator.key(), iterator.value());
-  }
-
-  UpdateWidgetValues();
 }
 
 void NodeParamViewWidgetBridge::SetInputValue(const QVariant &value, int track)
@@ -413,6 +423,10 @@ void NodeParamViewWidgetBridge::CreateSliders(int count)
 
 void NodeParamViewWidgetBridge::UpdateWidgetValues()
 {
+  if (input_->IsArray()) {
+    return;
+  }
+
   rational node_time = GetCurrentTimeAsNodeTime();
 
   // We assume the first data type is the "primary" type

app/widget/nodeparamview/nodeparamviewwidgetbridge.h

@@ -24,8 +24,8 @@
 #include <QObject>
 
 #include "node/input.h"
-#include "widget/keyframeview/timetargetobject.h"
 #include "widget/slider/sliderbase.h"
+#include "widget/timetarget/timetarget.h"
 
 OLIVE_NAMESPACE_ENTER
 

app/widget/pixelsampler/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  widget/pixelsampler/pixelsampler.h
+  widget/pixelsampler/pixelsampler.cpp
+  PARENT_SCOPE
+)

app/widget/pixelsampler/pixelsampler.cpp

@@ -18,7 +18,7 @@
 
 ***/
 
-#include "pixelsamplerwidget.h"
+#include "pixelsampler.h"
 
 #include <QVBoxLayout>
 

app/widget/scope/CMakeLists.txt

@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 add_subdirectory(histogram)
+add_subdirectory(scopebase)
 add_subdirectory(waveform)
 
 set(OLIVE_SOURCES

app/widget/scope/histogram/histogram.cpp

@@ -29,189 +29,8 @@
 OLIVE_NAMESPACE_ENTER
 
 HistogramScope::HistogramScope(QWidget* parent) :
-  ManagedDisplayWidget(parent),
-  buffer_(nullptr)
+  ScopeBase(parent)
 {
-  EnableDefaultContextMenu();
-
-  connect(&worker_, &HistogramScopeWorker::Finished, this, &HistogramScope::FinishedProcessing, Qt::QueuedConnection);
-  worker_.start(QThread::IdlePriority);
-}
-
-HistogramScope::~HistogramScope()
-{
-  worker_.Cancel();
-  worker_.quit();
-  worker_.wait();
-}
-
-void HistogramScope::SetBuffer(Frame* frame)
-{
-  buffer_ = frame;
-
-  if (isVisible()) {
-    StartUpdate();
-  }
-}
-
-void HistogramScope::FinishedProcessing(QVector<double> red, QVector<double> green, QVector<double> blue)
-{
-  red_val_ = red;
-  green_val_ = green;
-  blue_val_ = blue;
-
-  update();
-}
-
-void HistogramScope::paintGL()
-{
-  QVector<QLine> red_lines(red_val_.size());
-  QVector<QLine> green_lines(green_val_.size());
-  QVector<QLine> blue_lines(blue_val_.size());
-
-  for (int i=0;i<red_lines.size();i++) {
-    red_lines.replace(i, QLine(i, height() * (1.0 - red_val_.at(i)), i, height()));
-    green_lines.replace(i, QLine(i, height() * (1.0 - green_val_.at(i)), i, height()));
-    blue_lines.replace(i, QLine(i, height() * (1.0 - blue_val_.at(i)), i, height()));
-  }
-
-  QPainter p(this);
-  p.setCompositionMode(QPainter::CompositionMode_Plus);
-
-  p.setPen(Qt::red);
-  p.drawLines(red_lines);
-
-  p.setPen(Qt::green);
-  p.drawLines(green_lines);
-
-  p.setPen(Qt::blue);
-  p.drawLines(blue_lines);
-}
-
-void HistogramScope::resizeEvent(QResizeEvent *e)
-{
-  QOpenGLWidget::resizeEvent(e);
-
-  StartUpdate();
-}
-
-void HistogramScope::ColorProcessorChangedEvent()
-{
-  StartUpdate();
-}
-
-void HistogramScope::StartUpdate()
-{
-  if (buffer_) {
-    worker_.QueueNext(*buffer_, color_service(), width());
-  } else {
-    // Update with nothing
-    red_val_.clear();
-    green_val_.clear();
-    blue_val_.clear();
-    update();
-  }
-}
-
-void HistogramScope::showEvent(QShowEvent* e)
-{
-  ManagedDisplayWidget::showEvent(e);
-
-  StartUpdate();
-}
-
-HistogramScopeWorker::HistogramScopeWorker() :
-  cancelled_(false)
-{
-}
-
-void HistogramScopeWorker::run()
-{
-  while (!cancelled_) {
-    next_lock_.lock();
-    while (!next_.is_allocated()) {
-      next_wait_.wait(&next_lock_);
-
-      if (cancelled_){
-        next_lock_.unlock();
-        return;
-      }
-    }
-
-    // Copy values
-    Frame f = next_;
-    int w = next_width_;
-    ColorProcessorPtr processor = next_processor_;
-    next_.destroy();
-
-    next_lock_.unlock();
-
-    // Color manage frame
-
-    QVector<int> data(w * kRGBChannels, 0);
-
-    int max_w = w-1;
-
-    for (int x=0;x<f.width();x++) {
-      for (int y=0;y<f.height();y++) {
-        Color c = f.get_pixel(x, y);
-
-        if (processor) {
-          c = processor->ConvertColor(c);
-        }
-
-        data[qFloor(clamp(c.red(), 0.0f, 1.0f) * max_w)]++;
-        data[qFloor(clamp(c.green(), 0.0f, 1.0f) * max_w) + w]++;
-        data[qFloor(clamp(c.blue(), 0.0f, 1.0f) * max_w) + w * 2]++;
-      }
-    }
-
-    int max_val = 0;
-
-    foreach (const int& i, data) {
-      if (i > max_val) {
-        max_val = i;
-      }
-    }
-
-    if (!max_val) {
-      // Prevent divide by zero
-      return;
-    }
-
-    QVector<double> red_lines(w);
-    QVector<double> green_lines(w);
-    QVector<double> blue_lines(w);
-
-    for (int i=0;i<w;i++) {
-      red_lines.replace(i, static_cast<double>(data.at(i)) / static_cast<double>(max_val));
-      green_lines.replace(i, static_cast<double>(data.at(i + w)) / static_cast<double>(max_val));
-      blue_lines.replace(i, static_cast<double>(data.at(i + w * 2)) / static_cast<double>(max_val));
-    }
-
-    emit Finished(red_lines, green_lines, blue_lines);
-  }
-}
-
-void HistogramScopeWorker::QueueNext(const Frame &f, ColorProcessorPtr processor, int width)
-{
-  next_lock_.lock();
-
-  next_ = f;
-  next_width_ = width;
-  next_processor_ = processor;
-
-  next_wait_.wakeOne();
-
-  next_lock_.unlock();
-}
-
-void HistogramScopeWorker::Cancel()
-{
-  cancelled_ = true;
-  next_lock_.lock();
-  next_wait_.wakeOne();
-  next_lock_.unlock();
 }
 
 OLIVE_NAMESPACE_EXIT