/* ***** BEGIN LICENSE BLOCK *****

* This file is part of Natron <http://www.natron.fr/>,

* Copyright (C) 2015 INRIA and Alexandre Gauthier-Foichat

*

* Natron 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 2 of the License, or

* (at your option) any later version.

*

* Natron 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 Natron. If not, see <http://www.gnu.org/licenses/gpl-2.0.html>

* ***** END LICENSE BLOCK ***** */

// ***** BEGIN PYTHON BLOCK *****

// from <https://docs.python.org/3/c-api/intro.html#include-files>:

// "Since Python may define some pre-processor definitions which affect the standard headers on some systems, you must include Python.h before any standard headers are included."

#include <Python.h>

// ***** END PYTHON BLOCK *****

#include "NodeGroup.h"

#include <set>

#include <locale>

#include <cfloat>

#include <QThreadPool>

#include <QCoreApplication>

#include <QTextStream>

#include <algorithm> // min, max

#include "Engine/AppInstance.h"

#include "Engine/Curve.h"

#include "Engine/GroupInput.h"

#include "Engine/GroupOutput.h"

#include "Engine/KnobFile.h"

#include "Engine/KnobTypes.h"

#include "Engine/Node.h"

#include "Engine/NodeGraphI.h"

#include "Engine/NodeGuiI.h"

#include "Engine/OutputSchedulerThread.h"

#include "Engine/Plugin.h"

#include "Engine/Project.h"

#include "Engine/RotoContext.h"

#include "Engine/Settings.h"

#include "Engine/TimeLine.h"

#include "Engine/ViewerInstance.h"

#define NATRON_PYPLUG_EXPORTER_VERSION 1

using namespace Natron;

struct NodeCollectionPrivate

{

AppInstance* app;

NodeGraphI* graph;

mutable QMutex nodesMutex;

NodeList nodes;

NodeCollectionPrivate(AppInstance* app)

: app(app)

, graph(0)

, nodesMutex()

, nodes()

{

}

NodePtr findNodeInternal(const std::string& name,const std::string& recurseName) const;

};

NodeCollection::NodeCollection(AppInstance* app)

: _imp(new NodeCollectionPrivate(app))

{

}

NodeCollection::~NodeCollection()

{

}

AppInstance*

NodeCollection::getApplication() const

{

return _imp->app;

}

void

NodeCollection::setNodeGraphPointer(NodeGraphI* graph)

{

_imp->graph = graph;

}

void

NodeCollection::discardNodeGraphPointer()

{

_imp->graph = 0;

}

NodeGraphI*

NodeCollection::getNodeGraph() const

{

return _imp->graph;

}

NodeList

NodeCollection::getNodes() const

{

QMutexLocker k(&_imp->nodesMutex);

return _imp->nodes;

}

void

NodeCollection::getNodes_recursive(NodeList& nodes) const

{

std::list<NodeGroup*> groupToRecurse;

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::const_iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

nodes.push_back(*it);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

groupToRecurse.push_back(isGrp);

}

}

}

for (std::list<NodeGroup*>::const_iterator it = groupToRecurse.begin(); it != groupToRecurse.end(); ++it) {

(*it)->getNodes_recursive(nodes);

}

}

void

NodeCollection::addNode(const NodePtr& node)

{

{

QMutexLocker k(&_imp->nodesMutex);

_imp->nodes.push_back(node);

}

}

void

NodeCollection::removeNode(const NodePtr& node)

{

QMutexLocker k(&_imp->nodesMutex);

NodeList::iterator found = std::find(_imp->nodes.begin(), _imp->nodes.end(), node);

if (found != _imp->nodes.end()) {

_imp->nodes.erase(found);

}

}

NodePtr

NodeCollection::getLastNode(const std::string& pluginID) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::const_reverse_iterator it = _imp->nodes.rbegin(); it != _imp->nodes.rend(); ++it ) {

if ((*it)->getPluginID() == pluginID) {

return *it;

}

}

return NodePtr();

}

bool

NodeCollection::hasNodes() const

{

QMutexLocker k(&_imp->nodesMutex);

return _imp->nodes.size() > 0;

}

void

NodeCollection::getActiveNodes(NodeList* nodes) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ((*it)->isActivated()) {

nodes->push_back(*it);

}

}

}

void

NodeCollection::getActiveNodesExpandGroups(NodeList* nodes) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ((*it)->isActivated()) {

nodes->push_back(*it);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->getActiveNodesExpandGroups(nodes);

}

}

}

}

