598 lines
15 KiB
C++
598 lines
15 KiB
C++
|
|
|
|
#include "tmacrofx.h"
|
|
|
|
// TnzBase includes
|
|
#include "tparamcontainer.h"
|
|
#include "tfxattributes.h"
|
|
|
|
// TnzCore includes
|
|
#include "tstream.h"
|
|
|
|
//--------------------------------------------------
|
|
|
|
namespace
|
|
{
|
|
|
|
class MatchesFx
|
|
{
|
|
public:
|
|
MatchesFx(const TFxP &fx) : m_fx(fx) {}
|
|
|
|
bool operator()(const TFxP &fx)
|
|
{
|
|
return m_fx.getPointer() == fx.getPointer();
|
|
}
|
|
|
|
TFxP m_fx;
|
|
};
|
|
|
|
//--------------------------------------------------
|
|
|
|
void pushParents(const TFxP &root, std::vector<TFxP> &fxs, const std::vector<TFxP> &selectedFxs)
|
|
{
|
|
int i, count = root->getInputPortCount();
|
|
if (count == 0) {
|
|
std::vector<TFxP>::const_iterator found = std::find_if(fxs.begin(), fxs.end(), MatchesFx(root));
|
|
if (found == fxs.end())
|
|
fxs.push_back(root);
|
|
return;
|
|
}
|
|
for (i = 0; i < count; i++) {
|
|
TFxP inutFx = root->getInputPort(i)->getFx();
|
|
std::vector<TFxP>::const_iterator found = std::find_if(selectedFxs.begin(), selectedFxs.end(), MatchesFx(inutFx));
|
|
if (found != selectedFxs.end())
|
|
pushParents(inutFx, fxs, selectedFxs);
|
|
}
|
|
std::vector<TFxP>::const_iterator found = std::find_if(fxs.begin(), fxs.end(), MatchesFx(root));
|
|
if (found == fxs.end())
|
|
fxs.push_back(root);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
std::vector<TFxP> sortFxs(const std::vector<TFxP> &fxs)
|
|
{
|
|
std::vector<TFxP> app;
|
|
std::vector<TFxP> roots;
|
|
//find fxs that could be in back of the vector.
|
|
int i;
|
|
for (i = 0; i < (int)fxs.size(); i++) {
|
|
TFxP fx = fxs[i];
|
|
int j, count = (int)fx->getOutputConnectionCount();
|
|
if (count == 0) {
|
|
roots.push_back(fx);
|
|
continue;
|
|
}
|
|
for (j = 0; j < count; j++) {
|
|
TFxP connectedFx = fx->getOutputConnection(j)->getOwnerFx();
|
|
std::vector<TFxP>::const_iterator found = std::find_if(fxs.begin(), fxs.end(), MatchesFx(connectedFx));
|
|
if (found == fxs.end()) {
|
|
roots.push_back(fx);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < (int)roots.size(); i++)
|
|
pushParents(roots[i], app, fxs);
|
|
assert(fxs.size() == app.size());
|
|
return app;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
// raccoglie tutti i parametri dai vari TFx e li assegna anche alla macro
|
|
void collectParams(TMacroFx *macroFx)
|
|
{
|
|
int k;
|
|
for (k = 0; k < (int)macroFx->m_fxs.size(); k++) {
|
|
TFxP fx = macroFx->m_fxs[k];
|
|
int j;
|
|
for (j = 0; j < fx->getParams()->getParamCount(); j++)
|
|
macroFx->getParams()->add(fx->getParams()->getParamVar(j)->clone());
|
|
}
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
//--------------------------------------------------
|
|
|
|
bool TMacroFx::analyze(const vector<TFxP> &fxs,
|
|
TFxP &root,
|
|
vector<TFxP> &roots,
|
|
vector<TFxP> &leafs)
|
|
{
|
|
if (fxs.size() == 1)
|
|
return false;
|
|
else {
|
|
leafs.clear();
|
|
roots.clear();
|
|
std::vector<TFxP>::const_iterator it = fxs.begin();
|
|
for (; it != fxs.end(); ++it) {
|
|
TFxP fx = *it;
|
|
int inputInternalConnection = 0;
|
|
int inputExternalConnection = 0;
|
|
int outputInternalConnection = 0;
|
|
int outputExternalConnection = 0;
|
|
|
|
int i;
|
|
|
|
// calcola se ci sono connessioni in input dall'esterno
|
|
// verso l'interno e/o internamente a orderedFxs
|
|
int inputPortCount = fx->getInputPortCount();
|
|
for (i = 0; i < inputPortCount; ++i) {
|
|
TFxPort *inputPort = fx->getInputPort(i);
|
|
TFx *inputPortFx = inputPort->getFx();
|
|
if (inputPortFx) {
|
|
if (std::find_if(fxs.begin(), fxs.end(), MatchesFx(inputPortFx)) != fxs.end())
|
|
++inputInternalConnection;
|
|
else
|
|
++inputExternalConnection;
|
|
}
|
|
}
|
|
|
|
// calcola se ci sono connessioni in output dall'interno
|
|
// verso l'esterno e/o internamente a orderedFxs
|
|
int outputPortCount = fx->getOutputConnectionCount();
|
|
for (i = 0; i < outputPortCount; ++i) {
|
|
TFxPort *outputPort = fx->getOutputConnection(i);
|
|
TFx *outputFx = outputPort->getOwnerFx();
|
|
if (outputFx) {
|
|
if (std::find_if(fxs.begin(), fxs.end(), MatchesFx(outputFx)) != fxs.end())
|
|
++outputInternalConnection;
|
|
else
|
|
++outputExternalConnection;
|
|
}
|
|
}
|
|
|
|
// se fx e' una radice
|
|
if ((outputExternalConnection > 0) ||
|
|
(outputExternalConnection == 0 && outputInternalConnection == 0)) {
|
|
root = fx;
|
|
roots.push_back(fx);
|
|
}
|
|
|
|
// se fx e' una foglia
|
|
if (inputExternalConnection > 0 || fx->getInputPortCount() == 0 ||
|
|
(inputExternalConnection == 0 && inputInternalConnection < fx->getInputPortCount())) {
|
|
leafs.push_back(fx);
|
|
}
|
|
}
|
|
|
|
if (roots.size() != 1)
|
|
return false;
|
|
else {
|
|
if (leafs.size() == 0)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
bool TMacroFx::analyze(const vector<TFxP> &fxs)
|
|
{
|
|
TFxP root = 0;
|
|
std::vector<TFxP> leafs;
|
|
std::vector<TFxP> roots;
|
|
return analyze(fxs, root, roots, leafs);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
bool TMacroFx::isaLeaf(TFx *fx) const
|
|
{
|
|
int count = fx->getInputPortCount();
|
|
if (count == 0)
|
|
return true;
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
TFxPort *port = fx->getInputPort(i);
|
|
TFx *inputFx = port->getFx();
|
|
if (inputFx) {
|
|
if (std::find_if(m_fxs.begin(), m_fxs.end(), MatchesFx(inputFx)) == m_fxs.end()) {
|
|
// il nodo di input non appartiene al macroFx
|
|
return true;
|
|
}
|
|
} else {
|
|
// la porta di input non e' connessa
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// tutte le porte di input sono connesse verso nodi appartenenti al macroFx
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TMacroFx::TMacroFx() : m_isEditing(false) {}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TMacroFx::~TMacroFx() {}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TFx *TMacroFx::clone(bool recursive) const
|
|
{
|
|
int n = m_fxs.size();
|
|
vector<TFxP> clones(n);
|
|
std::map<TFx *, int> table;
|
|
std::map<TFx *, int>::iterator it;
|
|
int i, rootIndex = -1;
|
|
// nodi
|
|
for (i = 0; i < n; ++i) {
|
|
TFx *fx = m_fxs[i].getPointer();
|
|
assert(fx);
|
|
clones[i] = fx->clone(false);
|
|
assert(table.count(fx) == 0);
|
|
table[fx] = i;
|
|
if (fx == m_root.getPointer())
|
|
rootIndex = i;
|
|
TFx *linkedFx = fx->getLinkedFx();
|
|
if (linkedFx && table.find(linkedFx) != table.end())
|
|
clones[i]->linkParams(clones[table[linkedFx]].getPointer());
|
|
}
|
|
assert(rootIndex >= 0);
|
|
// connessioni
|
|
for (i = 0; i < n; i++) {
|
|
TFx *fx = m_fxs[i].getPointer();
|
|
for (int j = 0; j < fx->getInputPortCount(); j++) {
|
|
TFxPort *port = fx->getInputPort(j);
|
|
TFx *inputFx = port->getFx();
|
|
if (!inputFx)
|
|
continue;
|
|
it = table.find(inputFx);
|
|
if (it == table.end()) {
|
|
// il j-esimo input di fx e' esterno alla macro
|
|
if (recursive)
|
|
clones[i]->connect(fx->getInputPortName(j), inputFx->clone(true));
|
|
} else {
|
|
// il j-esimo input di fx e' interno alla macro
|
|
clones[i]->connect(fx->getInputPortName(j), clones[it->second].getPointer());
|
|
}
|
|
}
|
|
}
|
|
|
|
//TFx *rootClone =
|
|
// const_cast<TMacroFx*>(this)->
|
|
// clone(m_root.getPointer(), recursive, visited, clones);
|
|
|
|
TMacroFx *clone = TMacroFx::create(clones);
|
|
clone->setName(getName());
|
|
clone->setFxId(getFxId());
|
|
|
|
//Copy the index of the passive cache manager.
|
|
clone->getAttributes()->passiveCacheDataIdx() = getAttributes()->passiveCacheDataIdx();
|
|
|
|
assert(clone->getRoot() == clones[rootIndex].getPointer());
|
|
|
|
return clone;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
bool TMacroFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
|
|
{
|
|
return m_root->doGetBBox(frame, bBox, info);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::doDryCompute(TRectD &rect,
|
|
double frame,
|
|
const TRenderSettings &info)
|
|
{
|
|
assert(m_root);
|
|
m_root->dryCompute(rect, frame, info);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
|
|
{
|
|
assert(m_root);
|
|
m_root->compute(tile, frame, ri);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TFxTimeRegion TMacroFx::getTimeRegion() const
|
|
{
|
|
return m_root->getTimeRegion();
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
string TMacroFx::getPluginId() const
|
|
{
|
|
return "Base";
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::setRoot(TFx *root)
|
|
{
|
|
m_root = root;
|
|
// TFx::m_imp->m_outputPort = root->m_imp->m_outputPort;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TFx *TMacroFx::getRoot() const
|
|
{
|
|
return m_root.getPointer();
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TFx *TMacroFx::getFxById(const wstring &id) const
|
|
{
|
|
int i;
|
|
for (i = 0; i < (int)m_fxs.size(); i++) {
|
|
TFx *fx = m_fxs[i].getPointer();
|
|
if (fx->getFxId() == id)
|
|
return fx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
const vector<TFxP> &TMacroFx::getFxs() const
|
|
{
|
|
return m_fxs;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
string TMacroFx::getMacroFxType() const
|
|
{
|
|
string name = getFxType() + "(";
|
|
for (int i = 0; i < (int)m_fxs.size(); i++) {
|
|
if (i > 0)
|
|
name += ",";
|
|
if (TMacroFx *childMacro = dynamic_cast<TMacroFx *>(m_fxs[i].getPointer()))
|
|
name += childMacro->getMacroFxType();
|
|
else
|
|
name += m_fxs[i]->getFxType();
|
|
}
|
|
return name + ")";
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
TMacroFx *TMacroFx::create(const vector<TFxP> &fxs)
|
|
{
|
|
std::vector<TFxP> leafs;
|
|
std::vector<TFxP> roots;
|
|
TFxP root = 0;
|
|
|
|
vector<TFxP> orederedFxs = sortFxs(fxs);
|
|
|
|
// verifica che gli effetti selezionati siano idonei ad essere raccolti
|
|
// in una macro. Ci deve essere un solo nodo terminale
|
|
// (roots.size()==1, roots[0] == root) e uno o piu' nodi di ingresso
|
|
// (assert leafs.size()>0)
|
|
if (!analyze(orederedFxs, root, roots, leafs))
|
|
return 0;
|
|
|
|
// -----------------------------
|
|
|
|
TMacroFx *macroFx = new TMacroFx;
|
|
|
|
// tutti i nodi vengono spostati (e non copiati) nella macro stessa
|
|
std::vector<TFxP>::const_iterator it = orederedFxs.begin();
|
|
for (; it != orederedFxs.end(); ++it)
|
|
macroFx->m_fxs.push_back(*it);
|
|
|
|
// i nodi di ingresso vengono messi in collegamento con le
|
|
// porte di ingresso della macro
|
|
for (int i = 0; i < (int)leafs.size(); i++) {
|
|
TFxP fx = leafs[i];
|
|
int k = 0;
|
|
int count = fx->getInputPortCount();
|
|
for (; k < count; k++) {
|
|
TFxPort *port = fx->getInputPort(k);
|
|
string portName = fx->getInputPortName(k);
|
|
string fxId = toString(fx->getFxId());
|
|
portName += "_" + toString(macroFx->getInputPortCount()) + "_" + fxId;
|
|
TFx *portFx = port->getFx();
|
|
if (portFx) {
|
|
// se la porta k-esima del nodo di ingresso i-esimo e' collegata
|
|
// ad un effetto, la porta viene inserita solo se l'effetto non fa
|
|
// gia' parte della macro
|
|
if (std::find_if(orederedFxs.begin(), orederedFxs.end(), MatchesFx(portFx)) == orederedFxs.end())
|
|
macroFx->addInputPort(portName, *port);
|
|
} else
|
|
macroFx->addInputPort(portName, *port);
|
|
}
|
|
}
|
|
|
|
// le porte di uscita di root diventano le porte di uscita della macro
|
|
int count = root->getOutputConnectionCount();
|
|
int k = count - 1;
|
|
for (; k >= 0; --k) {
|
|
TFxPort *port = root->getOutputConnection(k);
|
|
port->setFx(macroFx);
|
|
}
|
|
|
|
macroFx->setRoot(root.getPointer());
|
|
|
|
// tutti i parametri delle funzioni figlie diventano parametri della macro
|
|
collectParams(macroFx);
|
|
return macroFx;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
bool TMacroFx::canHandle(const TRenderSettings &info, double frame)
|
|
{
|
|
return m_root->canHandle(info, frame);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
string TMacroFx::getAlias(double frame, const TRenderSettings &info) const
|
|
{
|
|
string alias = getFxType();
|
|
alias += "[";
|
|
|
|
// alias degli effetti connessi alle porte di input separati da virgole
|
|
// una porta non connessa da luogo a un alias vuoto (stringa vuota)
|
|
int i;
|
|
for (i = 0; i < getInputPortCount(); i++) {
|
|
TFxPort *port = getInputPort(i);
|
|
if (port->isConnected()) {
|
|
TRasterFxP ifx = port->getFx();
|
|
assert(ifx);
|
|
alias += ifx->getAlias(frame, info);
|
|
}
|
|
alias += ",";
|
|
}
|
|
|
|
// alias dei valori dei parametri dell'effetto al frame dato
|
|
for (int j = 0; j < (int)m_fxs.size(); j++) {
|
|
alias += (j == 0) ? "(" : ",(";
|
|
for (i = 0; i < m_fxs[j]->getParams()->getParamCount(); i++) {
|
|
if (i > 0)
|
|
alias += ",";
|
|
TParam *param = m_fxs[j]->getParams()->getParam(i);
|
|
alias += param->getName() + "=" + param->getValueAlias(frame, 2);
|
|
}
|
|
alias += ")";
|
|
}
|
|
|
|
alias += "]";
|
|
return alias;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::compatibilityTranslatePort(int major, int minor, std::string &portName)
|
|
{
|
|
// Reroute translation to the actual fx associated to the port
|
|
const std::string &fxId = portName.substr(portName.find_last_of('_') + 1,
|
|
std::string::npos);
|
|
|
|
if (TFx *fx = getFxById(toWideString(fxId))) {
|
|
size_t opnEnd = portName.find_first_of('_');
|
|
|
|
std::string originalPortName = portName.substr(0, opnEnd);
|
|
fx->compatibilityTranslatePort(major, minor, originalPortName);
|
|
|
|
portName.replace(0, opnEnd, originalPortName);
|
|
}
|
|
|
|
// Seems that at a certain point, the port name got extended...
|
|
if (VersionNumber(major, minor) == VersionNumber(1, 16)) {
|
|
for (int i = 0; i < getInputPortCount(); ++i) {
|
|
const std::string &name = getInputPortName(i);
|
|
if (name.find(portName) != string::npos) {
|
|
portName = name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::loadData(TIStream &is)
|
|
{
|
|
VersionNumber tnzVersion = is.getVersion();
|
|
string tagName;
|
|
while (is.openChild(tagName)) {
|
|
if (tagName == "root") {
|
|
TPersist *p = 0;
|
|
is >> p;
|
|
m_root = dynamic_cast<TFx *>(p);
|
|
} else if (tagName == "nodes") {
|
|
while (!is.eos()) {
|
|
TPersist *p = 0;
|
|
is >> p;
|
|
|
|
// NOTE: In current implementation p is sharedly owned by is - it's automatically
|
|
// released upon stream destruction if the below assignment fails
|
|
|
|
if (TFx *fx = dynamic_cast<TFx *>(p)) {
|
|
m_fxs.push_back(fx);
|
|
}
|
|
}
|
|
} else if (tagName == "ports") {
|
|
int i = 0;
|
|
while (is.matchTag(tagName)) {
|
|
if (tagName == "port") {
|
|
string name = is.getTagAttribute("name");
|
|
if (tnzVersion < VersionNumber(1, 16) && name != "") {
|
|
TRasterFxPort *port = new TRasterFxPort();
|
|
addInputPort(name, *port);
|
|
} else {
|
|
name = is.getTagAttribute("name_inFx");
|
|
if (tnzVersion < VersionNumber(1, 17) && tnzVersion != VersionNumber(0, 0))
|
|
name.insert(name.find("_"), "_" + toString(i));
|
|
|
|
compatibilityTranslatePort(tnzVersion.first, tnzVersion.second, name);
|
|
|
|
string inPortName = name;
|
|
inPortName.erase(inPortName.find("_"), inPortName.size() - 1);
|
|
|
|
string inFxId = name;
|
|
inFxId.erase(0, inFxId.find_last_of("_") + 1);
|
|
|
|
for (int i = 0; i < (int)m_fxs.size(); i++) {
|
|
wstring fxId = m_fxs[i]->getFxId();
|
|
if (fxId == toWideString(inFxId)) {
|
|
if (TFxPort *port = m_fxs[i]->getInputPort(inPortName))
|
|
addInputPort(name, *port);
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
} else
|
|
throw TException("unexpected tag " + tagName);
|
|
}
|
|
} else if (tagName == "super") {
|
|
TRasterFx::loadData(is);
|
|
} else
|
|
throw TException("unexpected tag " + tagName);
|
|
is.closeChild();
|
|
}
|
|
collectParams(this);
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
|
|
void TMacroFx::saveData(TOStream &os)
|
|
{
|
|
int i;
|
|
os.openChild("root");
|
|
TPersist *p = m_root.getPointer();
|
|
os << p;
|
|
os.closeChild();
|
|
os.openChild("nodes");
|
|
for (i = 0; i < (int)m_fxs.size(); i++) {
|
|
TFxP fx = m_fxs[i];
|
|
TPersist *p = fx.getPointer();
|
|
os << p;
|
|
}
|
|
os.closeChild();
|
|
os.openChild("ports");
|
|
for (i = 0; i < getInputPortCount(); i++) {
|
|
std::string portName = getInputPortName(i);
|
|
std::map<string, string> attr;
|
|
attr["name_inFx"] = portName;
|
|
os.openCloseChild("port", attr);
|
|
}
|
|
os.closeChild();
|
|
os.openChild("super");
|
|
TRasterFx::saveData(os);
|
|
os.closeChild();
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
FX_IDENTIFIER(TMacroFx, "macroFx")
|
|
//FX_IDENTIFIER_IS_HIDDEN(TMacroFx, "macroFx")
|