razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases 1 Wiki Activity

Merge pull request #1223 from manongjohn/render_keys_only

Browse source 
Render Key Drawings Only & Render To Folders
This commit is contained in:
manongjohn 2023-10-02 07:49:00 -04:00 committed by GitHub
parent f8cb349fa3 ab2b67c21e
commit 6f59eeeb92
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 329 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
toonz/sources/include/tfarmtask.h
View file

@ -97,6 +97,9 @@ public:
int m_chunkSize; //!< Sub-tasks size
int m_multimedia;
bool m_renderKeysOnly;
bool m_renderToFolders;
int m_threadsIndex;
int m_maxTileSizeIndex;
@ -118,9 +121,9 @@ public:
const QString &user, const QString &host, int stepCount,
int priority, const TFilePath &taskFilePath,
const TFilePath &outputPath, int from, int to, int step, int shrink,
int multimedia, int chunksize, int threadsIndex,
int maxTileSizeIndex, OverwriteBehavior overwrite,
bool onlyvisible);
int multimedia, bool renderKeysOnly, bool renderToFolders,
int chunksize, int threadsIndex, int maxTileSizeIndex,
OverwriteBehavior overwrite, bool onlyvisible);
virtual ~TFarmTask() { delete m_dependencies; }
@ -155,7 +158,8 @@ public:
const QString &host, int stepCount, int priority,
const TFilePath &taskFilePath, const TFilePath &outputPath,
int from, int to, int step, int shrink, int multimedia,
int chunksize, int threadsIndex, int maxTileSizeIndex);
bool renderKeysOnly, bool renderToFolders, int chunksize,
int threadsIndex, int maxTileSizeIndex);
TFarmTaskGroup(const QString &id, const QString &name, const QString &user,
const QString &host, int stepCount, int priority,

5
toonz/sources/include/toonz/multimediarenderer.h
View file

@ -67,7 +67,8 @@ public:
//----------------------------------------------------------------
MultimediaRenderer(ToonzScene *scene, const TFilePath &moviePath,
int multimediaMode, int threadCount = 1,
int multimediaMode, bool renderKeysOnly,
bool renderToFolders, int threadCount = 1,
bool cacheResults = true);
~MultimediaRenderer();
@ -84,6 +85,8 @@ public:
enum { COLUMNS = 1, LAYERS = 2 };
int getMultimediaMode() const;
bool isRenderKeysOnly() const;
bool isRenderToFolders() const;
//! Returns the currently active TRenderer.
TRenderer *getTRenderer();

10
toonz/sources/include/toutputproperties.h
View file

@ -86,6 +86,8 @@ private:
int m_offset, m_step;
int m_multimediaRendering;
bool m_renderKeysOnly;
bool m_renderToFolders;
int m_maxTileSizeIndex;
int m_threadIndex;
@ -211,6 +213,14 @@ Insert in \b v all extension in format properties of output settings.
void setMultimediaRendering(int mode) { m_multimediaRendering = mode; }
int getMultimediaRendering() const { return m_multimediaRendering; }
void setRenderKeysOnly(bool keysOnly) { m_renderKeysOnly = keysOnly; }
bool isRenderKeysOnly() const { return m_renderKeysOnly; }
void setRenderToFolders(bool renderToFolders) {
m_renderToFolders = renderToFolders;
}
bool isRenderToFolders() const { return m_renderToFolders; }
/*! Sets the granularity of raster allocations for rendering processes.
The specified value refers to an index associated with const values,
spanning from 0 (no bound, ie giant rasters are allowed) to 3 (highly

14
toonz/sources/tcomposer/tcomposer.cpp
View file

@ -486,6 +486,8 @@ static std::pair<int, int> generateMovie(ToonzScene *scene, const TFilePath &fp,
double stepd = step * timeStretchFactor;
int multimediaRender = outputSettings.getMultimediaRendering();
bool renderKeysOnly = outputSettings.isRenderKeysOnly();
bool renderToFolders = outputSettings.isRenderToFolders();
//---------------------------------------------------------
// Multimedia render
@ -493,6 +495,7 @@ static std::pair<int, int> generateMovie(ToonzScene *scene, const TFilePath &fp,
if (multimediaRender) {
MultimediaRenderer multimediaRenderer(scene, fp, multimediaRender,
renderKeysOnly, renderToFolders,
threadCount);
TRenderSettings rs = outputSettings.getRenderSettings();
rs.m_maxTileSize = maxTileSize;
@ -608,6 +611,8 @@ int main(int argc, char *argv[]) {
IntQualifier stepOpt("-step n", "Step");
IntQualifier shrinkOpt("-shrink n", "Shrink");
IntQualifier multimedia("-multimedia n", "Multimedia rendering mode");
IntQualifier renderKeysOnly("-renderkeysonly n", "Render keys drawings only");
IntQualifier renderToFolders("-rendertofolders n", "Render To Folders");
StringQualifier farmData("-farm data", "TFarm Controller");
StringQualifier idq("-id n", "id");
StringQualifier nthreads("-nthreads n", "Number of rendering threads");
@ -615,7 +620,8 @@ int main(int argc, char *argv[]) {
"Enable tile rendering of max n MB per tile");
StringQualifier tmsg("-tmsg val", "only internal use");
usageLine = srcName + dstName + range + stepOpt + shrinkOpt + multimedia +
farmData + idq + nthreads + tileSize + tmsg;
renderKeysOnly + renderToFolders + farmData + idq + nthreads +
tileSize + tmsg;
// system path qualifiers
std::map<QString, std::unique_ptr<TCli::QualifierT<TFilePath>>>
@ -927,6 +933,12 @@ int main(int argc, char *argv[]) {
if (multimedia.isSelected())
scene->getProperties()->getOutputProperties()->setMultimediaRendering(
multimedia.getValue());
if (renderKeysOnly.isSelected())
scene->getProperties()->getOutputProperties()->setRenderKeysOnly(
renderKeysOnly.getValue());
if (renderToFolders.isSelected())
scene->getProperties()->getOutputProperties()->setRenderToFolders(
renderToFolders.getValue());
// Retrieve Thread count
const int procCount = TSystem::getProcessorCount();

5
toonz/sources/toonz/batches.cpp
View file

@ -360,6 +360,8 @@ void BatchesController::addComposerTask(const TFilePath &_taskFilePath) {
int shrink = rs.m_shrinkX;
int multimedia = out.getMultimediaRendering();
bool renderKeysOnly = out.isRenderKeysOnly();
bool renderToFolders = out.isRenderToFolders();
int threadsIndex = out.getThreadIndex();
int maxTileSizeIndex = out.getMaxTileSizeIndex();
@ -385,7 +387,8 @@ void BatchesController::addComposerTask(const TFilePath &_taskFilePath) {
TFarmTaskGroup *taskGroup = new TFarmTaskGroup(
id, name, TSystem::getUserName(), TSystem::getHostName(), sceneFrameCount,
50, taskFilePath, outputPath, r0, r1, step, shrink, multimedia,
taskChunkSize, threadsIndex, maxTileSizeIndex);
renderKeysOnly, renderToFolders, taskChunkSize, threadsIndex,
maxTileSizeIndex);
try {
BatchesController::instance()->addTask(id, taskGroup);

47
toonz/sources/toonz/outputsettingspopup.cpp
View file

@ -938,6 +938,12 @@ QFrame *OutputSettingsPopup::createMoreSettingsBox() {
m_multimediaOm->installEventFilter(this);
m_stereoShift->setEnabled(false);
m_renderKeysOnly = new DVGui::CheckBox(tr("Render Key Drawings Only"), this);
m_renderKeysOnly->setEnabled(false);
m_renderToFolders = new DVGui::CheckBox(tr("Render To Folders"), this);
m_renderToFolders->setEnabled(false);
//-----
QGridLayout *lay = new QGridLayout();
@ -978,11 +984,15 @@ QFrame *OutputSettingsPopup::createMoreSettingsBox() {
Qt::AlignRight | Qt::AlignVCenter);
lay->addWidget(m_multimediaOm, 5, 1, 1, 3,
Qt::AlignLeft | Qt::AlignVCenter);
lay->addWidget(m_renderKeysOnly, 6, 1, 1, 3,
Qt::AlignLeft | Qt::AlignVCenter);
lay->addWidget(m_renderToFolders, 7, 1, 1, 3,
Qt::AlignLeft | Qt::AlignVCenter);
lay->addWidget(m_doStereoscopy, 6, 0);
lay->addWidget(new QLabel(tr("Camera Shift:")), 6, 1, 1, 2,
lay->addWidget(m_doStereoscopy, 8, 0);
lay->addWidget(new QLabel(tr("Camera Shift:")), 8, 1, 1, 2,
Qt::AlignRight | Qt::AlignVCenter);
lay->addWidget(m_stereoShift, 6, 3, Qt::AlignLeft | Qt::AlignVCenter);
lay->addWidget(m_stereoShift, 8, 3, Qt::AlignLeft | Qt::AlignVCenter);
}
lay->setColumnStretch(4, 1);
@ -1013,6 +1023,10 @@ QFrame *OutputSettingsPopup::createMoreSettingsBox() {
SLOT(onStereoChecked(int)));
ret = ret && connect(m_stereoShift, SIGNAL(editingFinished()),
SLOT(onStereoChanged()));
ret = ret && connect(m_renderKeysOnly, SIGNAL(stateChanged(int)), this,
SLOT(onRenderKeysOnlyChecked(int)));
ret = ret && connect(m_renderToFolders, SIGNAL(stateChanged(int)), this,
SLOT(onRenderToFoldersChecked(int)));
assert(ret);
return moreSettingsBox;
}
@ -1165,6 +1179,10 @@ void OutputSettingsPopup::updateField() {
m_fileFormat->setCurrentIndex(
m_fileFormat->findText(QString::fromStdString(path.getType())));
m_multimediaOm->setCurrentIndex(prop->getMultimediaRendering());
m_renderKeysOnly->setChecked(prop->isRenderKeysOnly());
m_renderToFolders->setChecked(prop->isRenderToFolders());
m_renderKeysOnly->setEnabled(prop->getMultimediaRendering());
m_renderToFolders->setEnabled(prop->getMultimediaRendering());
}
// Refresh format if allow-multithread was toggled
@ -1831,6 +1849,29 @@ void OutputSettingsPopup::onMultimediaChanged(int state) {
if (prop->getMultimediaRendering() == state) return;
prop->setMultimediaRendering(state);
m_renderKeysOnly->setEnabled(state);
m_renderToFolders->setEnabled(state);
TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}
//-----------------------------------------------------------------------------
void OutputSettingsPopup::onRenderKeysOnlyChecked(int) {
if (!getCurrentScene()) return;
TOutputProperties *prop = getProperties();
prop->setRenderKeysOnly(m_renderKeysOnly->isChecked());
TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}
//-----------------------------------------------------------------------------
void OutputSettingsPopup::onRenderToFoldersChecked(int) {
if (!getCurrentScene()) return;
TOutputProperties *prop = getProperties();
prop->setRenderToFolders(m_renderToFolders->isChecked());
TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

4
toonz/sources/toonz/outputsettingspopup.h
View file

@ -70,6 +70,8 @@ class OutputSettingsPopup : public DVGui::Dialog {
QComboBox *m_rasterGranularityOm;
QComboBox *m_threadsComboOm;
bool m_allowMT;
DVGui::CheckBox *m_renderKeysOnly;
DVGui::CheckBox *m_renderToFolders;
DVGui::DoubleLineEdit *m_frameRateFld;
QPushButton *m_fileFormatButton;
@ -131,6 +133,8 @@ protected slots:
void onApplyShrinkChecked(int state);
void onSubcameraChecked(int state);
void onMultimediaChanged(int mode);
void onRenderKeysOnlyChecked(int);
void onRenderToFoldersChecked(int);
void onThreadsComboChanged(int type);
void onRasterGranularityChanged(int type);
void onStereoChecked(int);

17
toonz/sources/toonz/rendercommand.cpp
View file

@ -162,6 +162,8 @@ class RenderCommand {
double m_timeStretchFactor;
int m_multimediaRender;
bool m_renderKeysOnly;
bool m_renderToFolders;
public:
RenderCommand()
@ -173,7 +175,9 @@ public:
, m_stepd(1)
, m_oldCameraRes(0, 0)
, m_timeStretchFactor(1)
, m_multimediaRender(0) {
, m_multimediaRender(0)
, m_renderKeysOnly(false)
, m_renderToFolders(false) {
setCommandHandler("MI_Render", this, &RenderCommand::onRender);
setCommandHandler("MI_SaveAndRender", this, &RenderCommand::onSaveAndRender);
setCommandHandler("MI_FastRender", this, &RenderCommand::onFastRender);
@ -238,6 +242,8 @@ sprop->getOutputProperties()->setRenderSettings(rso);*/
m_r = m_r0;
m_stepd = m_step;
m_multimediaRender = 0;
m_renderKeysOnly = false;
m_renderToFolders = false;
return true;
}
@ -302,6 +308,8 @@ sprop->getOutputProperties()->setRenderSettings(rso);*/
// Update the multimedia render switch
m_multimediaRender = outputSettings.getMultimediaRendering();
m_renderKeysOnly = outputSettings.isRenderKeysOnly();
m_renderToFolders = outputSettings.isRenderToFolders();
return true;
}
@ -731,8 +739,11 @@ void RenderCommand::multimediaRender() {
TRenderSettings rs = prop->getRenderSettings();
rs.m_maxTileSize = maxTileSizes[index];
MultimediaRenderer multimediaRenderer(
scene, m_fp, prop->getMultimediaRendering(), threadCount);
int multimedia = prop->getMultimediaRendering();
bool renderKeysOnly = prop->isRenderKeysOnly();
bool renderToFolders = prop->isRenderToFolders();
MultimediaRenderer multimediaRenderer(scene, m_fp, multimedia, renderKeysOnly,
renderToFolders, threadCount);
multimediaRenderer.setRenderSettings(rs);
TPointD cameraDpi = scene->getCurrentCamera()->getDpi();

66
toonz/sources/toonz/tasksviewer.cpp
View file

@ -340,6 +340,10 @@ void TaskSheet::update(TFarmTask *task) {
m_step->setText(QString::number(task->m_step));
m_shrink->setText(QString::number(task->m_shrink));
m_multimedia->setCurrentIndex(task->m_multimedia);
m_renderKeysOnly->setChecked(task->m_renderKeysOnly);
m_renderToFolders->setChecked(task->m_renderToFolders);
m_renderKeysOnly->setEnabled(m_multimedia->currentIndex());
m_renderToFolders->setEnabled(m_multimedia->currentIndex());
m_threadsCombo->setCurrentIndex(task->m_threadsIndex);
m_rasterGranularityCombo->setCurrentIndex(task->m_maxTileSizeIndex);
@ -445,9 +449,9 @@ void inline create(QLabel *&ret, QGridLayout *layout, QString name, int row,
//-----------------------------------------------------------------------------
void inline create(CheckBox *&ret, QGridLayout *layout, QString name, int row) {
void inline create(CheckBox *&ret, QGridLayout *layout, QString name, int row, int col = 0) {
ret = new CheckBox(name);
layout->addWidget(ret, row, 0, 1, 2, Qt::AlignLeft | Qt::AlignVCenter);
layout->addWidget(ret, row, col, 1, 2, Qt::AlignLeft | Qt::AlignVCenter);
}
//-----------------------------------------------------------------------------
@ -692,6 +696,53 @@ void TaskSheet::setMultimedia(int) {
taskGroup->getTask(i)->m_multimedia = taskGroup->m_multimedia;
}
m_renderKeysOnly->setEnabled(m_multimedia->currentIndex());
m_renderToFolders->setEnabled(m_multimedia->currentIndex());
m_viewer->startTimer();
}
//-----------------------------------------------------------------------------
void TaskSheet::setRenderKeysOnly(int) {
if (!m_task) return;
if (m_task->m_renderKeysOnly ==
(m_renderKeysOnly->checkState() == Qt::Checked))
return;
m_task->m_renderKeysOnly = (m_renderKeysOnly->checkState() == Qt::Checked);
m_commandLine->setText(m_task->getCommandLine());
BatchesController::instance()->setDirtyFlag(true);
// Update children tasks, if present.
TFarmTaskGroup *taskGroup = dynamic_cast<TFarmTaskGroup *>(m_task);
if (taskGroup) {
for (int i = 0; i < taskGroup->getTaskCount(); ++i)
taskGroup->getTask(i)->m_renderKeysOnly = taskGroup->m_renderKeysOnly;
}
m_viewer->startTimer();
}
//-----------------------------------------------------------------------------
void TaskSheet::setRenderToFolders(int) {
if (!m_task) return;
if (m_task->m_renderToFolders ==
(m_renderToFolders->checkState() == Qt::Checked))
return;
m_task->m_renderToFolders = (m_renderToFolders->checkState() == Qt::Checked);
m_commandLine->setText(m_task->getCommandLine());
BatchesController::instance()->setDirtyFlag(true);
// Update children tasks, if present.
TFarmTaskGroup *taskGroup = dynamic_cast<TFarmTaskGroup *>(m_task);
if (taskGroup) {
for (int i = 0; i < taskGroup->getTaskCount(); ++i)
taskGroup->getTask(i)->m_renderToFolders = taskGroup->m_renderToFolders;
}
m_viewer->startTimer();
}
@ -845,6 +896,10 @@ TaskSheet::TaskSheet(TasksViewer *owner) : QScrollArea(owner) {
::create(m_chunkSize, m_multimedia, layout1, tr("Frames per Chunk:"),
tr("Multimedia:"), Qt::AlignRight | Qt::AlignTop,
Qt::AlignLeft | Qt::AlignTop, row1++);
::create(m_renderKeysOnly, layout1, tr("Render Key Drawings Only"), row1++,
4);
::create(m_renderToFolders, layout1, tr("Render To Folders"), row1++,
4);
::create(m_from, m_to, layout1, tr("From:"), tr("To:"),
Qt::AlignRight | Qt::AlignTop, Qt::AlignRight | Qt::AlignTop,
row1++);
@ -858,6 +913,9 @@ TaskSheet::TaskSheet(TasksViewer *owner) : QScrollArea(owner) {
<< tr("Fx Schematic Terminal Nodes");
m_multimedia->addItems(multimediaTypes);
m_renderKeysOnly->setEnabled(false);
m_renderToFolders->setEnabled(false);
::create(m_threadsCombo, layout1, tr("Dedicated CPUs:"), row1++, 3);
QStringList threadsTypes;
threadsTypes << tr("Single") << tr("Half") << tr("All");
@ -953,6 +1011,10 @@ TaskSheet::TaskSheet(TasksViewer *owner) : QScrollArea(owner) {
ret = ret && connect(m_multimedia, SIGNAL(currentIndexChanged(int)), this,
SLOT(setMultimedia(int)));
ret = ret && connect(m_renderKeysOnly, SIGNAL(stateChanged(int)), this,
SLOT(setRenderKeysOnly(int)));
ret = ret && connect(m_renderToFolders, SIGNAL(stateChanged(int)), this,
SLOT(setRenderToFolders(int)));
ret = ret && connect(m_visible, SIGNAL(stateChanged(int)), this,
SLOT(setVisible(int)));

4
toonz/sources/toonz/tasksviewer.h
View file

@ -126,6 +126,8 @@ class TaskSheet final : public QScrollArea {
QListWidget *m_addedBox;
QListWidget *m_notAddedBox;
DVGui::CheckBox *m_visible;
DVGui::CheckBox *m_renderKeysOnly;
DVGui::CheckBox *m_renderToFolders;
QComboBox *m_overwrite;
QComboBox *m_multimedia;
QComboBox *m_threadsCombo;
@ -148,6 +150,8 @@ protected slots:
void setVisible(int);
void setOverwrite(int);
void setMultimedia(int);
void setRenderKeysOnly(int);
void setRenderToFolders(int);
void setThreadsCombo(int);
void setGranularityCombo(int);
void setPriority();

62
toonz/sources/toonzfarm/tfarm/tfarmtask.cpp
View file

@ -129,6 +129,8 @@ TFarmTask::TFarmTask(const QString &name)
, m_shrink(-1)
, m_chunkSize(-1)
, m_multimedia(0) // Full render, no multimedia
, m_renderKeysOnly(false)
, m_renderToFolders(false)
, m_threadsIndex(2) // All threads
, m_maxTileSizeIndex(0) // No tiling
, m_overwrite()
@ -142,9 +144,10 @@ TFarmTask::TFarmTask(const QString &id, const QString &name, bool composerTask,
const QString &user, const QString &host, int stepCount,
int priority, const TFilePath &taskFilePath,
const TFilePath &outputPath, int from, int to, int step,
int shrink, int multimedia, int chunksize,
int threadsIndex, int maxTileSizeIndex,
OverwriteBehavior overwrite, bool onlyvisible)
int shrink, int multimedia, bool renderKeysOnly,
bool renderToFolders, int chunksize, int threadsIndex,
int maxTileSizeIndex, OverwriteBehavior overwrite,
bool onlyvisible)
: m_isComposerTask(composerTask)
, m_id(id)
@ -164,6 +167,8 @@ TFarmTask::TFarmTask(const QString &id, const QString &name, bool composerTask,
, m_step(step)
, m_shrink(shrink)
, m_multimedia(multimedia)
, m_renderKeysOnly(renderKeysOnly)
, m_renderToFolders(renderToFolders)
, m_threadsIndex(threadsIndex)
, m_maxTileSizeIndex(maxTileSizeIndex)
, m_chunkSize(chunksize)
@ -221,6 +226,8 @@ TFarmTask &TFarmTask::operator=(const TFarmTask &rhs) {
m_onlyVisible = rhs.m_onlyVisible;
m_overwrite = rhs.m_overwrite;
m_multimedia = rhs.m_multimedia;
m_renderKeysOnly = rhs.m_renderKeysOnly;
m_renderToFolders = rhs.m_renderToFolders;
m_threadsIndex = rhs.m_threadsIndex;
m_maxTileSizeIndex = rhs.m_maxTileSizeIndex;
m_chunkSize = rhs.m_chunkSize;
@ -262,6 +269,8 @@ bool TFarmTask::operator==(const TFarmTask &task) {
task.m_from == m_from && task.m_to == m_to && task.m_step == m_step &&
task.m_shrink == m_shrink && task.m_onlyVisible == m_onlyVisible &&
task.m_overwrite == m_overwrite && task.m_multimedia == m_multimedia &&
task.m_renderKeysOnly == m_renderKeysOnly &&
task.m_renderToFolders == m_renderToFolders &&
task.m_threadsIndex == m_threadsIndex &&
task.m_maxTileSizeIndex == m_maxTileSizeIndex &&
task.m_chunkSize == m_chunkSize && equalDependencies);
@ -442,6 +451,12 @@ void TFarmTask::parseCommandLine(QString commandLine) {
} else if (l.at(i) == "-multimedia") {
m_multimedia = (l.at(i + 1).toInt());
i += 2;
} else if (l.at(i) == "-renderkeysonly") {
m_renderKeysOnly = (l.at(i + 1).toInt());
i += 2;
} else if (l.at(i) == "-rendertofolders") {
m_renderToFolders = (l.at(i + 1).toInt());
i += 2;
} else if (l.at(i) == "-nthreads") {
QString str(l.at(i + 1));
@ -526,6 +541,8 @@ QString TFarmTask::getCommandLineArguments() const {
cmdline += " -step " + QString::number(m_step);
cmdline += " -shrink " + QString::number(m_shrink);
cmdline += " -multimedia " + QString::number(m_multimedia);
cmdline += " -renderkeysonly " + QString::number(m_renderKeysOnly ? 1 : 0);
cmdline += " -rendertofolders " + QString::number(m_renderToFolders ? 1 : 0);
const QString threadCounts[3] = {"single", "half", "all"};
cmdline += " -nthreads " + threadCounts[m_threadsIndex];
@ -579,6 +596,8 @@ QStringList TFarmTask::getCommandLineArgumentsList() const {
ret << "-step" << QString::number(m_step);
ret << "-shrink" << QString::number(m_shrink);
ret << "-multimedia" << QString::number(m_multimedia);
ret << "-renderkeysonly" << QString::number(m_renderKeysOnly ? 1 : 0);
ret << "-rendertofolders" << QString::number(m_renderToFolders ? 1 : 0);
const QString threadCounts[3] = {"single", "half", "all"};
ret << "-nthreads" << threadCounts[m_threadsIndex];
@ -664,8 +683,9 @@ bool TFarmTaskGroup::changeChunkSize(int chunksize) {
TFarmTask *subTask = new TFarmTask(
m_id + "." + toString(i, 2, '0'), subName, true, m_user, m_hostName,
rb - ra + 1, m_priority, m_taskFilePath, m_outputPath, ra, rb,
m_step, m_shrink, m_multimedia, m_chunkSize, m_threadsIndex,
m_maxTileSizeIndex, Overwrite_Off, false);
m_step, m_shrink, m_multimedia, m_renderKeysOnly, m_renderToFolders,
m_chunkSize, m_threadsIndex, m_maxTileSizeIndex, Overwrite_Off,
false);
subTask->m_parentId = m_id;
addTask(subTask);
@ -682,18 +702,17 @@ bool TFarmTaskGroup::changeChunkSize(int chunksize) {
//------------------------------------------------------------------------------
TFarmTaskGroup::TFarmTaskGroup(const QString &id, const QString &name,
const QString &user, const QString &host,
int stepCount, int priority,
const TFilePath &taskFilePath,
const TFilePath &outputPath, int from, int to,
int step, int shrink, int multimedia,
int chunksize, int threadsIndex,
int maxTileSizeIndex)
TFarmTaskGroup::TFarmTaskGroup(
const QString &id, const QString &name, const QString &user,
const QString &host, int stepCount, int priority,
const TFilePath &taskFilePath, const TFilePath &outputPath, int from,
int to, int step, int shrink, int multimedia, bool renderKeysOnly,
bool renderToFolders, int chunksize, int threadsIndex, int maxTileSizeIndex)
: TFarmTask(id, name, true, user, host, stepCount, priority, taskFilePath,
outputPath, from, to, step, shrink, multimedia, chunksize,
threadsIndex, maxTileSizeIndex, Overwrite_Off, false)
outputPath, from, to, step, shrink, multimedia, renderKeysOnly,
renderToFolders, chunksize, threadsIndex, maxTileSizeIndex,
Overwrite_Off, false)
, m_imp(new Imp()) {
int subCount = 0;
if (chunksize > 0) subCount = tceil((to - from + 1) / (double)chunksize);
@ -708,11 +727,11 @@ TFarmTaskGroup::TFarmTaskGroup(const QString &id, const QString &name,
name + " " + toString(ra, 2, '0') + "-" + toString(rb, 2, '0');
stepCount = rb - ra + 1;
TFarmTask *subTask =
new TFarmTask(id + "." + toString(i, 2, '0'), subName, true, user,
host, stepCount, priority, taskFilePath, outputPath,
ra, rb, step, shrink, multimedia, chunksize,
threadsIndex, maxTileSizeIndex, Overwrite_Off, false);
TFarmTask *subTask = new TFarmTask(
id + "." + toString(i, 2, '0'), subName, true, user, host,
stepCount, priority, taskFilePath, outputPath, ra, rb, step, shrink,
multimedia, renderKeysOnly, renderToFolders, chunksize,
threadsIndex, maxTileSizeIndex, Overwrite_Off, false);
subTask->m_parentId = id;
addTask(subTask);
@ -733,7 +752,8 @@ TFarmTaskGroup::TFarmTaskGroup(const QString &id, const QString &name,
const TFilePath &taskFilePath,
OverwriteBehavior overwrite, bool onlyvisible)
: TFarmTask(id, name, false, user, host, stepCount, priority, taskFilePath,
TFilePath(), 0, 0, 0, 0, 0, 0, 0, 0, overwrite, onlyvisible)
TFilePath(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, overwrite,
onlyvisible)
, m_imp(new Imp()) {}
//------------------------------------------------------------------------------

110
toonz/sources/toonzlib/multimediarenderer.cpp
View file

@ -4,12 +4,16 @@
#include "toonz/multimediarenderer.h"
#include "toonz/movierenderer.h"
#include "trenderer.h"
#include "tsystem.h"
// Scene structures
#include "toonz/toonzscene.h"
#include "toonz/txsheet.h"
#include "toonz/fxdag.h"
#include "toonz/tcolumnfxset.h"
#include "toonz/txshlevelcolumn.h"
#include "toonz/txshzeraryfxcolumn.h"
#include "toonz/txshcell.h"
// Fxs tree decomposition
#include "toonz/scenefx.h"
@ -69,9 +73,12 @@ public:
QEventLoop m_eventLoop;
int m_multimediaMode;
bool m_renderKeysOnly;
bool m_renderToFolders;
Imp(ToonzScene *scene, const TFilePath &moviePath, int multimediaMode,
int threadCount, bool cacheResults);
bool renderKeysOnly, bool renderToFolders, int threadCount,
bool cacheResults);
~Imp();
@ -79,6 +86,7 @@ public:
void scanSceneForColumns();
void scanSceneForLayers();
bool scanColsRecursive(TFx *fx);
bool hasKeyDrawing(TFx *fx, int row);
TColumnFx *searchColumn(TFxP fx);
TFxP addPostProcessing(TFxP fx, TFxP postProc);
void addPostProcessingRecursive(TFxP fx, TFxP postProc);
@ -94,7 +102,8 @@ public:
//---------------------------------------------------------
MultimediaRenderer::Imp::Imp(ToonzScene *scene, const TFilePath &moviePath,
int multimediaMode, int threadCount,
int multimediaMode, bool renderKeysOnly,
bool renderToFolders, int threadCount,
bool cacheResults)
: m_scene(scene)
, m_fp(moviePath)
@ -108,7 +117,9 @@ MultimediaRenderer::Imp::Imp(ToonzScene *scene, const TFilePath &moviePath,
, m_canceled(false)
, m_currentFx(0)
, m_currentFrame()
, m_multimediaMode(multimediaMode) {
, m_multimediaMode(multimediaMode)
, m_renderKeysOnly(renderKeysOnly)
, m_renderToFolders(renderToFolders) {
// Retrieve all fx nodes to be rendered in this process.
scanSceneForRenderNodes();
}
@ -172,6 +183,35 @@ bool MultimediaRenderer::Imp::scanColsRecursive(TFx *fx) {
return false;
}
bool MultimediaRenderer::Imp::hasKeyDrawing(TFx *fx, int row) {
TColumnFx *colFx = dynamic_cast<TColumnFx *>(fx);
if (colFx) {
TXshColumn *col = colFx->getXshColumn();
if (!col) return false;
TXshCellColumn *celCol = col->getCellColumn();
if (!celCol) return false;
TXshCell cell = celCol->getCell(row, false);
TXshCell prevCell = row > 0 ? celCol->getCell(row - 1, false) : TXshCell();
if (cell.isEmpty() || cell.getFrameId().isStopFrame() || cell == prevCell)
return false;
return true;
}
// Search for key drawings in every port
bool doesChildHaveKey;
for (int i = 0; i < fx->getInputPortCount(); ++i) {
TFx *childFx = fx->getInputPort(i)->getFx();
if (!childFx) continue;
doesChildHaveKey = hasKeyDrawing(childFx, row);
if (doesChildHaveKey) return true;
}
return false;
}
//---------------------------------------------------------
//! Build the scene fx for each node below the xsheet one.
@ -310,6 +350,11 @@ void MultimediaRenderer::Imp::start() {
int j;
for (j = 0, jt = m_framesToRender.begin(); jt != m_framesToRender.end();
++j, ++jt) {
if (m_multimediaMode && m_renderKeysOnly &&
!hasKeyDrawing(m_fxsToRender.getFx(i), *jt))
continue;
TFxPair fx;
if (m_renderSettings.m_stereoscopic)
@ -354,13 +399,39 @@ void MultimediaRenderer::Imp::start() {
std::wstring fxNameNoSpaces(::removeSpaces(fxName));
std::wstring fxId(currFx->getFxId());
std::wstring fpName =
m_fp.getWideName() + L"_" + columnName +
(columnId == columnName ? L"" : L"(" + columnId + L")") +
(fxId.empty() ? L"" : L"_" + fxName + (fxId == fxNameNoSpaces
? L""
: L"(" + fxId + L")"));
TFilePath movieFp(m_fp.withName(fpName));
std::wstring fpName;
TFilePath fp = m_fp;
if (!m_renderToFolders)
fpName = fp.getWideName() + L"_" + columnName +
(columnId == columnName ? L"" : L"(" + columnId + L")") +
(fxId.empty()
? L""
: L"_" + fxName +
(fxId == fxNameNoSpaces ? L"" : L"(" + fxId + L")"));
else {
fp = fp.getParentDir() + TFilePath(fp.getWideName()) +
TFilePath(columnName +
(columnId == columnName ? L"" : L"(" + columnId + L")")) +
columnName;
fp = fp.withType(m_fp.getType());
if (!TSystem::doesExistFileOrLevel(fp.getParentDir())) {
TFilePath parentDir = fp.getParentDir();
try {
TSystem::mkDir(parentDir);
} catch (...) {
break;
}
}
fpName = columnName +
((fxId.empty() || m_multimediaMode == 1)
? L""
: L"_" + fxName +
(fxId == fxNameNoSpaces ? L"" : L"(" + fxId + L")"));
}
TFilePath movieFp(fp.withName(fpName));
// Initialize a MovieRenderer with our infos
MovieRenderer movieRenderer(m_scene, movieFp, m_threadCount, false);
@ -446,10 +517,11 @@ void MultimediaRenderer::Imp::onRenderCompleted() {
MultimediaRenderer::MultimediaRenderer(ToonzScene *scene,
const TFilePath &moviePath,
int multimediaMode, int threadCount,
int multimediaMode, bool renderKeysOnly,
bool renderToFolders, int threadCount,
bool cacheResults)
: m_imp(new Imp(scene, moviePath, multimediaMode, threadCount,
cacheResults)) {
: m_imp(new Imp(scene, moviePath, multimediaMode, renderKeysOnly,
renderToFolders, threadCount, cacheResults)) {
m_imp->addRef();
}
@ -481,6 +553,18 @@ int MultimediaRenderer::getMultimediaMode() const {
//---------------------------------------------------------
bool MultimediaRenderer::isRenderKeysOnly() const {
return m_imp->m_renderKeysOnly;
}
//---------------------------------------------------------
bool MultimediaRenderer::isRenderToFolders() const {
return m_imp->m_renderToFolders;
}
//---------------------------------------------------------
void MultimediaRenderer::setRenderSettings(
const TRenderSettings &renderSettings) {
// assert(m_imp->m_framesOnRendering.empty());

6
toonz/sources/toonzlib/outputproperties.cpp
View file

@ -38,6 +38,8 @@ TOutputProperties::TOutputProperties()
, m_step(1)
, m_whichLevels(false)
, m_multimediaRendering(0)
, m_renderKeysOnly(false)
, m_renderToFolders(false)
, m_maxTileSizeIndex(0)
, m_threadIndex(2)
, m_subcameraPreview(false)
@ -61,6 +63,8 @@ TOutputProperties::TOutputProperties(const TOutputProperties &src)
, m_offset(src.m_offset)
, m_step(src.m_step)
, m_multimediaRendering(src.m_multimediaRendering)
, m_renderKeysOnly(src.m_renderKeysOnly)
, m_renderToFolders(src.m_renderToFolders)
, m_maxTileSizeIndex(src.m_maxTileSizeIndex)
, m_threadIndex(src.m_threadIndex)
, m_subcameraPreview(src.m_subcameraPreview)
@ -96,6 +100,8 @@ TOutputProperties &TOutputProperties::operator=(const TOutputProperties &src) {
m_step = src.m_step;
m_multimediaRendering = src.m_multimediaRendering;
m_renderKeysOnly = src.m_renderKeysOnly;
m_renderToFolders = src.m_renderToFolders;
m_maxTileSizeIndex = src.m_maxTileSizeIndex;
m_threadIndex = src.m_threadIndex;
m_subcameraPreview = src.m_subcameraPreview;

16
toonz/sources/toonzlib/sceneproperties.cpp
View file

@ -262,6 +262,14 @@ void TSceneProperties::saveData(TOStream &os) const {
os.child("syncColorSettings") << (out.isColorSettingsSynced() ? 1 : 0);
os.child("multimedia") << out.getMultimediaRendering();
// Save render keys only if enabled and multimedia set to anything except
// None
if (out.getMultimediaRendering()) {
if (out.isRenderKeysOnly())
os.child("renderKeysOnly") << (out.isRenderKeysOnly() ? 1 : 0);
if (out.isRenderToFolders())
os.child("renderToFolders") << (out.isRenderToFolders() ? 1 : 0);
}
os.child("threadsIndex") << out.getThreadIndex();
os.child("maxTileSizeIndex") << out.getMaxTileSizeIndex();
os.child("subcameraPrev") << (out.isSubcameraPreview() ? 1 : 0);
@ -595,6 +603,14 @@ void TSceneProperties::loadData(TIStream &is, bool isLoadingProject) {
int j;
is >> j;
out.setMultimediaRendering(j);
} else if (tagName == "renderKeysOnly") {
int renderKeysOnly;
is >> renderKeysOnly;
out.setRenderKeysOnly(renderKeysOnly == 1);
} else if (tagName == "renderToFolders") {
int renderToFolders;
is >> renderToFolders;
out.setRenderToFolders(renderToFolders == 1);
} else if (tagName == "threadsIndex") {
int j;
is >> j;