void

NodeCollection::getViewers(std::list<ViewerInstance*>* viewers) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

ViewerInstance* isViewer = dynamic_cast<ViewerInstance*>((*it)->getLiveInstance());

if (isViewer) {

viewers->push_back(isViewer);

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->getViewers(viewers);

}

}

}

void

NodeCollection::getWriters(std::list<Natron::OutputEffectInstance*>* writers) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ((*it)->getLiveInstance()->isWriter()) {

Natron::OutputEffectInstance* out = dynamic_cast<Natron::OutputEffectInstance*>((*it)->getLiveInstance());

assert(out);

writers->push_back(out);

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->getWriters(writers);

}

}

}

static void setMustQuitProcessingRecursive(bool mustQuit, NodeCollection* grp)

{

NodeList nodes = grp->getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

(*it)->setMustQuitProcessing(mustQuit);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

setMustQuitProcessingRecursive(mustQuit,isGrp);

}

}

}

static void quitAnyProcessingInternal(NodeCollection* grp) {

NodeList nodes = grp->getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

(*it)->quitAnyProcessing();

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

quitAnyProcessingInternal(isGrp);

}

}

}

void

NodeCollection::quitAnyProcessingForAllNodes()

{

setMustQuitProcessingRecursive(true, this);

quitAnyProcessingInternal(this);

setMustQuitProcessingRecursive(false, this);

}

void

NodeCollection::resetTotalTimeSpentRenderingForAllNodes()

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

Natron::EffectInstance* effect = (*it)->getLiveInstance();

effect->resetTotalTimeSpentRendering();

NodeGroup* isGroup = dynamic_cast<NodeGroup*>(effect);

if (isGroup) {

isGroup->resetTotalTimeSpentRenderingForAllNodes();

}

}

}

bool

NodeCollection::hasNodeRendering() const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ( (*it)->isOutputNode() ) {

Natron::OutputEffectInstance* effect = dynamic_cast<Natron::OutputEffectInstance*>( (*it)->getLiveInstance() );

assert(effect);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>(effect);

if (isGrp) {

if (isGrp->hasNodeRendering()) {

return true;

}

} else {

if ( effect->getRenderEngine()->hasThreadsWorking() ) {

return true;

break;

}

}

}

}

return false;

}

void

NodeCollection::refreshViewersAndPreviews()

{

assert(QThread::currentThread() == qApp->thread());

if ( !appPTR->isBackground() ) {

int time = _imp->app->getTimeLine()->currentFrame();

NodeList nodes = getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

assert(*it);

(*it)->computePreviewImage(time);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->refreshViewersAndPreviews();

} else {

ViewerInstance* n = dynamic_cast<ViewerInstance*>((*it)->getLiveInstance());

if (n) {

n->renderCurrentFrame(true);

}

}

}

}

}

void

NodeCollection::refreshPreviews()

{

int time = _imp->app->getTimeLine()->currentFrame();

NodeList nodes;

getActiveNodes(&nodes);

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ( (*it)->isPreviewEnabled() ) {

(*it)->refreshPreviewImage(time);

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->refreshPreviews();

}

}

}

void

NodeCollection::forceRefreshPreviews()

{

int time = _imp->app->getTimeLine()->currentFrame();

NodeList nodes;

getActiveNodes(&nodes);

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ( (*it)->isPreviewEnabled() ) {

(*it)->computePreviewImage(time);

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->forceRefreshPreviews();

}

}

}

void

NodeCollection::clearNodes(bool emitSignal)

{

NodeList nodesToDelete;

{

QMutexLocker l(&_imp->nodesMutex);

nodesToDelete = _imp->nodes;

}

///First quit any processing

for (NodeList::iterator it = nodesToDelete.begin(); it != nodesToDelete.end(); ++it) {

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->clearNodes(emitSignal);

}

(*it)->quitAnyProcessing();

}

///Kill thread pool so threads are killed before killing thread storage

QThreadPool::globalInstance()->waitForDone();

///Kill effects

for (NodeList::iterator it = nodesToDelete.begin(); it != nodesToDelete.end(); ++it) {

(*it)->deactivate(std::list<Natron::Node* >(),false,false,true,false);

}

for (NodeList::iterator it = nodesToDelete.begin(); it != nodesToDelete.end(); ++it) {

(*it)->removeReferences(false);

}

if (emitSignal) {

if (_imp->graph) {

_imp->graph->onNodesCleared();

}

}

