diff --git a/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp b/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
index ac51bd3c274fe12725fd2d53da454fd755921964..7e03bddb512e3ee7e28a36c82d4394b836a51d2b 100644
--- a/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
+++ b/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
@@ -20,11 +20,11 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
 
     auto controlPanel = new RendererPanel( renderer->getRendererName() );
 
-    auto nodeEditor     = new RenderGraphEditorView( nullptr );
+    auto nodeEditor = new RenderGraphEditorView( nullptr );
     nodeEditor->setGraph( renderer->getRenderGraph() );
 
-
-    // TODO: find a way to refresh the main window when a widget gets updated instead of relying on nodeHoverLeft event
+    // TODO: find a way to refresh the main window when a widget gets updated instead of relying on
+    // nodeHoverLeft event
 
     QObject::connect( nodeEditor, &RenderGraphEditorView::needUpdate, appUpdateCallback );
 
@@ -106,7 +106,8 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
         if ( !nodeEditor->isVisible() )
         {
             // Fill the flowscene in the editor with the current graph if any
-            // TODO change this detection method. Instead of the file name, set a flag on the graph that indicates it is available
+            // TODO change this detection method. Instead of the file name, set a flag on the graph
+            // that indicates it is available
             if ( renderer->getJsonFilePath() != "" )
             {
                 // Fill the editor with the current graph ...
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.cpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.cpp
index a4573019ed50a9ae68d14b814f7ff3ade0367128..67c01f023ee1c468cf34a00ba5df3c5f162aff77 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.cpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.cpp
@@ -50,7 +50,9 @@ void updateWidget( Node* node, QWidget* widget ) {
 }
 
 /** Convert from Qt::Json to nlohmann::json */
-void QJsonEntryToNlohmannEntry( const QString& key, const QJsonValue& value, nlohmann::json& data ) {
+void QJsonEntryToNlohmannEntry( const QString& key,
+                                const QJsonValue& value,
+                                nlohmann::json& data ) {
     switch ( value.type() )
     {
     case QJsonValue::Bool:
@@ -102,18 +104,18 @@ void NlohmannEntryToQJsonEntry( const nlohmann::json& data, QJsonValue& value )
     }
     break;
     case nlohmann::detail::value_t::number_float: {
-        auto v = double(data.get<float>());
-        value   = v;
+        auto v = double( data.get<float>() );
+        value  = v;
     }
     break;
-    case nlohmann::detail::value_t::number_integer:{
+    case nlohmann::detail::value_t::number_integer: {
         auto v = data.get<int>();
-        value   = v;
+        value  = v;
     }
     break;
     case nlohmann::detail::value_t::number_unsigned: {
         auto v = data.get<unsigned int>();
-        value  = int(v);
+        value  = int( v );
     }
     break;
     case nlohmann::detail::value_t::string: {
@@ -124,16 +126,17 @@ void NlohmannEntryToQJsonEntry( const nlohmann::json& data, QJsonValue& value )
     case nlohmann::detail::value_t::array: {
         QJsonArray a;
         QJsonValue v;
-        for( auto& x : data.items() ) {
+        for ( auto& x : data.items() )
+        {
             NlohmannEntryToQJsonEntry( x.value(), v );
             a.append( v );
         }
         value = a;
     }
     break;
-    default :
+    default:
         LOG( Ra::Core::Utils::logERROR ) << "nlohmann::json to QJson : nlohmann json type "
-                                         << int(data.type()) << " is not supported.";
+                                         << int( data.type() ) << " is not supported.";
     }
 }
 
@@ -152,17 +155,20 @@ void QJsonObjectToNlohmannObject( const QJsonObject& p, nlohmann::json& data ) {
     }
 }
 
-void NlohmannObjectToQJsonObject(const nlohmann::json& data, QJsonObject& p) {
-    for (const auto& [key, value] : data.items()) {
-        if ( value.is_object() ) {
+void NlohmannObjectToQJsonObject( const nlohmann::json& data, QJsonObject& p ) {
+    for ( const auto& [key, value] : data.items() )
+    {
+        if ( value.is_object() )
+        {
             QJsonObject o;
-            NlohmannObjectToQJsonObject( data[key], o);
-            p.insert(key.c_str(), o);
+            NlohmannObjectToQJsonObject( data[key], o );
+            p.insert( key.c_str(), o );
         }
-        else {
+        else
+        {
             QJsonValue v;
             NlohmannEntryToQJsonEntry( value, v );
-            p.insert(key.c_str(), v);
+            p.insert( key.c_str(), v );
         }
     }
 }
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp
index 8eb83f20a2c67dac72fb0847491f97c7d8dd6d62..6fba0ebeb2d7e67aec43246e292b72231595da2d 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp
@@ -13,7 +13,7 @@ namespace NodeDataModelTools {
 QWidget* getWidget( Node* node );
 void updateWidget( Node* node, QWidget* widget );
 void QJsonObjectToNlohmannObject( const QJsonObject& p, nlohmann::json& data );
-void NlohmannObjectToQJsonObject(const nlohmann::json& data, QJsonObject& p);
+void NlohmannObjectToQJsonObject( const nlohmann::json& data, QJsonObject& p );
 } // namespace NodeDataModelTools
 
 template <typename T>
@@ -36,7 +36,7 @@ class NodeAdapterModel : public QtNodes::NodeDataModel
         m_renderGraph->m_recompile = true;
     }
 
-    void adapt(T* n) {
+    void adapt( T* n ) {
         m_node = n;
         m_inputsConnected.resize( m_node->getInputs().size() );
         m_widget = NodeDataModelTools::getWidget( m_node );
@@ -46,7 +46,9 @@ class NodeAdapterModel : public QtNodes::NodeDataModel
 
   public:
     explicit NodeAdapterModel( RenderGraph* renderGraph ) : m_renderGraph( renderGraph ) { init(); }
-    explicit NodeAdapterModel( RenderGraph* renderGraph, T* n ) : m_renderGraph( renderGraph ) { adapt(n); }
+    explicit NodeAdapterModel( RenderGraph* renderGraph, T* n ) : m_renderGraph( renderGraph ) {
+        adapt( n );
+    }
     NodeAdapterModel()                          = delete;
     NodeAdapterModel( const NodeAdapterModel& ) = delete;
     NodeAdapterModel( NodeAdapterModel&& )      = default;
@@ -69,14 +71,13 @@ class NodeAdapterModel : public QtNodes::NodeDataModel
 
     void updateState() override {
         int i = 0;
-        for( const auto& in : m_node->getInputs() ) {
-            if( in->isLinked() ) {
-                m_inputsConnected[i] = true;
-            }
+        for ( const auto& in : m_node->getInputs() )
+        {
+            if ( in->isLinked() ) { m_inputsConnected[i] = true; }
             i++;
         }
         checkConnections();
-        }
+    }
 
   private:
     QtNodes::NodeDataType IOToDataType( size_t hashType, const std::string& ioName ) const {
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.inl b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.inl
index df82593803b426849ff7051fff49d17e2b0cc761..2d7e513a9721ee6a07de93c46f6eb907a65b48b2 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.inl
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.inl
@@ -1,16 +1,16 @@
 template <typename T>
 QJsonObject NodeAdapterModel<T>::save() const {
-    QJsonObject o;// = QtNodes::NodeDataModel::save();
+    QJsonObject o; // = QtNodes::NodeDataModel::save();
     nlohmann::json nodeData;
-    m_node->toJson(nodeData);
-    NodeDataModelTools::NlohmannObjectToQJsonObject(nodeData, o);
+    m_node->toJson( nodeData );
+    NodeDataModelTools::NlohmannObjectToQJsonObject( nodeData, o );
     return o;
 }
 
 template <typename T>
 void NodeAdapterModel<T>::restore( QJsonObject const& p ) {
-    //QtNodes::NodeDataModel::restore( p );
-    // 1 - convert the QJsonObject to nlohmann::json
+    // QtNodes::NodeDataModel::restore( p );
+    //  1 - convert the QJsonObject to nlohmann::json
     nlohmann::json nodeData;
     NodeDataModelTools::QJsonObjectToNlohmannObject( p, nodeData );
     // 2 - call fromjson on the node using this json object
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterTemplateInstanciations.hpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterTemplateInstanciations.hpp
index 745f17918dcc8eb348717424f7eb6761ae403781..cd0a6517fff7f61795fa9272861b2b5fcd468131 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterTemplateInstanciations.hpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/NodeAdapterTemplateInstanciations.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-
 #include <RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp>
 
 /** Node adapter specialized methods */
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
index 26b17a316a744e8078a8e60889229e3fbb8981d3..196cb4d4a2835a5341c62619c9f5401e3610e71a 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
@@ -89,11 +89,10 @@ void RenderGraphEditorView::connectAll() {
         connections.push_back(QObject::connect(scene, &QtNodes::FlowScene::connectionDeleted,
        this, &RenderGraphEditorView::needUpdate));
     */
-    connections.push_back(
-        QObject::connect( scene, &QtNodes::FlowScene::nodeHoverLeft, [this]() {
-            std::cout << "QtNodes::FlowScene::nodeHoverLeft\n";
-            emit needUpdate();
-        } ) );
+    connections.push_back( QObject::connect( scene, &QtNodes::FlowScene::nodeHoverLeft, [this]() {
+        std::cout << "QtNodes::FlowScene::nodeHoverLeft\n";
+        emit needUpdate();
+    } ) );
 
     connections.push_back( QObject::connect( scene, &QtNodes::FlowScene::nodeDeleted, [this]() {
         std::cout << "QtNodes::FlowScene::nodeDeleted\n";
@@ -111,53 +110,49 @@ void RenderGraphEditorView::connectAll() {
         } ) );
 }
 
-
-
-void RenderGraphEditorView::setGraph( RenderGraph* rg) {
+void RenderGraphEditorView::setGraph( RenderGraph* rg ) {
     currentGraph = rg;
-    // Replace this by a transformation of the currentGraph NodeSet (how to access ??) instead of a hard building of the registry
+    // Replace this by a transformation of the currentGraph NodeSet (how to access ??) instead of a
+    // hard building of the registry
     m_editorRegistry = NodeGraphQtEditor::initializeNodeRegistry( currentGraph );
     scene->setRegistry( m_editorRegistry );
-
-
 }
 
 void RenderGraphEditorView::editGraph() {
     // TODO, check if pointer are valid ? They have to ...
-    const auto& nodes = *(currentGraph->getNodes());
+    const auto& nodes = *( currentGraph->getNodes() );
     // inserting nodes
-    for(const auto& n : nodes) {
-        scene->importNode( NodeGraphQtEditor::getAdaptedNode( n.get() ) );
-
-    }
+    for ( const auto& n : nodes )
+    { scene->importNode( NodeGraphQtEditor::getAdaptedNode( n.get() ) ); }
     // inserting connections
-    for(const auto& n : nodes) {
-        int numPort=0;
-        for( const auto & input : n->getInputs() ) {
-            if( input->isLinked() ) {
-                auto portOut = input->getLink();
-                auto nodeOut = portOut->getNode();
+    for ( const auto& n : nodes )
+    {
+        int numPort = 0;
+        for ( const auto& input : n->getInputs() )
+        {
+            if ( input->isLinked() )
+            {
+                auto portOut     = input->getLink();
+                auto nodeOut     = portOut->getNode();
                 int outPortIndex = 0;
-                for( const auto& p : nodeOut->getOutputs() ) {
-                    if ( p.get() == portOut ) {
-                        break;
-                    }
+                for ( const auto& p : nodeOut->getOutputs() )
+                {
+                    if ( p.get() == portOut ) { break; }
                     outPortIndex++;
                 }
-                scene->importConnection( nodeOut->getUuid().c_str(), outPortIndex,
-                                         n->getUuid().c_str(), numPort);
+                scene->importConnection(
+                    nodeOut->getUuid().c_str(), outPortIndex, n->getUuid().c_str(), numPort );
             }
             numPort++;
         }
     }
 }
 
-
 namespace NodeGraphQtEditor {
 
 /** NodeDataModelBuilder to convert an existing graph to its editor representation */
 
-using DataModelAdapter = std::function<std::unique_ptr<QtNodes::NodeDataModel>(Node*)>;
+using DataModelAdapter = std::function<std::unique_ptr<QtNodes::NodeDataModel>( Node* )>;
 
 template <typename T>
 class NodeDataModelAdapter
@@ -165,8 +160,8 @@ class NodeDataModelAdapter
   public:
     explicit NodeDataModelAdapter( RenderGraph* renderGraph ) : m_renderGraph( renderGraph ) {}
 
-    std::unique_ptr<QtNodes::NodeDataModel> operator()(Node* n) {
-        return std::make_unique<NodeAdapterModel<T>>( m_renderGraph, static_cast<T*>(n) );
+    std::unique_ptr<QtNodes::NodeDataModel> operator()( Node* n ) {
+        return std::make_unique<NodeAdapterModel<T>>( m_renderGraph, static_cast<T*>( n ) );
     }
 
   private:
@@ -176,13 +171,13 @@ class NodeDataModelAdapter
 using DataModelAdapters = std::unordered_map<std::string, DataModelAdapter>;
 DataModelAdapters dataModelAdapters;
 
-void registerNodeModelAdapterInternal( std::string nodeType,
-                                       DataModelAdapter adapter) {
+void registerNodeModelAdapterInternal( std::string nodeType, DataModelAdapter adapter ) {
     if ( dataModelAdapters.find( nodeType ) == dataModelAdapters.end() )
     { dataModelAdapters[nodeType] = std::move( adapter ); }
     else
     {
-        std::cerr << "registerNodeModelCreatorInternal: trying to add an already existing node adapter for type "
+        std::cerr << "registerNodeModelCreatorInternal: trying to add an already existing node "
+                     "adapter for type "
                   << nodeType << "." << std::endl;
     }
 }
@@ -192,12 +187,9 @@ void registerNodeModelAdapter( DataModelAdapter nodeAdapter ) {
     registerNodeModelAdapterInternal( T::getTypename(), std::move( nodeAdapter ) );
 }
 
-
 std::unique_ptr<QtNodes::NodeDataModel> getAdaptedNode( Node* n ) {
     auto it = dataModelAdapters.find( n->getTypeName() );
-    if (  it != dataModelAdapters.end() ) {
-        return it->second(n);
-    }
+    if ( it != dataModelAdapters.end() ) { return it->second( n ); }
     return nullptr;
 }
 
@@ -208,9 +200,7 @@ class NodeCreator
   public:
     explicit NodeCreator( RenderGraph* renderGraph ) : m_renderGraph( renderGraph ) {}
 
-    std::unique_ptr<T> operator()() {
-        return std::make_unique<T>( m_renderGraph );
-    }
+    std::unique_ptr<T> operator()() { return std::make_unique<T>( m_renderGraph ); }
 
   private:
     RenderGraph* m_renderGraph;
@@ -218,61 +208,60 @@ class NodeCreator
 
 using namespace QtNodes;
 
-template<typename T>
+template <typename T>
 void addNodeTypeToEditor( RenderGraph* renderGraph,
                           std::shared_ptr<DataModelRegistry>& creators,
                           /*DataModelAdapters& adapters, */
                           std::string category ) {
 
-    creators->registerModel<NodeAdapterModel<T>>(
-        NodeCreator<NodeAdapterModel<T>>( renderGraph ), "Data" );
+    creators->registerModel<NodeAdapterModel<T>>( NodeCreator<NodeAdapterModel<T>>( renderGraph ),
+                                                  "Data" );
 
-    registerNodeModelAdapter<T>( NodeDataModelAdapter<T>(renderGraph) );
+    registerNodeModelAdapter<T>( NodeDataModelAdapter<T>( renderGraph ) );
 }
 
-
 std::shared_ptr<DataModelRegistry> initializeNodeRegistry( RenderGraph* renderGraph ) {
     auto ret = std::make_shared<DataModelRegistry>();
 #if 1
-    addNodeTypeToEditor<DataNode<NodeTypeRenderObject>>(renderGraph, ret, "Data");
-    addNodeTypeToEditor<DataNode<NodeTypeLight>>(renderGraph, ret, "Data");
-    addNodeTypeToEditor<DataNode<NodeTypeCamera>>(renderGraph, ret, "Data");
-
-    addNodeTypeToEditor<DisplaySinkNode>(renderGraph, ret, "Sinks");
-
-    addNodeTypeToEditor<FilterROByTypeNode>(renderGraph, ret, "Filters");
-    addNodeTypeToEditor<FilterROByNameNode>(renderGraph, ret, "Filters");
-
-    addNodeTypeToEditor<ClearColorNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<ZGeomPrepassNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<AccessibilityBufferNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<EnvLightNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<LocalLightNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<EmissivityNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<TransparencyNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<VolumeNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<VolumeVizualisationNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<UINode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<WireframeNode>(renderGraph, ret, "RenderPasses");
-    addNodeTypeToEditor<SimpleNode>(renderGraph, ret, "RenderPasses");
-
-    addNodeTypeToEditor<ColorSourceNode>(renderGraph, ret, "Sources");
-    addNodeTypeToEditor<BooleanValueSource>(renderGraph, ret, "Sources");
-    addNodeTypeToEditor<ScalarValueSource>(renderGraph, ret, "Sources");
-    addNodeTypeToEditor<EnvMapTextureSource>(renderGraph, ret, "Sources");
-    addNodeTypeToEditor<ColorTextureNode>(renderGraph, ret, "Sources");
-    addNodeTypeToEditor<DepthTextureNode>(renderGraph, ret, "Sources");
-
-    addNodeTypeToEditor<DifferenceNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<SumNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<MultiplyNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<OneMinusNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<MaxNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<MinNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<MoreThanThresholdNode>(renderGraph, ret, "Compositing");
-    addNodeTypeToEditor<LessThanThresholdNode>(renderGraph, ret, "Compositing");
-
-    addNodeTypeToEditor<FXAANode>(renderGraph, ret, "Anti Aliasing");
+    addNodeTypeToEditor<DataNode<NodeTypeRenderObject>>( renderGraph, ret, "Data" );
+    addNodeTypeToEditor<DataNode<NodeTypeLight>>( renderGraph, ret, "Data" );
+    addNodeTypeToEditor<DataNode<NodeTypeCamera>>( renderGraph, ret, "Data" );
+
+    addNodeTypeToEditor<DisplaySinkNode>( renderGraph, ret, "Sinks" );
+
+    addNodeTypeToEditor<FilterROByTypeNode>( renderGraph, ret, "Filters" );
+    addNodeTypeToEditor<FilterROByNameNode>( renderGraph, ret, "Filters" );
+
+    addNodeTypeToEditor<ClearColorNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<ZGeomPrepassNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<AccessibilityBufferNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<EnvLightNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<LocalLightNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<EmissivityNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<TransparencyNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<VolumeNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<VolumeVizualisationNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<UINode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<WireframeNode>( renderGraph, ret, "RenderPasses" );
+    addNodeTypeToEditor<SimpleNode>( renderGraph, ret, "RenderPasses" );
+
+    addNodeTypeToEditor<ColorSourceNode>( renderGraph, ret, "Sources" );
+    addNodeTypeToEditor<BooleanValueSource>( renderGraph, ret, "Sources" );
+    addNodeTypeToEditor<ScalarValueSource>( renderGraph, ret, "Sources" );
+    addNodeTypeToEditor<EnvMapTextureSource>( renderGraph, ret, "Sources" );
+    addNodeTypeToEditor<ColorTextureNode>( renderGraph, ret, "Sources" );
+    addNodeTypeToEditor<DepthTextureNode>( renderGraph, ret, "Sources" );
+
+    addNodeTypeToEditor<DifferenceNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<SumNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<MultiplyNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<OneMinusNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<MaxNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<MinNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<MoreThanThresholdNode>( renderGraph, ret, "Compositing" );
+    addNodeTypeToEditor<LessThanThresholdNode>( renderGraph, ret, "Compositing" );
+
+    addNodeTypeToEditor<FXAANode>( renderGraph, ret, "Anti Aliasing" );
 
 #else
     ret->registerModel<NodeAdapterModel<DataNode<NodeTypeRenderObject>>>(
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
index 7c4b28ee4edd9ca598ed099aa1ef5dbbe8914af3..66c1e51513bcf343b015da44063a1eec20f0ef15 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
@@ -19,7 +19,7 @@ class Node;
 namespace NodeGraphQtEditor {
 std::shared_ptr<QtNodes::DataModelRegistry> initializeNodeRegistry( RenderGraph* renderGraph );
 std::unique_ptr<QtNodes::NodeDataModel> getAdaptedNode( Node* n );
-}
+} // namespace NodeGraphQtEditor
 
 class NodeBasedRenderer_LIBRARY_API RenderGraphEditorView : public QWidget
 {
@@ -30,7 +30,7 @@ class NodeBasedRenderer_LIBRARY_API RenderGraphEditorView : public QWidget
     void disconnectAll();
     void connectAll();
 
-    void setGraph( RenderGraph* rg);
+    void setGraph( RenderGraph* rg );
 
     void editGraph();
 
@@ -45,14 +45,12 @@ class NodeBasedRenderer_LIBRARY_API RenderGraphEditorView : public QWidget
     void needUpdate();
 
   public:
-
     QMenuBar* menuBar{ nullptr };
     QAction* newAction{ nullptr };
     QAction* openAction{ nullptr };
     QAction* saveAction{ nullptr };
     QAction* saveAsAction{ nullptr };
 
-
     std::vector<QMetaObject::Connection> connections;
 
     // TODO, put all these as private data
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.cpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.cpp
index 773d9391c9d630602250bd4f02006ccf5ff28aed..c28560703ef4054f4e488286635fb59553f12417 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.cpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.cpp
@@ -1,14 +1,14 @@
 #if 0
-#include <QtCore/QObject>
-#include <QtWidgets/QCheckBox>
+#    include <QtCore/QObject>
+#    include <QtWidgets/QCheckBox>
 
-#include <RadiumNBR/Gui/PowerSlider.hpp>
-#include <RadiumNBR/Gui/RenderGraphEditor/ColorSlider.hpp>
-#include <RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp>
+#    include <RadiumNBR/Gui/PowerSlider.hpp>
+#    include <RadiumNBR/Gui/RenderGraphEditor/ColorSlider.hpp>
+#    include <RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp>
 
-#include <RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.hpp>
+#    include <RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.hpp>
 
-#include <iostream>
+#    include <iostream>
 
 // float
 template <>
@@ -38,7 +38,7 @@ NodeBasedRenderer_LIBRARY_API QJsonObject SourceNodeModel<float>::save() const {
 
 template <>
 NodeBasedRenderer_LIBRARY_API void SourceNodeModel<float>::restore( QJsonObject const& p ) {
-#if 0
+#    if 0
     auto powerSlider = dynamic_cast<PowerSlider*>( m_widget );
     QJsonValue n     = p["number"];
 
@@ -50,7 +50,7 @@ NodeBasedRenderer_LIBRARY_API void SourceNodeModel<float>::restore( QJsonObject
         float f = strNum.toFloat( &ok );
         if ( ok ) { powerSlider->setValue( f ); }
     }
-#endif
+#    endif
     nlohmann::json nodeData;
     NodeDataModelTools::QJsonObjectToNlohmannObject( p, nodeData );
     m_node->fromJson( nodeData );
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp
index f3258e9244b5999af46fb6ce327510d441016c31..a234a06f5cda8c45ba7a15cd0f64cc0e216dc5aa 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/SourceNodeModel.hpp
@@ -1,10 +1,10 @@
 #if 0
-#pragma once
-#include <RadiumNBR/Gui/RenderGraphEditor/ConnectionStatusData.hpp>
-#include <nodes/NodeDataModel>
+#    pragma once
+#    include <RadiumNBR/Gui/RenderGraphEditor/ConnectionStatusData.hpp>
+#    include <nodes/NodeDataModel>
 
-#include <RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp>
-#include <RadiumNBR/NodeGraph/RenderGraph.hpp>
+#    include <RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp>
+#    include <RadiumNBR/NodeGraph/RenderGraph.hpp>
 
 template <typename T>
 class SourceNodeModel : public QtNodes::NodeDataModel
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.cpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.cpp
index a87c3eb9c931b69805725cccf5f2036d5813eb46..241353a6a3d6002ba84bc6db63daeb4185e34faa 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.cpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/WidgetFactory.cpp
@@ -111,7 +111,7 @@ void initializeWidgetFactory() {
 
     WidgetFactory::registerWidget<Scalar>(
         []( EditableParameterBase* editableParameter ) {
-            auto editable = dynamic_cast<EditableParameter<Scalar>*>( editableParameter );
+            auto editable    = dynamic_cast<EditableParameter<Scalar>*>( editableParameter );
             auto powerSlider = new PowerSlider();
             powerSlider->setObjectName( editable->m_name.c_str() );
             powerSlider->setValue( editable->m_data );
@@ -126,7 +126,7 @@ void initializeWidgetFactory() {
         },
         []( QWidget* widget, EditableParameterBase* editableParameter ) -> bool {
             auto editable = dynamic_cast<EditableParameter<Scalar>*>( editableParameter );
-            auto slider = widget->findChild<PowerSlider*>( editableParameter->m_name.c_str() );
+            auto slider   = widget->findChild<PowerSlider*>( editableParameter->m_name.c_str() );
             if ( slider )
             {
                 slider->setValue( editable->m_data );
@@ -164,8 +164,8 @@ void initializeWidgetFactory() {
 
     WidgetFactory::registerWidget<NodeTypeColor>(
         []( EditableParameterBase* editableParameter ) {
-            auto editable = dynamic_cast<EditableParameter<NodeTypeColor>*>( editableParameter );
-            NodeTypeColor c = 255_ra * NodeTypeColor::linearRGBTosRGB( editable->m_data );
+            auto editable    = dynamic_cast<EditableParameter<NodeTypeColor>*>( editableParameter );
+            NodeTypeColor c  = 255_ra * NodeTypeColor::linearRGBTosRGB( editable->m_data );
             auto button      = new QPushButton( "Choose color" );
             auto colorDialog = new QColorDialog( QColor( c.x(), c.y(), c.z() ), button );
             colorDialog->setObjectName( editable->m_name.c_str() );
@@ -235,20 +235,21 @@ void initializeWidgetFactory() {
 
     WidgetFactory::registerWidget<Selector<std::string>>(
         []( EditableParameterBase* editableParameter ) {
-            auto editable = dynamic_cast<EditableParameter<Selector<std::string>>*>( editableParameter );
+            auto editable =
+                dynamic_cast<EditableParameter<Selector<std::string>>*>( editableParameter );
             auto selector = new QComboBox();
             selector->setObjectName( editable->m_name.c_str() );
-            for( const auto&e : editable->m_data ) {
-                selector->addItem( e.c_str() );
-            }
-            QComboBox::connect( selector, &QComboBox::currentTextChanged,
-                                [editable]( const QString& string ) {
-                editable->m_data.set( string.toStdString() );
-            } );
+            for ( const auto& e : editable->m_data )
+            { selector->addItem( e.c_str() ); }
+            QComboBox::connect(
+                selector, &QComboBox::currentTextChanged, [editable]( const QString& string ) {
+                    editable->m_data.set( string.toStdString() );
+                } );
             return selector;
         },
         []( QWidget* widget, EditableParameterBase* editableParameter ) -> bool {
-            auto editable = dynamic_cast<EditableParameter<Selector<std::string>>*>( editableParameter );
+            auto editable =
+                dynamic_cast<EditableParameter<Selector<std::string>>*>( editableParameter );
             auto comboBox = widget->findChild<QComboBox*>( editable->m_name.c_str() );
             if ( comboBox )
             {
@@ -262,17 +263,16 @@ void initializeWidgetFactory() {
     WidgetFactory::registerWidget<std::string>(
         []( EditableParameterBase* editableParameter ) {
             auto editable = dynamic_cast<EditableParameter<std::string>*>( editableParameter );
-            auto line = new QLineEdit();
+            auto line     = new QLineEdit();
             line->setObjectName( editable->m_name.c_str() );
-            QLineEdit::connect( line, &QLineEdit::textEdited,
-                                [editable]( const QString& string ) {
-                                    editable->m_data = string.toStdString() ;
-                                } );
+            QLineEdit::connect( line, &QLineEdit::textEdited, [editable]( const QString& string ) {
+                editable->m_data = string.toStdString();
+            } );
             return line;
         },
         []( QWidget* widget, EditableParameterBase* editableParameter ) -> bool {
             auto editable = dynamic_cast<EditableParameter<std::string>*>( editableParameter );
-            auto line  = widget->findChild<QLineEdit*>( editable->m_name.c_str() );
+            auto line     = widget->findChild<QLineEdit*>( editable->m_name.c_str() );
             if ( line )
             {
                 line->setText( editable->m_data.c_str() );
diff --git a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
index 27a1679c3c0ade2621b835632d18faf9e317e995..b7a2f841d52aca16e992514dac3875ac8265bab8 100644
--- a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
+++ b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
@@ -165,7 +165,7 @@ void NodeBasedRenderer::resizeInternal() {
     if ( m_postprocessFbo->checkStatus() != GL_FRAMEBUFFER_COMPLETE )
     {
         LOG( Ra::Core::Utils::logERROR ) << "FBO Error (NodeBasedRenderer::m_postprocessFbo) : "
-                        << m_postprocessFbo->checkStatus();
+                                         << m_postprocessFbo->checkStatus();
     }
 #endif
     // finished with fbo, unbind to bind default
@@ -281,16 +281,18 @@ void NodeBasedRenderer::uiInternal( const ViewingParameters& renderData ) {
 }
 
 void NodeBasedRenderer::postProcessInternal( const ViewingParameters& /* renderData */ ) {
-    if (true/*m_colorTexture*/) {
+    if ( true /*m_colorTexture*/ )
+    {
         m_postprocessFbo->bind();
 
-        //GL_ASSERT( glDrawBuffers( 1, buffers ) );
-        GL_ASSERT( glDrawBuffer(GL_COLOR_ATTACHMENT0) );
+        // GL_ASSERT( glDrawBuffers( 1, buffers ) );
+        GL_ASSERT( glDrawBuffer( GL_COLOR_ATTACHMENT0 ) );
         GL_ASSERT( glDisable( GL_DEPTH_TEST ) );
         GL_ASSERT( glDepthMask( GL_FALSE ) );
 
-        auto shader = m_postProcessEnabled ? m_shaderProgramManager->getShaderProgram( "Hdr2Ldr" )
-                                           : m_shaderProgramManager->getShaderProgram( "DrawScreen" );
+        auto shader = m_postProcessEnabled
+                          ? m_shaderProgramManager->getShaderProgram( "Hdr2Ldr" )
+                          : m_shaderProgramManager->getShaderProgram( "DrawScreen" );
         shader->bind();
         shader->setUniform( "screenTexture", m_colorTexture, 0 );
         m_quadMesh->render( shader );
@@ -370,7 +372,8 @@ void NodeBasedRenderer::observeDisplaySink( const std::vector<NodeTypeTexture*>&
 #ifdef GRAPH_CALL_TRACE
             std::cout << t->getName() << std::endl;
 #endif
-            if (t) {
+            if ( t )
+            {
                 if ( !colorTextureSet )
                 {
                     m_colorTexture  = t;
diff --git a/src/libRender/RadiumNBR/NodeGraph/Node.cpp b/src/libRender/RadiumNBR/NodeGraph/Node.cpp
index 780853fb2d82ca7817f872d839a4cf6ac72a5158..b1385d0655a72a155eab0e476b126986b5f4abf4 100644
--- a/src/libRender/RadiumNBR/NodeGraph/Node.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/Node.cpp
@@ -3,40 +3,41 @@
 #include <Core/Utils/Log.hpp>
 using namespace Ra::Core::Utils;
 
-bool Node::s_uuidGeneratorInitialized {false};
-uuids::uuid_random_generator* Node::s_uidGenerator{nullptr};
+bool Node::s_uuidGeneratorInitialized{ false };
+uuids::uuid_random_generator* Node::s_uidGenerator{ nullptr };
 
 void Node::createUuidGenerator() {
     std::random_device rd;
-    auto seed_data = std::array<int, std::mt19937::state_size> {};
-    std::generate(std::begin(seed_data), std::end(seed_data), std::ref(rd));
-    std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
-    auto generator = new std::mt19937(seq);
-    s_uidGenerator = new uuids::uuid_random_generator(*generator);
+    auto seed_data = std::array<int, std::mt19937::state_size>{};
+    std::generate( std::begin( seed_data ), std::end( seed_data ), std::ref( rd ) );
+    std::seed_seq seq( std::begin( seed_data ), std::end( seed_data ) );
+    auto generator             = new std::mt19937( seq );
+    s_uidGenerator             = new uuids::uuid_random_generator( *generator );
     s_uuidGeneratorInitialized = true;
 }
 
 /// Generates the uuid of the node
 void Node::generateUuid() {
-    if (!s_uuidGeneratorInitialized) {
-        createUuidGenerator();
-    }
-    m_uuid = (*s_uidGenerator)();
+    if ( !s_uuidGeneratorInitialized ) { createUuidGenerator(); }
+    m_uuid = ( *s_uidGenerator )();
 }
 /// Gets the UUID of the node as a string
 std::string Node::getUuid() const {
-    if ( m_uuid.is_nil() ) {
+    if ( m_uuid.is_nil() )
+    {
         // generates the uuid (need to remove const attribute) ...
-        const_cast<Node*>(this)->generateUuid();
+        const_cast<Node*>( this )->generateUuid();
     }
-    std::string struuid = "{" + uuids::to_string(m_uuid) + "}";
+    std::string struuid = "{" + uuids::to_string( m_uuid ) + "}";
     return struuid;
 }
 
-bool Node::setUuid(const std::string& uid) {
-    if ( m_uuid.is_nil() ) {
-        auto id = uuids::uuid::from_string(uid);
-        if ( id ) {
+bool Node::setUuid( const std::string& uid ) {
+    if ( m_uuid.is_nil() )
+    {
+        auto id = uuids::uuid::from_string( uid );
+        if ( id )
+        {
             m_uuid = id.value();
             return true;
         }
@@ -56,8 +57,8 @@ void Node::fromJson( const nlohmann::json& data ) {
 #endif
 
     // get the common content of the Node from the json data
-    std::string struuid = data["id"];
-    m_uuid                   = uuids::uuid::from_string(struuid).value();
+    std::string struuid      = data["id"];
+    m_uuid                   = uuids::uuid::from_string( struuid ).value();
     std::string readTypeName = data["model"]["name"];
     if ( readTypeName != m_typeName )
     {
@@ -79,8 +80,8 @@ void Node::fromJson( const nlohmann::json& data ) {
 
 void Node::toJson( nlohmann::json& data ) const {
     // write the common content of the Node to the json data
-    std::string struuid = "{" + uuids::to_string(m_uuid) + "}";
-    data["id"] = struuid;
+    std::string struuid = "{" + uuids::to_string( m_uuid ) + "}";
+    data["id"]          = struuid;
 
     nlohmann::json model;
     model["instance"] = m_instanceName;
@@ -95,9 +96,9 @@ void Node::toJson( nlohmann::json& data ) const {
     {
         if ( key != "id" && key != "model" ) { data.emplace( key, value ); }
     }
-/*
-    std::cout << "Node::toJson -- generated json is : \n";
-    for ( auto& [key, value] : data.items() )
-    { std::cout << "\t" << key << " : " << value << "\n"; }
-    */
+    /*
+        std::cout << "Node::toJson -- generated json is : \n";
+        for ( auto& [key, value] : data.items() )
+        { std::cout << "\t" << key << " : " << value << "\n"; }
+        */
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/Node.hpp b/src/libRender/RadiumNBR/NodeGraph/Node.hpp
index 4cd36160d53005381bc2f25709f6f27e54d6f51e..ef2718e73d4660111847c6c1d154d771ab5b9e31 100644
--- a/src/libRender/RadiumNBR/NodeGraph/Node.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/Node.hpp
@@ -120,11 +120,12 @@ class NodeBasedRenderer_LIBRARY_API Node
 
     /// Sets the UUID of the node from a valid string string
     /// @return true if the uuid is set, false if the node already have a valid uid
-    bool setUuid(const std::string& uid);
+    bool setUuid( const std::string& uid );
 
     /// return the deletable status of the node
-    /// Default is true. If a node must not be deleted (e.g. RenderObjectSource Node in the rendergraph), override this method.
-    bool isDeletable() { return m_isDeletable;}
+    /// Default is true. If a node must not be deleted (e.g. RenderObjectSource Node in the
+    /// rendergraph), override this method.
+    bool isDeletable() { return m_isDeletable; }
     // Set the deletable status of the node
     void setDeletableStatus( bool deletable = true ) { m_isDeletable = deletable; }
 
@@ -163,14 +164,17 @@ class NodeBasedRenderer_LIBRARY_API Node
 
     /// internal json representation of the Node.
     /// Must be implemented by inheriting classes.
-    /// Be careful with template specialization and function member overriding when implementing this method.
+    /// Be careful with template specialization and function member overriding when implementing
+    /// this method.
     virtual void fromJsonInternal( const nlohmann::json& data ) {
-        std::cout << "virtual void fromJsonInternal : MUST NOT BE CALLED on a " << typeid(*this).name() << "\n";
-    }//= 0;
+        std::cout << "virtual void fromJsonInternal : MUST NOT BE CALLED on a "
+                  << typeid( *this ).name() << "\n";
+    } //= 0;
 
     /// internal json representation of the Node.
     /// Must be implemented by inheriting classes.
-    /// Be careful with template specialization and function member overriding when implementing this method.
+    /// Be careful with template specialization and function member overriding when implementing
+    /// this method.
     virtual void toJsonInternal( nlohmann::json& data ) const {} //= 0;
 
     /// Adds an in port to the node.
@@ -215,10 +219,10 @@ class NodeBasedRenderer_LIBRARY_API Node
 
     /// The uuid of the node (TODO, use https://github.com/mariusbancila/stduuid instead of a
     /// string)
-    //std::string m_uuid;
+    // std::string m_uuid;
     uuids::uuid m_uuid;
     /// The deletable status of the node
-    bool m_isDeletable {true};
+    bool m_isDeletable{ true };
     /// The type name of the node
     std::string m_typeName;
     /// The instance name of the node
@@ -245,7 +249,5 @@ class NodeBasedRenderer_LIBRARY_API Node
     static void createUuidGenerator();
 
   public:
-    static const std::string getTypename() {
-        return "Node";
-    }
+    static const std::string getTypename() { return "Node"; }
 };
diff --git a/src/libRender/RadiumNBR/NodeGraph/NodeFactory.cpp b/src/libRender/RadiumNBR/NodeGraph/NodeFactory.cpp
index 5b0bf41da3fd51634e83d2681d07bfccdde0155b..4d989ac6cf83a4f9fb8860dc67d5f3932399cdcc 100644
--- a/src/libRender/RadiumNBR/NodeGraph/NodeFactory.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/NodeFactory.cpp
@@ -57,7 +57,8 @@ void initializeNodeFactory() {
         } );
 
         NodeFactory::registerNode<ColorSourceNode>( []( const nlohmann::json& data ) {
-            auto node = new ColorSourceNode( "Color_" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node =
+                new ColorSourceNode( "Color_" + std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -70,36 +71,36 @@ void initializeNodeFactory() {
         } );
 
         NodeFactory::registerNode<ColorTextureNode>( []( const nlohmann::json& data ) {
-            auto node =
-                new ColorTextureNode( "colorTexture_" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new ColorTextureNode( "colorTexture_" +
+                                              std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<DepthTextureNode>( []( const nlohmann::json& data ) {
-            auto node =
-                new DepthTextureNode( "depthTexture_" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new DepthTextureNode( "depthTexture_" +
+                                              std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<FilterROByTypeNode>( []( const nlohmann::json& data ) {
-            auto node      = new FilterROByTypeNode(
-                "filterROByType" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new FilterROByTypeNode( "filterROByType" +
+                                                std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<FilterROByNameNode>( []( const nlohmann::json& data ) {
-            auto node      = new FilterROByNameNode(
-                "filterROByName" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new FilterROByNameNode( "filterROByName" +
+                                                std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<AccessibilityBufferNode>( []( const nlohmann::json& data ) {
-            auto node = new AccessibilityBufferNode(
-                "accessibilityBufferPass" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new AccessibilityBufferNode( "accessibilityBufferPass" +
+                                                     std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -120,7 +121,7 @@ void initializeNodeFactory() {
 
         NodeFactory::registerNode<EnvLightNode>( []( const nlohmann::json& data ) {
             auto node = new EnvLightNode( "environmentLightPass" +
-                                                      std::to_string( NodeFactory::newNodeId() ) );
+                                          std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -141,21 +142,20 @@ void initializeNodeFactory() {
 
         NodeFactory::registerNode<TransparencyNode>( []( const nlohmann::json& data ) {
             auto node = new TransparencyNode( "transparencyPass" +
-                                                      std::to_string( NodeFactory::newNodeId() ) );
+                                              std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<VolumeNode>( []( const nlohmann::json& data ) {
-            auto node =
-                new VolumeNode( "volumePass" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new VolumeNode( "volumePass" + std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<VolumeVizualisationNode>( []( const nlohmann::json& data ) {
-            auto node = new VolumeVizualisationNode(
-                "volumeVizualisationPass" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new VolumeVizualisationNode( "volumeVizualisationPass" +
+                                                     std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -174,8 +174,7 @@ void initializeNodeFactory() {
         } );
 
         NodeFactory::registerNode<SimpleNode>( []( const nlohmann::json& data ) {
-            auto node =
-                new SimpleNode( "SimpleNode" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new SimpleNode( "SimpleNode" + std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -194,8 +193,7 @@ void initializeNodeFactory() {
         } );
 
         NodeFactory::registerNode<MultiplyNode>( []( const nlohmann::json& data ) {
-            auto node =
-                new MultiplyNode( "multiply" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new MultiplyNode( "multiply" + std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
@@ -220,15 +218,15 @@ void initializeNodeFactory() {
         } );
 
         NodeFactory::registerNode<MoreThanThresholdNode>( []( const nlohmann::json& data ) {
-            auto node = new MoreThanThresholdNode(
-                "more than threshold" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new MoreThanThresholdNode( "more than threshold" +
+                                                   std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
 
         NodeFactory::registerNode<LessThanThresholdNode>( []( const nlohmann::json& data ) {
-            auto node = new LessThanThresholdNode(
-                "less than threshold" + std::to_string( NodeFactory::newNodeId() ) );
+            auto node = new LessThanThresholdNode( "less than threshold" +
+                                                   std::to_string( NodeFactory::newNodeId() ) );
             node->fromJson( data );
             return node;
         } );
diff --git a/src/libRender/RadiumNBR/NodeGraph/NodeFactory.hpp b/src/libRender/RadiumNBR/NodeGraph/NodeFactory.hpp
index 14be5f39eba88608f18463437e1aad82874b9534..a0d0edafbff312f39c5058163e4de7428454f2b1 100644
--- a/src/libRender/RadiumNBR/NodeGraph/NodeFactory.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/NodeFactory.hpp
@@ -13,7 +13,7 @@ NodeBasedRenderer_LIBRARY_API Node* createNode( std::string& nodeType, const nlo
 
 NodeBasedRenderer_LIBRARY_API void
 registerNodeInternal( std::string nodeType,
-                      std::function<Node*( const nlohmann::json& data )> nodeCreator);
+                      std::function<Node*( const nlohmann::json& data )> nodeCreator );
 
 template <typename T>
 void registerNode( std::function<Node*( const nlohmann::json& data )> nodeCreator ) {
diff --git a/src/libRender/RadiumNBR/NodeGraph/Port.hpp b/src/libRender/RadiumNBR/NodeGraph/Port.hpp
index c1ce9b652c12da7006083d33dacfc971496856d6..23f93b2517fecb7958aceb53abb3bfdd14e07920 100644
--- a/src/libRender/RadiumNBR/NodeGraph/Port.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/Port.hpp
@@ -92,7 +92,8 @@ class PortOut : public PortBase
  * @tparam T
  */
 template <typename T>
-class PortIn : public PortBase, public Ra::Core::Utils::Observable<const std::string&, const PortIn<T>&, bool>
+class PortIn : public PortBase,
+               public Ra::Core::Utils::Observable<const std::string&, const PortIn<T>&, bool>
 {
   private:
     /// A pointer to the out port this port is connected to.
@@ -124,7 +125,7 @@ class PortIn : public PortBase, public Ra::Core::Utils::Observable<const std::st
             m_from     = dynamic_cast<PortOut<T>*>( other );
             m_isLinked = true;
             // notify after connect
-            this->notify(getName(), *this, true);
+            this->notify( getName(), *this, true );
         }
         return m_isLinked;
     }
@@ -134,7 +135,7 @@ class PortIn : public PortBase, public Ra::Core::Utils::Observable<const std::st
         if ( m_isLinked )
         {
             // notify before disconnect
-            this->notify(getName(), *this, false);
+            this->notify( getName(), *this, false );
             m_from     = nullptr;
             m_isLinked = false;
             return true;
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/LessThanThresholdNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/LessThanThresholdNode.cpp
index c6ae062f54794c8de6e25f701c11ce0e7d4d3f42..58d59e13db1bbe8d0f23049d7fdd0daccb4c58b9 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/LessThanThresholdNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/LessThanThresholdNode.cpp
@@ -112,12 +112,10 @@ void LessThanThresholdNode::buildRenderTechnique(
     const Ra::Engine::Rendering::RenderObject* ro,
     Ra::Engine::Rendering::RenderTechnique& rt ) const {}
 
-void LessThanThresholdNode::toJsonInternal( nlohmann::json& data ) const  {
+void LessThanThresholdNode::toJsonInternal( nlohmann::json& data ) const {
     data["threshold"] = m_editableThreshold;
 }
 
 void LessThanThresholdNode::fromJsonInternal( const nlohmann::json& data ) {
-    if (data.contains("threshold")) {
-        m_editableThreshold = data["threshold"];
-    }
+    if ( data.contains( "threshold" ) ) { m_editableThreshold = data["threshold"]; }
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/MoreThanThresholdNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/MoreThanThresholdNode.cpp
index f607e5afa948952561989f34c5ba1d37a14bbb6e..8661b8ac1bcc8626a14a43b1fa70530f9ea75745 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/MoreThanThresholdNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Compositing/MoreThanThresholdNode.cpp
@@ -112,12 +112,10 @@ void MoreThanThresholdNode::buildRenderTechnique(
     const Ra::Engine::Rendering::RenderObject* ro,
     Ra::Engine::Rendering::RenderTechnique& rt ) const {}
 
-void MoreThanThresholdNode::toJsonInternal( nlohmann::json& data ) const  {
+void MoreThanThresholdNode::toJsonInternal( nlohmann::json& data ) const {
     data["threshold"] = m_editableThreshold;
 }
 
 void MoreThanThresholdNode::fromJsonInternal( const nlohmann::json& data ) {
-    if (data.contains("threshold")) {
-        m_editableThreshold = data["threshold"];
-    }
+    if ( data.contains( "threshold" ) ) { m_editableThreshold = data["threshold"]; }
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterNode.hpp
index fdd1fccf211f3eeb62490829b81633dd8f1565df..d5896f339b24d65fdbf04742cc97f285f2de748a 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterNode.hpp
@@ -23,7 +23,7 @@ class FilterNode : public Node
     }
 
     void execute() override {
-        auto input            = dynamic_cast<PortIn<std::vector<T>>*>( m_inputs[0].get() );
+        auto input = dynamic_cast<PortIn<std::vector<T>>*>( m_inputs[0].get() );
         if ( input->isLinked() )
         {
             std::vector<T>& inData = input->getData();
@@ -74,41 +74,40 @@ class FilterNode : public Node
     std::vector<T> m_elements;
 };
 
-#include <vector>
 #include <initializer_list>
+#include <vector>
 template <typename T>
-class Selector {
+class Selector
+{
     std::vector<T> m_values;
-    size_t m_currentIndex{0};
+    size_t m_currentIndex{ 0 };
     T* m_currentValue;
+
   public:
-    explicit Selector(std::initializer_list<T> values) : m_values{values}, m_currentValue { m_values.data() } {}
+    explicit Selector( std::initializer_list<T> values ) :
+        m_values{ values }, m_currentValue{ m_values.data() } {}
     const T& get() const { return *m_currentValue; }
     size_t size() const { return m_values.size(); }
-    bool set(size_t p) {
-        if (p < m_values.size()) {
-            m_currentValue = m_values.data()+p;
+    bool set( size_t p ) {
+        if ( p < m_values.size() )
+        {
+            m_currentValue = m_values.data() + p;
             m_currentIndex = p;
             return true;
-        } else { return false; }
+        }
+        else
+        { return false; }
     }
-    bool set(const T& v) {
+    bool set( const T& v ) {
         size_t p = 0;
-        for(const auto& e : m_values) {
-            if ( e == v ) {
-                return set(p);
-            }
+        for ( const auto& e : m_values )
+        {
+            if ( e == v ) { return set( p ); }
             p++;
         }
         return false;
     }
-    typename std::vector<T>::const_iterator begin() const {
-        return m_values.cbegin();
-    }
-    typename std::vector<T>::const_iterator end() const {
-        return m_values.cend();
-    }
-    const T& operator[](size_t p) const {
-        return m_values.at( p );
-    }
+    typename std::vector<T>::const_iterator begin() const { return m_values.cbegin(); }
+    typename std::vector<T>::const_iterator end() const { return m_values.cend(); }
+    const T& operator[]( size_t p ) const { return m_values.at( p ); }
 };
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByNameNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByNameNode.hpp
index 4471b9ab4823363e1cbbe9c378463fa394f8a139..7f70623d7f3134f20e1f24c4acb050ce3ed0a218 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByNameNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByNameNode.hpp
@@ -27,12 +27,11 @@ class FilterROByNameNode : public FilterNode<NodeTypeRenderObject>
 
   protected:
     void toJsonInternal( nlohmann::json& data ) const override {
-        if ( !m_filteredName.empty() ) {
-            data["filteredName"] = m_filteredName;
-        }
+        if ( !m_filteredName.empty() ) { data["filteredName"] = m_filteredName; }
     }
     void fromJsonInternal( const nlohmann::json& data ) override {
-        if ( data.contains( "filteredName" ) ) { m_filteredName = data["filteredName"].get<std::string>(); }
+        if ( data.contains( "filteredName" ) )
+        { m_filteredName = data["filteredName"].get<std::string>(); }
         else
         { m_filteredName = ""; }
     }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByTypeNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByTypeNode.hpp
index 32ecf59eda9a014005b64b2472cd6d568b33aa04..a669ab0ccfc62e5defc011c2b6bc972b1f1bef20 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByTypeNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Filters/FilterROByTypeNode.hpp
@@ -26,22 +26,23 @@ class FilterROByTypeNode : public FilterNode<NodeTypeRenderObject>
         addEditableParameter( new EditableParameter( "Selected type", m_selector ) );
     }
 
-    void setTypeToFilter( const std::string& newTypeToFilter ) { m_selector.set( newTypeToFilter ); }
+    void setTypeToFilter( const std::string& newTypeToFilter ) {
+        m_selector.set( newTypeToFilter );
+    }
 
     static const std::string getTypename() { return "Filter RenderObjects By Type"; }
 
   protected:
     void toJsonInternal( nlohmann::json& data ) const override {
-        if ( m_selector.get() != "Opaque" ) {
-            data["filteredType"] = m_selector.get();
-        }
+        if ( m_selector.get() != "Opaque" ) { data["filteredType"] = m_selector.get(); }
     }
     void fromJsonInternal( const nlohmann::json& data ) override {
-        if ( data.contains( "filteredType" ) ) { setTypeToFilter( data["filteredType"].get<std::string>() ); }
+        if ( data.contains( "filteredType" ) )
+        { setTypeToFilter( data["filteredType"].get<std::string>() ); }
         else
-        { m_selector.set(0); }
+        { m_selector.set( 0 ); }
     }
 
   private:
-    Selector<std::string> m_selector{"Opaque", "Transparent", "Volume"};
+    Selector<std::string> m_selector{ "Opaque", "Transparent", "Volume" };
 };
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.cpp
index eb3d56690aec4e2e86714157f55bb6b605696ed9..3021b71973db65132e26c24edc0cc66cbcaa9a8f 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.cpp
@@ -110,11 +110,11 @@ void AccessibilityBufferNode::update() {
 void AccessibilityBufferNode::execute() {
     Ra::Engine::Data::RenderParameters inPassParams;
     // Positions
-    auto inputPosition          = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[0].get() );
-    auto posTexture = &inputPosition->getData();
+    auto inputPosition = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[0].get() );
+    auto posTexture    = &inputPosition->getData();
 
     // Normals
-    auto inputNormal               = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[1].get() );
+    auto inputNormal   = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[1].get() );
     auto normalTexture = &inputNormal->getData();
 
     // AO Radius
@@ -223,21 +223,23 @@ void AccessibilityBufferNode::resize( uint32_t width, uint32_t height ) {
 }
 
 void AccessibilityBufferNode::toJsonInternal( nlohmann::json& data ) const {
-    if ( m_currentSamples != AO_DefaultSamples ) {
+    if ( m_currentSamples != AO_DefaultSamples )
+    {
         // do not write default value
         data["samples"] = m_currentSamples;
     }
-    if ( m_editableAORadius != AO_DefaultRadius ) {
+    if ( m_editableAORadius != AO_DefaultRadius )
+    {
         // do not write default value
-        data["radius"] = m_editableAORadius; }
+        data["radius"] = m_editableAORadius;
+    }
 }
 
 void AccessibilityBufferNode::fromJsonInternal( const nlohmann::json& data ) {
-    if ( data.contains("radius") ) {
-        m_editableAORadius = data["radius"];
-    }
-    if ( data.contains("samples") ) {
-        m_currentSamples = data["samples"];
-        m_editableSamples = Scalar(m_currentSamples);
+    if ( data.contains( "radius" ) ) { m_editableAORadius = data["radius"]; }
+    if ( data.contains( "samples" ) )
+    {
+        m_currentSamples  = data["samples"];
+        m_editableSamples = Scalar( m_currentSamples );
     }
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.hpp
index ce20ec94f83e1ad841e06c2eefa2017c0d9bad16..ac844dc4e91cdbadd8a0cbc2a064dc2ea972b256 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/AccessibilityBufferNode.hpp
@@ -20,14 +20,13 @@ class NodeBasedRenderer_LIBRARY_API AccessibilityBufferNode : public Node
     */
     static const std::string getTypename() { return "Accessibility Buffer Pass"; }
 
-
   protected:
     void toJsonInternal( nlohmann::json& data ) const override;
     void fromJsonInternal( const nlohmann::json& data ) override;
 
   private:
-    static constexpr Scalar AO_DefaultRadius {5_ra};
-    static constexpr Scalar AO_DefaultSamples {64_ra};
+    static constexpr Scalar AO_DefaultRadius{ 5_ra };
+    static constexpr Scalar AO_DefaultSamples{ 64_ra };
 
     NodeTypeTexture* m_rawAO{ nullptr };
     NodeTypeTexture* m_AO{ nullptr };
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ClearColorNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ClearColorNode.cpp
index 42448750c83c6577d07a98fde8629cfb9ee94dfb..9223c2bc635794c93b90488812886df3e4717a2b 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ClearColorNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ClearColorNode.cpp
@@ -132,7 +132,6 @@ void ClearColorNode::resize( uint32_t width, uint32_t height ) {
 #endif
 }
 
-
 void ClearColorNode::toJsonInternal( nlohmann::json& data ) const {
     NodeTypeColor c = NodeTypeColor::linearRGBTosRGB( m_editableClearColor );
     std::array<Scalar, 3> color{ c.x(), c.y(), c.z() };
@@ -140,11 +139,14 @@ void ClearColorNode::toJsonInternal( nlohmann::json& data ) const {
 }
 
 void ClearColorNode::fromJsonInternal( const nlohmann::json& data ) {
-    if ( data.contains("clearColor") ) {
+    if ( data.contains( "clearColor" ) )
+    {
         std::array<Scalar, 3> c = data["clearColor"];
         m_editableClearColor = NodeTypeColor::sRGBToLinearRGB( NodeTypeColor( c[0], c[1], c[2] ) );
-    } else {
-        m_editableClearColor = NodeTypeColor::sRGBToLinearRGB( NodeTypeColor( 42, 42, 42 ) * 1_ra/255_ra );
     }
-
+    else
+    {
+        m_editableClearColor =
+            NodeTypeColor::sRGBToLinearRGB( NodeTypeColor( 42, 42, 42 ) * 1_ra / 255_ra );
+    }
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EmissivityNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EmissivityNode.cpp
index f11e4202aa189e9eed86af530085a4927076eb01..b244b6e2a10b5e7fdd260620bd9c36a51735153f 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EmissivityNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EmissivityNode.cpp
@@ -60,11 +60,11 @@ void EmissivityNode::execute() {
     outputColor->setData( m_colorTexture );
 
     // Depth
-    auto inputDepth               = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[1].get() );
+    auto inputDepth   = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[1].get() );
     auto depthTexture = &inputDepth->getData();
 
     // AO Radius
-    auto inputAO               = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[2].get() );
+    auto inputAO   = static_cast<PortIn<NodeTypeTexture>*>( m_inputs[2].get() );
     auto AOTexture = inputAO->isLinked() ? &inputAO->getData() : m_blankAO;
     inPassParams.addParameter( "amb_occ_sampler", AOTexture );
 
@@ -72,7 +72,10 @@ void EmissivityNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[3].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -82,7 +85,7 @@ void EmissivityNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[4].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 
     m_framebuffer->bind();
     m_framebuffer->attachTexture( gl::GL_DEPTH_ATTACHMENT, depthTexture->texture() );
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EnvLightNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EnvLightNode.cpp
index f66e4ea7c14a2bd72b304a9efdebde4fa84bc7ba..0aa6785651ed1c9c698d693b699208a12420fe11 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EnvLightNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/EnvLightNode.cpp
@@ -107,7 +107,10 @@ void EnvLightNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[4].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -117,7 +120,7 @@ void EnvLightNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[5].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 
     m_framebuffer->bind();
     m_framebuffer->attachTexture( gl::GL_COLOR_ATTACHMENT0, m_colorTexture->texture() );
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/LocalLightNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/LocalLightNode.cpp
index 4a18648d5358c30840dcd6fe70e42e11fd50c3dc..d07880f11d4fd70483ebdf2f7219b1c5d95a3f12 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/LocalLightNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/LocalLightNode.cpp
@@ -74,7 +74,10 @@ void LocalLightNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[3].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -84,7 +87,7 @@ void LocalLightNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[4].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 
     // Lights
     auto inputLight = static_cast<PortIn<std::vector<NodeTypeLight>>*>( m_inputs[5].get() );
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/SimpleNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/SimpleNode.cpp
index f3caf86ffb666e1279a02fa5abf1ddd6c720dde2..3f95bd1da3149faa86a3683e4c256ce56aacb2a6 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/SimpleNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/SimpleNode.cpp
@@ -3,7 +3,7 @@
 #include <Engine/Data/Material.hpp>
 #include <Engine/Data/ShaderConfigFactory.hpp>
 
-#include<globjects/State.h>
+#include <globjects/State.h>
 
 SimpleNode::SimpleNode( const std::string& name ) : Node( name, getTypename() ) {
     auto portInRO = new PortIn<std::vector<NodeTypeRenderObject>>( "inRenderObjects", this );
@@ -56,7 +56,6 @@ SimpleNode::SimpleNode( const std::string& name ) : Node( name, getTypename() )
 void SimpleNode::init() {
     m_framebuffer = new globjects::Framebuffer();
 
-
     float blankAO[4] = { 1.f, 1.f, 1.f, 1.f };
     Ra::Engine::Data::TextureParameters texParams;
     texParams.target         = gl::GL_TEXTURE_2D;
@@ -71,15 +70,15 @@ void SimpleNode::init() {
     texParams.texels         = &blankAO;
     m_blankAO                = new Ra::Engine::Data::Texture( texParams );
     m_blankAO->initializeGL();
-/*
-    m_nodeState = new globjects::State(globjects::State::DeferredMode);
-    m_nodeState->enable( gl::GL_DEPTH_TEST );
-    m_nodeState->depthMask( gl::GL_TRUE );
-    m_nodeState->depthFunc( gl::GL_LEQUAL );
-    m_nodeState->colorMask( gl::GL_TRUE, gl::GL_TRUE, gl::GL_TRUE, gl::GL_TRUE );
-    m_nodeState->blendFunc( gl::GL_ONE, gl::GL_ONE );
-    m_nodeState->disable( gl::GL_BLEND );
-*/
+    /*
+        m_nodeState = new globjects::State(globjects::State::DeferredMode);
+        m_nodeState->enable( gl::GL_DEPTH_TEST );
+        m_nodeState->depthMask( gl::GL_TRUE );
+        m_nodeState->depthFunc( gl::GL_LEQUAL );
+        m_nodeState->colorMask( gl::GL_TRUE, gl::GL_TRUE, gl::GL_TRUE, gl::GL_TRUE );
+        m_nodeState->blendFunc( gl::GL_ONE, gl::GL_ONE );
+        m_nodeState->disable( gl::GL_BLEND );
+    */
 }
 
 void SimpleNode::update() {}
@@ -89,7 +88,10 @@ void SimpleNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[0].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -99,11 +101,10 @@ void SimpleNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[1].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
     // Lights
     auto inputLight = static_cast<PortIn<std::vector<NodeTypeLight>>*>( m_inputs[2].get() );
-    if ( !inputLight->isLinked() )
-    { return; }
+    if ( !inputLight->isLinked() ) { return; }
     auto& lights = inputLight->getData();
 
     m_framebuffer->bind();
@@ -111,8 +112,8 @@ void SimpleNode::execute() {
     const gl::GLenum buffers[] = { gl::GL_COLOR_ATTACHMENT0 };
     gl::glDrawBuffers( 1, buffers );
 
-    //auto currentState = globjects::State::currentState();
-    //m_nodeState->apply();
+    // auto currentState = globjects::State::currentState();
+    // m_nodeState->apply();
 
     gl::glEnable( gl::GL_DEPTH_TEST );
     gl::glDepthMask( gl::GL_TRUE );
@@ -128,15 +129,16 @@ void SimpleNode::execute() {
     if ( lights.size() > 0 )
     {
         bool first_light = true;
-        for( const auto& l : lights )
+        for ( const auto& l : lights )
         {
             Ra::Engine::Data::RenderParameters inPassParams;
             inPassParams.addParameter( "amb_occ_sampler", m_blankAO );
             l->getRenderParameters( inPassParams );
             for ( const auto& ro : renderObjects )
             { ro->render( inPassParams, cameras[0], m_idx ); }
-            if (first_light) {
-                //break;
+            if ( first_light )
+            {
+                // break;
                 first_light = false;
                 gl::glEnable( gl::GL_BLEND );
                 gl::glBlendFunc( gl::GL_ONE, gl::GL_ONE );
@@ -146,7 +148,7 @@ void SimpleNode::execute() {
     }
     gl::glDisable( gl::GL_BLEND );
     gl::glDepthMask( gl::GL_TRUE );
-    //currentState->apply();
+    // currentState->apply();
 
     m_framebuffer->unbind();
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/TransparencyNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/TransparencyNode.cpp
index 592b1b8275cb5a502818d775680fa50cec12f414..982dacf930633549043fe22de2a19a5457a4e899 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/TransparencyNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/TransparencyNode.cpp
@@ -107,7 +107,10 @@ void TransparencyNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[2].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -117,7 +120,7 @@ void TransparencyNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[3].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/UINode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/UINode.cpp
index aae77ac3dd19afc55cb48b3ea444427f0549dcbe..9dfff0820477b936790a766dfa5811d017301637 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/UINode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/UINode.cpp
@@ -59,7 +59,10 @@ void UINode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[3].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -69,7 +72,7 @@ void UINode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[4].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeNode.cpp
index f327f12f3f877d4d2e903f88769df1ffe2f98011..1ab248cd87ff54ca0ba852184dc53eea80e76e9f 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeNode.cpp
@@ -97,7 +97,10 @@ void VolumeNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[2].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -107,7 +110,7 @@ void VolumeNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[3].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
@@ -117,9 +120,9 @@ void VolumeNode::execute() {
     if ( !inputLight->isLinked() )
     {
 #ifdef GRAPH_CALL_TRACE
-                std::cout << "Lights port is not linked, 0 light" << std::endl;
+        std::cout << "Lights port is not linked, 0 light" << std::endl;
 #endif
-    return;
+        return;
     }
     auto& lights = inputLight->getData();
 #ifdef GRAPH_CALL_TRACE
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeVizualisationNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeVizualisationNode.cpp
index 1425be366880b55f6ec118f5ad14442c43015bbf..8cb1d35ec4fda978e44886df79c2afde3d19b5ca 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeVizualisationNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/VolumeVizualisationNode.cpp
@@ -118,7 +118,10 @@ void VolumeVizualisationNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[2].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -128,7 +131,7 @@ void VolumeVizualisationNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[3].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
@@ -257,9 +260,7 @@ void VolumeVizualisationNode::buildRenderTechnique(
 }
 
 // TODO : implement these
-void VolumeVizualisationNode::toJsonInternal( nlohmann::json& data ) const {
-
-}
+void VolumeVizualisationNode::toJsonInternal( nlohmann::json& data ) const {}
 
 void VolumeVizualisationNode::fromJsonInternal( const nlohmann::json& data ) {
     // TODO !!!
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/WireframeNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/WireframeNode.cpp
index 96e78adddf1698d6641de8982fc44769aafc8f11..139ac80c89f2ee1960da5ed99657dbc32ef14ec8 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/WireframeNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/WireframeNode.cpp
@@ -150,7 +150,10 @@ void WireframeNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[3].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -162,7 +165,7 @@ void WireframeNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[4].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ZGeomPrepassNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ZGeomPrepassNode.cpp
index d929a234d8ce2edb8a70eb6c17f2f40f7732c35b..39a56028b83d9ea875ae171c85a415d5e48074ae 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ZGeomPrepassNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/RenderPasses/ZGeomPrepassNode.cpp
@@ -63,7 +63,10 @@ void ZGeomPrepassNode::execute() {
     auto inputRO = static_cast<PortIn<std::vector<NodeTypeRenderObject>>*>( m_inputs[0].get() );
     if ( !inputRO->isLinked() )
 #ifdef GRAPH_CALL_TRACE
-    { std::cout << "RenderObjects port is not linked, no render object" << std::endl; return;}
+    {
+        std::cout << "RenderObjects port is not linked, no render object" << std::endl;
+        return;
+    }
     else
     { std::cout << renderObjects.size() << " render objects" << std::endl; }
 #else
@@ -73,7 +76,7 @@ void ZGeomPrepassNode::execute() {
 
     // Cameras
     auto inputCamera = static_cast<PortIn<std::vector<NodeTypeCamera>>*>( m_inputs[1].get() );
-    auto& cameras = inputCamera->getData();
+    auto& cameras    = inputCamera->getData();
 #ifdef GRAPH_CALL_TRACE
     std::cout << cameras.size() << " cameras" << std::endl;
 #endif
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/SinkNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/SinkNode.hpp
index a5f5eb16163acaadb12ed1429f1ee7b573093509..5f6e594011fbe59340ccefc6ab4987148b71b142 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/SinkNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/SinkNode.hpp
@@ -46,5 +46,4 @@ class NodeBasedRenderer_LIBRARY_API SinkNode : public Node
   protected:
     void toJsonInternal( nlohmann::json& data ) const override {}
     void fromJsonInternal( const nlohmann::json& data ) override {}
-
 };
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.cpp
index 56130eafc829359513a8cf6aa96113dc72ec922f..047b792681448e943c6279ff327caf5672c5ec3f 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.cpp
@@ -10,7 +10,8 @@ using namespace Ra::Core::Utils;
 /** Source env map */
 
 void EnvMapTextureSource::toJsonInternal( nlohmann::json& data ) const {
-    if ( getData() ) {
+    if ( getData() )
+    {
         data["files"]    = getData()->getImageName().c_str();
         data["type"]     = int( getData()->getImageType() );
         data["strength"] = getData()->getEnvStrength() * 100.;
@@ -18,7 +19,8 @@ void EnvMapTextureSource::toJsonInternal( nlohmann::json& data ) const {
 }
 
 void EnvMapTextureSource::fromJsonInternal( const nlohmann::json& data ) {
-    if (data.contains("files")) {
+    if ( data.contains( "files" ) )
+    {
         std::string files = data["files"];
         int t             = data["type"];
         float strength    = data["strength"];
@@ -58,20 +60,18 @@ void EnvMapTextureSource::fromJsonInternal( const nlohmann::json& data ) {
         }
         else
         { setData( nullptr ); }
-    } else
+    }
+    else
     { setData( nullptr ); }
 }
 
-
 /** Source bool */
 void BooleanValueSource::toJsonInternal( nlohmann::json& data ) const {
     data["boolean"] = getData();
 }
 
 void BooleanValueSource::fromJsonInternal( const nlohmann::json& data ) {
-    if ( data.contains("boolean") ) {
-        setData( data["boolean"] );
-    }
+    if ( data.contains( "boolean" ) ) { setData( data["boolean"] ); }
 }
 
 /** Source Scalar */
@@ -80,9 +80,7 @@ void ScalarValueSource::toJsonInternal( nlohmann::json& data ) const {
 }
 
 void ScalarValueSource::fromJsonInternal( const nlohmann::json& data ) {
-    if (data.contains("number")) {
-        setData( data["number"] );
-    }
+    if ( data.contains( "number" ) ) { setData( data["number"] ); }
 }
 
 /** Source Color */
@@ -93,7 +91,8 @@ void ColorSourceNode::toJsonInternal( nlohmann::json& data ) const {
 }
 
 void ColorSourceNode::fromJsonInternal( const nlohmann::json& data ) {
-    if (data.contains("color")) {
+    if ( data.contains( "color" ) )
+    {
         std::array<Scalar, 3> c = data["color"];
         setData( NodeTypeColor::sRGBToLinearRGB( NodeTypeColor( c[0], c[1], c[2] ) ) );
     }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp
index 9bc841bea9dcc87703625f28791622c22e3adf81..aed5193a1f9b9c8e067abbf48f9efe07aea1b1e9 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sources/SourceNode.hpp
@@ -12,8 +12,6 @@ class SourceNode : public Node
         Node( instanceName, typeName ) {
         auto portOut = new PortOut<T>( "to", this );
         addOutput( portOut, &m_data );
-
-
     }
 
   public:
diff --git a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
index 1f143978524de04f9107f93ee6f9d5e2473a9909..889d34e494d022ee71186ab16094f678354891dd 100644
--- a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
@@ -161,16 +161,17 @@ void RenderGraph::loadFromJson( const std::string& jsonFilePath ) {
             {
                 std::cerr << "Error when reading JSON file \"" << jsonFilePath
                           << "\": Output index " << fromIndex << " for node \""
-                          << nodeFrom->getInstanceName() << " (" << nodeFrom->getTypeName() << ")\" must be between 0 and "
-                          << nodeFrom->getOutputs().size() - 1 << ". Link not added." << std::endl;
+                          << nodeFrom->getInstanceName() << " (" << nodeFrom->getTypeName()
+                          << ")\" must be between 0 and " << nodeFrom->getOutputs().size() - 1
+                          << ". Link not added." << std::endl;
                 continue;
             }
         }
         else
         {
             std::cerr << "Error when reading JSON file \"" << jsonFilePath
-                      << "\": Could not find a node associated with id " << l["out_id"] << ". Link not added."
-                      << std::endl;
+                      << "\": Could not find a node associated with id " << l["out_id"]
+                      << ". Link not added." << std::endl;
             continue;
         }
 
@@ -184,17 +185,17 @@ void RenderGraph::loadFromJson( const std::string& jsonFilePath ) {
             else
             {
                 std::cerr << "Error when reading JSON file \"" << jsonFilePath << "\": Input index "
-                          << toIndex << " for node \"" << nodeFrom->getInstanceName() << " (" << nodeFrom->getTypeName()
-                          << ")\" must be between 0 and " << nodeTo->getInputs().size() - 1 << ". Link not added."
-                          << std::endl;
+                          << toIndex << " for node \"" << nodeFrom->getInstanceName() << " ("
+                          << nodeFrom->getTypeName() << ")\" must be between 0 and "
+                          << nodeTo->getInputs().size() - 1 << ". Link not added." << std::endl;
                 continue;
             }
         }
         else
         {
             std::cerr << "Error when reading JSON file \"" << jsonFilePath
-                      << "\": Could not find a node associated with id " << l["in_id"] << ". Link not added."
-                      << std::endl;
+                      << "\": Could not find a node associated with id " << l["in_id"]
+                      << ". Link not added." << std::endl;
             continue;
         }
 
@@ -208,33 +209,34 @@ void RenderGraph::loadFromJson( const std::string& jsonFilePath ) {
                       << std::endl;
         }
     }
-
 }
 
 void RenderGraph::saveToJson( const std::string& jsonFilePath ) {
     std::cout << "RenderGraph::saveToJson : saving graph to " << jsonFilePath << "\n";
-    nlohmann::json nodes = nlohmann::json::array();
+    nlohmann::json nodes       = nlohmann::json::array();
     nlohmann::json connections = nlohmann::json::array();
-    for(const auto&n : m_nodes) {
+    for ( const auto& n : m_nodes )
+    {
         nlohmann::json nodeData;
-        n->toJson(nodeData);
-        nodes.push_back(nodeData);
-        int numPort=0;
-        for( const auto & input : n->getInputs() ) {
-            if( input->isLinked() ) {
+        n->toJson( nodeData );
+        nodes.push_back( nodeData );
+        int numPort = 0;
+        for ( const auto& input : n->getInputs() )
+        {
+            if ( input->isLinked() )
+            {
                 nlohmann::json link = nlohmann::json::object();
-                link["in_id"] = n->getUuid();
-                link["in_index"] = numPort;
-                auto portOut = input->getLink();
-                auto nodeOut = portOut->getNode();
-                int outPortIndex = 0;
-                for( const auto& p : nodeOut->getOutputs() ) {
-                    if ( p.get() == portOut ) {
-                        break;
-                    }
+                link["in_id"]       = n->getUuid();
+                link["in_index"]    = numPort;
+                auto portOut        = input->getLink();
+                auto nodeOut        = portOut->getNode();
+                int outPortIndex    = 0;
+                for ( const auto& p : nodeOut->getOutputs() )
+                {
+                    if ( p.get() == portOut ) { break; }
                     outPortIndex++;
                 }
-                link["out_id"] = nodeOut->getUuid();
+                link["out_id"]    = nodeOut->getUuid();
                 link["out_index"] = outPortIndex;
                 connections.push_back( link );
             }
@@ -242,10 +244,10 @@ void RenderGraph::saveToJson( const std::string& jsonFilePath ) {
         }
     }
     nlohmann::json graphJson;
-    graphJson["nodes"] = nodes;
+    graphJson["nodes"]       = nodes;
     graphJson["connections"] = connections;
-    std::ofstream file(jsonFilePath);
-    file << std::setw(4) << graphJson << std::endl;
+    std::ofstream file( jsonFilePath );
+    file << std::setw( 4 ) << graphJson << std::endl;
 }
 
 bool RenderGraph::addNode( Node* newNode ) {
@@ -306,15 +308,16 @@ bool RenderGraph::addLink( Node* nodeFrom,
 #ifdef GRAPH_CALL_TRACE
     std::cout << "\e[32m\e[1mRenderGraph\e[0m \"" << m_name
               << "\": ADD LINK : try to connect output \"" + nodeFromOutputName + "\" of node \"" +
-                     nodeFrom->getInstanceName() + "\" to input \"" + nodeToInputName + "\" of node \"" +
-                     nodeTo->getInstanceName() + "\"."
+                     nodeFrom->getInstanceName() + "\" to input \"" + nodeToInputName +
+                     "\" of node \"" + nodeTo->getInstanceName() + "\"."
               << std::endl;
 #endif
     // Check node "from" existence in the graph
     if ( findNode( nodeFrom->getInstanceName() ) == -1 )
     {
 #ifdef GRAPH_CALL_TRACE
-        std::cerr << "ADD LINK : node \"from\" \"" + nodeFrom->getInstanceName() + "\" does not exist."
+        std::cerr << "ADD LINK : node \"from\" \"" + nodeFrom->getInstanceName() +
+                         "\" does not exist."
                   << std::endl;
 #endif
         return false;
@@ -412,8 +415,8 @@ bool RenderGraph::addLink( Node* nodeFrom,
 #ifdef GRAPH_CALL_TRACE
     std::cout << "\e[32m\e[1mRenderGraph\e[0m \"" << m_name
               << "\": ADD LINK : success connecting output \"" + nodeFromOutputName +
-                     "\" of node \"" + nodeFrom->getInstanceName() + "\" to input \"" + nodeToInputName +
-                     "\" of node \"" + nodeTo->getInstanceName() + "\"."
+                     "\" of node \"" + nodeFrom->getInstanceName() + "\" to input \"" +
+                     nodeToInputName + "\" of node \"" + nodeTo->getInstanceName() + "\"."
               << std::endl;
 #endif
     return true;
@@ -424,7 +427,8 @@ bool RenderGraph::removeLink( Node* node, const std::string& nodeInputName ) {
     if ( findNode( node->getInstanceName() ) == -1 )
     {
 #ifdef GRAPH_CALL_TRACE
-        std::cerr << "REMOVE LINK : node \"" + node->getInstanceName() + "\" does not exist." << std::endl;
+        std::cerr << "REMOVE LINK : node \"" + node->getInstanceName() + "\" does not exist."
+                  << std::endl;
 #endif
         return false;
     }
diff --git a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.hpp b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.hpp
index bb2d764c1573fbe0ca95b078664db68a062fffec..7f939d838a24db425d34f00a5e0f71ce99dc2a2a 100644
--- a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.hpp
@@ -6,7 +6,6 @@
 
 #include <RadiumNBR/NodeGraph/Node.hpp>
 
-
 // TODO : Find a new name, it is not a RENDER graph only anymore
 class NodeBasedRenderer_LIBRARY_API RenderGraph : public Node
 {