{

QMutexLocker l(&_imp->nodesMutex);

_imp->nodes.clear();

}

nodesToDelete.clear();

}

bool

NodeCollection::setNodeName(const std::string& baseName,bool appendDigit,bool errorIfExists,std::string* nodeName)

{

if (baseName.empty()) {

return false;

}

///Remove any non alpha-numeric characters from the baseName

std::string cpy = Natron::makeNameScriptFriendly(baseName);

if (cpy.empty()) {

return false;

}

bool foundNodeWithName = false;

int no = 1;

{

std::stringstream ss;

ss << cpy;

if (appendDigit) {

ss << no;

}

*nodeName = ss.str();

}

do {

foundNodeWithName = false;

QMutexLocker l(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ((*it)->getScriptName_mt_safe() == *nodeName) {

foundNodeWithName = true;

break;

}

}

if (foundNodeWithName) {

if (errorIfExists || !appendDigit) {

return false;

}

++no;

{

std::stringstream ss;

ss << cpy << no;

*nodeName = ss.str();

}

}

} while (foundNodeWithName);

return true;

}

void

NodeCollection::initNodeName(const std::string& pluginLabel,std::string* nodeName)

{

std::string baseName(pluginLabel);

if (baseName.size() > 3 &&

baseName[baseName.size() - 1] == 'X' &&

baseName[baseName.size() - 2] == 'F' &&

baseName[baseName.size() - 3] == 'O') {

baseName = baseName.substr(0,baseName.size() - 3);

}

if (!setNodeName(baseName,true, false, nodeName)) {

throw std::invalid_argument(QObject::tr("Invalid plugin label: ").toStdString() + pluginLabel);

}

}

bool

NodeCollection::connectNodes(int inputNumber,const NodePtr& input,Natron::Node* output,bool force)

{

////Only called by the main-thread

assert( QThread::currentThread() == qApp->thread() );

NodePtr existingInput = output->getRealInput(inputNumber);

if (force && existingInput) {

bool ok = disconnectNodes(existingInput.get(), output);

assert(ok);

if (input->getMaxInputCount() > 0) {

ok = connectNodes(input->getPreferredInputForConnection(), existingInput, input.get());

assert(ok);

}

}

if (!input) {

return true;

}

if ( !output->connectInput(input, inputNumber) ) {

return false;

}

return true;

}

bool

NodeCollection::connectNodes(int inputNumber,const std::string & inputName,Natron::Node* output)

{

NodeList nodes = getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

assert(*it);

if ((*it)->getScriptName() == inputName) {

return connectNodes(inputNumber,*it, output);

}

}

return false;

}

bool

NodeCollection::disconnectNodes(Natron::Node* input,Natron::Node* output,bool autoReconnect)

{

NodePtr inputToReconnectTo;

int indexOfInput = output->inputIndex( input );

if (indexOfInput == -1) {

return false;

}

int inputsCount = input->getMaxInputCount();

if (inputsCount == 1) {

inputToReconnectTo = input->getInput(0);

}

if (output->disconnectInput(input) < 0) {

return false;

}

if (autoReconnect && inputToReconnectTo) {

connectNodes(indexOfInput, inputToReconnectTo, output);

}

return true;

}

bool

NodeCollection::autoConnectNodes(const NodePtr& selected,const NodePtr& created)

{

///We follow this rule:

// 1) selected is output

// a) created is output --> fail

// b) created is input --> connect input

// c) created is regular --> connect input

// 2) selected is input

// a) created is output --> connect output

// b) created is input --> fail

// c) created is regular --> connect output

// 3) selected is regular

// a) created is output--> connect output

// b) created is input --> connect input

// c) created is regular --> connect output

///if true if will connect 'created' as input of 'selected',

///otherwise as output.

bool connectAsInput = false;

///cannot connect 2 input nodes together: case 2-b)

if ( (selected->getMaxInputCount() == 0) && (created->getMaxInputCount() == 0) ) {

return false;

}

///cannot connect 2 output nodes together: case 1-a)

if ( selected->isOutputNode() && created->isOutputNode() ) {

return false;

}

///1)

if ( selected->isOutputNode() ) {

///assert we're not in 1-a)

assert( !created->isOutputNode() );

///for either cases 1-b) or 1-c) we just connect the created node as input of the selected node.

connectAsInput = true;

}

///2) and 3) are similar exceptfor case b)

else {

///case 2 or 3- a): connect the created node as output of the selected node.

if ( created->isOutputNode() ) {

connectAsInput = false;

}

///case b)

else if (created->getMaxInputCount() == 0) {

assert(selected->getMaxInputCount() != 0);

///case 3-b): connect the created node as input of the selected node

connectAsInput = true;

}

///case c) connect created as output of the selected node

else {

connectAsInput = false;

}

}

bool ret = false;

if (connectAsInput) {

///connect it to the first input

int selectedInput = selected->getPreferredInputForConnection();

if (selectedInput != -1) {

bool ok = connectNodes(selectedInput, created, selected.get(),true);

assert(ok);

Q_UNUSED(ok);

ret = true;

} else {

ret = false;

}

} else {

if ( !created->isOutputNode() ) {

///we find all the nodes that were previously connected to the selected node,

///and connect them to the created node instead.

std::map<Node*,int> outputsConnectedToSelectedNode;

selected->getOutputsConnectedToThisNode(&outputsConnectedToSelectedNode);

for (std::map<Node*,int>::iterator it = outputsConnectedToSelectedNode.begin();

it != outputsConnectedToSelectedNode.end(); ++it) {

if (it->first->getParentMultiInstanceName().empty()) {

bool ok = disconnectNodes(selected.get(), it->first);

assert(ok);

ok = connectNodes(it->second, created, it->first);

Q_UNUSED(ok);

//assert(ok); Might not be ok if the disconnectNodes() action above was queued

}

}

}

///finally we connect the created node to the selected node

int createdInput = created->getPreferredInputForConnection();

if (createdInput != -1) {

bool ok = connectNodes(createdInput, selected, created.get());

assert(ok);

Q_UNUSED(ok);

ret = true;

} else {

ret = false;

}

}

///update the render trees

std::list<ViewerInstance* > viewers;

created->hasViewersConnected(&viewers);

for (std::list<ViewerInstance* >::iterator it = viewers.begin(); it != viewers.end(); ++it) {

(*it)->renderCurrentFrame(true);

}

return ret;

} // autoConnectNodes

NodePtr

NodeCollectionPrivate::findNodeInternal(const std::string& name,const std::string& recurseName) const

{

QMutexLocker k(&nodesMutex);

for (NodeList::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ((*it)->getScriptName_mt_safe() == name) {

if (!recurseName.empty()) {

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

return isGrp->getNodeByFullySpecifiedName(recurseName);

} else {

std::list<NodePtr> children;

(*it)->getChildrenMultiInstance(&children);

for (std::list<NodePtr>::iterator it2 = children.begin(); it2 != children.end(); ++it2) {

if ((*it2)->getScriptName_mt_safe() == recurseName) {

return *it2;

}

}

}

} else {

return *it;

}

}

}

return NodePtr();

}

NodePtr

NodeCollection::getNodeByName(const std::string & name) const

{

return _imp->findNodeInternal(name,std::string());

}

void

NodeCollection::getNodeNameAndRemainder_LeftToRight(const std::string& fullySpecifiedName,std::string& name,std::string& remainder)

{

std::size_t foundDot = fullySpecifiedName.find_first_of('.');

if (foundDot != std::string::npos) {

name = fullySpecifiedName.substr(0, foundDot);

if (foundDot + 1 < fullySpecifiedName.size()) {

remainder = fullySpecifiedName.substr(foundDot + 1, std::string::npos);

}

} else {

name = fullySpecifiedName;

}

}

void

NodeCollection::getNodeNameAndRemainder_RightToLeft(const std::string& fullySpecifiedName,std::string& name,std::string& remainder)

{

std::size_t foundDot = fullySpecifiedName.find_last_of('.');

if (foundDot != std::string::npos) {

name = fullySpecifiedName.substr(foundDot + 1, std::string::npos);

if (foundDot > 0) {

remainder = fullySpecifiedName.substr(0, foundDot - 1);

}

} else {

name = fullySpecifiedName;

}

}

NodePtr

NodeCollection::getNodeByFullySpecifiedName(const std::string& fullySpecifiedName) const

{

std::string toFind;

std::string recurseName;

getNodeNameAndRemainder_LeftToRight(fullySpecifiedName, toFind, recurseName);

return _imp->findNodeInternal(toFind,recurseName);

}

void

NodeCollection::notifyRenderBeingAborted()

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

(*it)->notifyRenderBeingAborted();

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->notifyRenderBeingAborted();

}

}

}

void

NodeCollection::fixRelativeFilePaths(const std::string& projectPathName,const std::string& newProjectPath,bool blockEval)

{

NodeList nodes = getNodes();

boost::shared_ptr<Natron::Project> project = _imp->app->getProject();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ((*it)->isActivated()) {

(*it)->getLiveInstance()->beginChanges();

const std::vector<boost::shared_ptr<KnobI> >& knobs = (*it)->getKnobs();

for (U32 j = 0; j < knobs.size(); ++j) {

Knob<std::string>* isString = dynamic_cast< Knob<std::string>* >(knobs[j].get());

String_Knob* isStringKnob = dynamic_cast<String_Knob*>(isString);

if (!isString || isStringKnob || knobs[j] == project->getEnvVarKnob()) {

continue;

}

std::string filepath = isString->getValue();

if (!filepath.empty()) {

if (project->fixFilePath(projectPathName, newProjectPath, filepath)) {

isString->setValue(filepath, 0);

}

}

}

(*it)->getLiveInstance()->endChanges(blockEval);

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->fixRelativeFilePaths(projectPathName, newProjectPath, blockEval);

}

}

}

}

void

NodeCollection::fixPathName(const std::string& oldName,const std::string& newName)

{

NodeList nodes = getNodes();

boost::shared_ptr<Natron::Project> project = _imp->app->getProject();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ((*it)->isActivated()) {

const std::vector<boost::shared_ptr<KnobI> >& knobs = (*it)->getKnobs();

for (U32 j = 0; j < knobs.size(); ++j) {

Knob<std::string>* isString = dynamic_cast< Knob<std::string>* >(knobs[j].get());

String_Knob* isStringKnob = dynamic_cast<String_Knob*>(isString);

if (!isString || isStringKnob || knobs[j] == project->getEnvVarKnob()) {

continue;

}

std::string filepath = isString->getValue();

if (filepath.size() >= (oldName.size() + 2) &&

filepath[0] == '[' &&

filepath[oldName.size() + 1] == ']' &&

filepath.substr(1,oldName.size()) == oldName) {

filepath.replace(1, oldName.size(), newName);

isString->setValue(filepath, 0);

}

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->fixPathName(oldName, newName);

}

}

}

}

bool

NodeCollection::checkIfNodeNameExists(const std::string & n,const Natron::Node* caller) const

{

QMutexLocker k(&_imp->nodesMutex);

for (NodeList::const_iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {

if ( (it->get() != caller) && ( (*it)->getScriptName_mt_safe() == n ) ) {

return true;

}

}

return false;

}

static void recomputeFrameRangeForAllReadersInternal(NodeCollection* group, int* firstFrame,int* lastFrame, bool setFrameRange)

{

NodeList nodes = group->getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

if ((*it)->isActivated()) {

if ((*it)->getLiveInstance()->isReader()) {

double thisFirst,thislast;

(*it)->getLiveInstance()->getFrameRange_public((*it)->getHashValue(), &thisFirst, &thislast);

if (thisFirst != INT_MIN) {

*firstFrame = setFrameRange ? thisFirst : std::min(*firstFrame, (int)thisFirst);

}

if (thislast != INT_MAX) {

*lastFrame = setFrameRange ? thislast : std::max(*lastFrame, (int)thislast);

}

} else {

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

recomputeFrameRangeForAllReadersInternal(isGrp, firstFrame, lastFrame, false);

}

}

}

}

}

void

NodeCollection::recomputeFrameRangeForAllReaders(int* firstFrame,int* lastFrame)

{

recomputeFrameRangeForAllReadersInternal(this,firstFrame,lastFrame,true);

}

void

NodeCollection::forceGetClipPreferencesOnAllTrees()

{

NodeList nodes;

getNodes_recursive(nodes);

std::list<Project::NodesTree> trees;

Project::extractTreesFromNodes(nodes, trees);

std::list<Natron::Node*> markedNodes;

for (std::list<Project::NodesTree>::iterator it = trees.begin(); it != trees.end(); ++it) {

it->output.node->restoreClipPreferencesRecursive(markedNodes);

}

}

void

NodeCollection::setParallelRenderArgs(int time,

int view,

bool isRenderUserInteraction,

bool isSequential,

bool canAbort,

U64 renderAge,

Natron::OutputEffectInstance* renderRequester,

int textureIndex,

const TimeLine* timeline,

const boost::shared_ptr<Natron::Node>& activeRotoPaintNode,

bool isAnalysis,

bool draftMode,

bool viewerProgressReportEnabled,

const boost::shared_ptr<RenderStats>& stats)

{

bool doNanHandling = appPTR->getCurrentSettings()->isNaNHandlingEnabled();

NodeList nodes = getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

assert(*it);

Natron::EffectInstance* liveInstance = (*it)->getLiveInstance();

assert(liveInstance);

U64 rotoAge = (*it)->getRotoAge();

bool duringPaintStrokeCreation = activeRotoPaintNode && (*it)->isDuringPaintStrokeCreation();

Natron::RenderSafetyEnum safety = (*it)->getCurrentRenderThreadSafety();

NodeList rotoPaintNodes;

boost::shared_ptr<RotoContext> roto = (*it)->getRotoContext();

if (roto) {

roto->getRotoPaintTreeNodes(&rotoPaintNodes);

}

liveInstance->setParallelRenderArgsTLS(time, view, isRenderUserInteraction, isSequential, canAbort, (*it)->getHashValue(),

rotoAge,renderAge,renderRequester,textureIndex, timeline, isAnalysis,duringPaintStrokeCreation, rotoPaintNodes, safety, doNanHandling, draftMode, viewerProgressReportEnabled, stats);

for (NodeList::iterator it2 = rotoPaintNodes.begin(); it2 != rotoPaintNodes.end(); ++it2) {

(*it2)->getLiveInstance()->setParallelRenderArgsTLS(time, view, isRenderUserInteraction, isSequential, canAbort, (*it2)->getHashValue(), (*it2)->getRotoAge(), renderAge, renderRequester, textureIndex, timeline, isAnalysis, activeRotoPaintNode && (*it2)->isDuringPaintStrokeCreation(), NodeList(), (*it2)->getCurrentRenderThreadSafety(), doNanHandling, draftMode, viewerProgressReportEnabled,stats);

}

if ((*it)->isMultiInstance()) {

///If the node has children, set the thread-local storage on them too, even if they do not render, it can be useful for expressions

///on parameters.

NodeList children;

(*it)->getChildrenMultiInstance(&children);

for (NodeList::iterator it2 = children.begin(); it2!=children.end(); ++it2) {

assert(*it2);

Natron::EffectInstance* childLiveInstance = (*it2)->getLiveInstance();

assert(childLiveInstance);

Natron::RenderSafetyEnum childSafety = (*it2)->getCurrentRenderThreadSafety();

childLiveInstance->setParallelRenderArgsTLS(time, view, isRenderUserInteraction, isSequential, canAbort, (*it2)->getHashValue(),0, renderAge,renderRequester, textureIndex, timeline, isAnalysis, false, std::list<boost::shared_ptr<Natron::Node> >(), childSafety, doNanHandling, draftMode, viewerProgressReportEnabled,stats);

}

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->setParallelRenderArgs(time, view, isRenderUserInteraction, isSequential, canAbort, renderAge, renderRequester, textureIndex, timeline, activeRotoPaintNode, isAnalysis, draftMode, viewerProgressReportEnabled,stats);

}

}

}

void

NodeCollection::invalidateParallelRenderArgs()

{

NodeList nodes = getNodes();

for (NodeList::iterator it = nodes.begin(); it != nodes.end(); ++it) {

(*it)->getLiveInstance()->invalidateParallelRenderArgsTLS();

if ((*it)->isMultiInstance()) {

///If the node has children, set the thread-local storage on them too, even if they do not render, it can be useful for expressions

///on parameters.

NodeList children;

(*it)->getChildrenMultiInstance(&children);

for (NodeList::iterator it2 = children.begin(); it2!=children.end(); ++it2) {

(*it2)->getLiveInstance()->invalidateParallelRenderArgsTLS();

}

}

NodeList rotoPaintNodes;

boost::shared_ptr<RotoContext> roto = (*it)->getRotoContext();

if (roto) {

roto->getRotoPaintTreeNodes(&rotoPaintNodes);

}

for (NodeList::iterator it2 = rotoPaintNodes.begin(); it2 != rotoPaintNodes.end(); ++it2) {

(*it2)->getLiveInstance()->invalidateParallelRenderArgsTLS();

}

NodeGroup* isGrp = dynamic_cast<NodeGroup*>((*it)->getLiveInstance());

if (isGrp) {

isGrp->invalidateParallelRenderArgs();

}

}

}