void RenderWindow::slotMenuSaveSettings()
{
cSettings parSettings(cSettings::formatCondensedText);
gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read);
parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes);
QFileDialog dialog(this);
dialog.setOption(QFileDialog::DontUseNativeDialog);
dialog.setFileMode(QFileDialog::AnyFile);
dialog.setNameFilter(tr("Fractals (*.txt *.fract)"));
dialog.setDirectory(
QDir::toNativeSeparators(QFileInfo(systemData.lastSettingsFile).absolutePath()));
dialog.selectFile(
QDir::toNativeSeparators(QFileInfo(systemData.lastSettingsFile).completeBaseName()));
dialog.setAcceptMode(QFileDialog::AcceptSave);
dialog.setWindowTitle(tr("Save settings..."));
dialog.setDefaultSuffix("fract");
QStringList filenames;
if (dialog.exec())
{
filenames = dialog.selectedFiles();
QString filename = QDir::toNativeSeparators(filenames.first());
parSettings.SaveToFile(filename);
systemData.lastSettingsFile = filename;
SaveSettingsToRecent(filename);
setWindowTitle(QString("Mandelbulber (") + filename + ")");
// QString hash = parSettings.GetHashCode();
// cThumbnail thumbnail(gPar, gParFractal, 200, 200);
// thumbnail.Render();
// thumbnail.Save(systemData.thumbnailDir + hash);
}
}
void RenderWindow::slotMenuLoadSettingsFromClipboard()
{
gMainInterface->SynchronizeInterface(
gPar, gParFractal, qInterface::read); // update appParam before loading new settings
cSettings parSettings(cSettings::formatFullText);
if (parSettings.LoadFromClipboard())
{
gMainInterface->DisablePeriodicRefresh();
gInterfaceReadyForSynchronization = false;
parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes);
gMainInterface->RebuildPrimitives(gPar);
gMainInterface->materialListModel->Regenerate();
gInterfaceReadyForSynchronization = true;
gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::write);
gMainInterface->ComboMouseClickUpdate();
systemData.lastSettingsFile = "from clipboard";
setWindowTitle(QString("Mandelbulber (") + "from clipboard" + ")");
gFlightAnimation->RefreshTable();
gKeyframeAnimation->RefreshTable();
gMainInterface->ReEnablePeriodicRefresh();
showDescriptionPopup();
}
else
{
cErrorMessage::showMessage(QObject::tr("Cannot load settings from clipboard!"),
cErrorMessage::errorMessage, gMainInterface->mainWindow);
}
}
void PreviewFileDialog::OnCurrentChanged(const QString & _filename)
{
filename = _filename;
QPixmap pixmap;
if (QFileInfo(filename).suffix() == QString("fract") && checkbox->isChecked())
{
thumbWidget->show();
preview->hide();
cSettings parSettings(cSettings::formatFullText);
parSettings.BeQuiet(true);
if (parSettings.LoadFromFile(filename))
{
progressBar->show();
cParameterContainer *par = new cParameterContainer;
cFractalContainer *parFractal = new cFractalContainer;
InitParams(par);
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
InitFractalParams(&parFractal->at(i));
/****************** TEMPORARY CODE FOR MATERIALS *******************/
InitMaterialParams(1, par);
/*******************************************************************/
if (parSettings.Decode(par, parFractal))
{
thumbWidget->AssignParameters(*par, *parFractal);
thumbWidget->update();
}
else
{
preview->setText(" ");
info->setText(" ");
}
delete par;
delete parFractal;
}
}
else
{
thumbWidget->hide();
preview->show();
pixmap.load(filename);
if (pixmap.isNull() || !checkbox->isChecked())
{
preview->setText(" ");
info->setText(" ");
}
else
{
preview->setPixmap(pixmap.scaled(200, 200, Qt::KeepAspectRatio, Qt::SmoothTransformation));
QString text = QString::number(pixmap.width()) + QString(" x ")
+ QString::number(pixmap.height());
info->setText(text);
}
}
}
void RenderWindow::slotPresetAddToToolbar()
{
cSettings parSettings(cSettings::formatCondensedText);
gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read);
parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes);
QString filename = systemData.dataDirectory + "toolbar/" + parSettings.GetHashCode() + ".fract";
parSettings.SaveToFile(filename);
slotPopulateToolbar();
}
void RenderWindow::slotMenuSaveSettingsToClipboard()
{
cSettings parSettings(cSettings::formatCondensedText);
gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read);
parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes);
parSettings.SaveToClipboard();
cErrorMessage::showMessage(
QObject::tr("Settings saved to clipboard"), cErrorMessage::infoMessage);
}
void cRenderQueue::slotRenderQueue()
{
int queueFinished = 0;
WriteLog("cRenderQueue::slotRenderQueue()", 2);
gQueue->stopRequest = false;
while (!gQueue->stopRequest)
{
int queueTotalLeft = gQueue->GetQueueSize();
cQueue::structQueueItem queueItem = gQueue->GetNextFromList();
if (queueItem.filename == "") break; // last item reached
emit updateProgressAndStatus(QFileInfo(queueItem.filename).fileName(),
QObject::tr("Queue Item %1 of %2").arg(queueFinished + 1).arg(queueTotalLeft + queueFinished),
(1.0 * queueFinished / (queueTotalLeft + queueFinished)), cProgressText::progress_QUEUE);
if (QFile::exists(queueItem.filename))
{
cSettings parSettings(cSettings::formatFullText);
parSettings.LoadFromFile(queueItem.filename);
parSettings.Decode(queuePar, queueParFractal, queueAnimFrames, queueKeyframes);
queuePar->Set("image_preview_scale", 0);
bool result = false;
switch (queueItem.renderType)
{
case cQueue::queue_STILL: result = RenderStill(queueItem.filename); break;
case cQueue::queue_FLIGHT: result = RenderFlight(); break;
case cQueue::queue_KEYFRAME: result = RenderKeyframe(); break;
}
if (result)
{
gQueue->RemoveQueueItem(queueItem);
queueFinished++;
}
else
{
break;
}
}
else
{
cErrorMessage::showMessage("Cannot load file!\n", cErrorMessage::errorMessage);
qCritical() << "\nSetting file " << queueItem.filename << " not found\n";
}
}
emit updateProgressAndStatus(
QObject::tr("Queue Render"), QObject::tr("Queue Done"), 1.0, cProgressText::progress_QUEUE);
emit finished();
}
bool cRenderQueue::RenderStill(const QString& filename)
{
QString extension;
enumImageFileType imageFormat = (enumImageFileType) gPar->Get<int>("queue_image_format");
extension = ImageFileExtension(imageFormat);
QString saveFilename = QFileInfo(filename).baseName() + extension;
//setup of rendering engine
cRenderJob *renderJob = new cRenderJob(queuePar,
queueParFractal,
image,
&gQueue->stopRequest,
imageWidget);
connect(renderJob,
SIGNAL(updateProgressAndStatus(const QString&, const QString&, double)),
this,
SIGNAL(updateProgressAndStatus(const QString&, const QString&, double)));
connect(renderJob,
SIGNAL(updateStatistics(cStatistics)),
this,
SIGNAL(updateStatistics(cStatistics)));
cRenderingConfiguration config;
if (systemData.noGui)
{
config.DisableProgressiveRender();
config.DisableRefresh();
}
config.EnableNetRender();
renderJob->Init(cRenderJob::still, config);
gQueue->stopRequest = false;
//render image
bool result = renderJob->Execute();
if (!result)
{
delete renderJob;
return false;
}
QString fullSaveFilename = gPar->Get<QString>("default_image_path") + QDir::separator()
+ saveFilename;
SaveImage(fullSaveFilename, imageFormat, image);
fullSaveFilename = gPar->Get<QString>("default_image_path") + QDir::separator()
+ QFileInfo(filename).baseName() + ".fract";
cSettings parSettings(cSettings::formatCondensedText);
parSettings.CreateText(queuePar, queueParFractal);
parSettings.SaveToFile(fullSaveFilename);
delete renderJob;
return true;
}
void Test::renderExamples()
{
// this renders all example files in a resolution of 5x5 px
// and benchmarks the runtime
QString examplePath =
QDir::toNativeSeparators(systemData.sharedDir + QDir::separator() + "examples");
QDirIterator it(examplePath, QStringList() << "*.fract", QDir::Files);
cParameterContainer *testPar = new cParameterContainer;
cFractalContainer *testParFractal = new cFractalContainer;
cAnimationFrames *testAnimFrames = new cAnimationFrames;
cKeyframes *testKeyframes = new cKeyframes;
testPar->SetContainerName("main");
InitParams(testPar);
/****************** TEMPORARY CODE FOR MATERIALS *******************/
InitMaterialParams(1, testPar);
/*******************************************************************/
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
{
testParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i));
InitFractalParams(&testParFractal->at(i));
}
bool stopRequest = false;
cImage *image = new cImage(testPar->Get<int>("image_width"), testPar->Get<int>("image_height"));
cRenderingConfiguration config;
config.DisableRefresh();
config.DisableProgressiveRender();
while (it.hasNext())
{
QString filename = it.next();
cSettings parSettings(cSettings::formatFullText);
parSettings.BeQuiet(true);
parSettings.LoadFromFile(filename);
parSettings.Decode(testPar, testParFractal, testAnimFrames, testKeyframes);
testPar->Set("image_width", 5);
testPar->Set("image_height", 5);
cRenderJob *renderJob = new cRenderJob(testPar, testParFractal, image, &stopRequest);
renderJob->Init(cRenderJob::still, config);
QVERIFY2(renderJob->Execute(), "example render failed.");
delete renderJob;
}
delete image;
delete testKeyframes;
delete testAnimFrames;
delete testParFractal;
delete testPar;
}
void RenderWindow::slotMenuLoadPreset(QString filename)
{
cSettings parSettings(cSettings::formatFullText);
parSettings.LoadFromFile(filename);
parSettings.Decode(gPar, gParFractal);
gMainInterface->RebuildPrimitives(gPar);
gMainInterface->SynchronizeInterface(gPar, gParFractal, cInterface::write);
gMainInterface->ComboMouseClickUpdate();
systemData.lastSettingsFile = gPar->Get<QString>("default_settings_path") + QDir::separator()
+ QFileInfo(filename).fileName();
this->setWindowTitle(QString("Mandelbulber (") + systemData.lastSettingsFile + ")");
}
void Test::testKeyframe()
{
QString exampleKeyframeFile =
QDir::toNativeSeparators(systemData.sharedDir + QDir::separator() + "examples"
+ QDir::separator() + "keyframe_anim_mandelbulb.fract");
cParameterContainer *testPar = new cParameterContainer;
cFractalContainer *testParFractal = new cFractalContainer;
cAnimationFrames *testAnimFrames = new cAnimationFrames;
cKeyframes *testKeyframes = new cKeyframes;
testPar->SetContainerName("main");
InitParams(testPar);
/****************** TEMPORARY CODE FOR MATERIALS *******************/
InitMaterialParams(1, testPar);
/*******************************************************************/
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
{
testParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i));
InitFractalParams(&testParFractal->at(i));
}
cImage *image = new cImage(testPar->Get<int>("image_width"), testPar->Get<int>("image_height"));
cRenderingConfiguration config;
config.DisableRefresh();
config.DisableProgressiveRender();
cSettings parSettings(cSettings::formatFullText);
parSettings.BeQuiet(true);
parSettings.LoadFromFile(exampleKeyframeFile);
parSettings.Decode(testPar, testParFractal, testAnimFrames, testKeyframes);
testPar->Set("image_width", 5);
testPar->Set("image_height", 5);
testPar->Set("keyframe_first_to_render", 50);
testPar->Set("keyframe_last_to_render", 55);
cKeyframeAnimation *testKeyframeAnimation = new cKeyframeAnimation(
gMainInterface, testKeyframes, image, NULL, testPar, testParFractal, NULL);
QVERIFY2(testKeyframeAnimation->slotRenderKeyframes(), "keyframe render failed.");
delete image;
delete testKeyframes;
delete testAnimFrames;
delete testParFractal;
delete testPar;
delete testKeyframeAnimation;
testKeyframeAnimation = NULL;
return;
}
void cUndo::Store(cParameterContainer *par, cFractalContainer *parFractal, cAnimationFrames *frames,
cKeyframes *keyframes)
{
sUndoRecord record;
// autosave
WriteLog("Autosave started", 2);
cSettings parSettings(cSettings::formatCondensedText);
parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes);
parSettings.SaveToFile(systemData.GetAutosaveFile());
WriteLog("Autosave finished", 2);
WriteLog("cUndo::Store() started", 2);
record.mainParams = *par;
record.fractParams = *parFractal;
if (frames)
{
record.animationFrames = *frames;
record.hasFrames = true;
}
else
{
record.hasFrames = false;
record.animationFrames = cAnimationFrames();
}
if (keyframes)
{
record.animationKeyframes = *keyframes;
record.hasKeyframes = true;
}
else
{
record.hasKeyframes = false;
record.animationKeyframes = cKeyframes();
}
if (undoBuffer.size() > level)
{
for (int i = undoBuffer.size() - 1; i >= level; i--)
{
undoBuffer.removeAt(i);
}
}
undoBuffer.append(record);
level++;
WriteLog("cUndo::Store() finished", 2);
}
void RenderWindow::slotMenuLoadSettingsFromFile(QString fileName)
{
cSettings parSettings(cSettings::formatFullText);
gMainInterface->DisablePeriodicRefresh();
gInterfaceReadyForSynchronization = false;
parSettings.LoadFromFile(fileName);
parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes);
gMainInterface->RebuildPrimitives(gPar);
gMainInterface->materialListModel->Regenerate();
gInterfaceReadyForSynchronization = true;
gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::write);
gMainInterface->ComboMouseClickUpdate();
systemData.lastSettingsFile = fileName;
SaveSettingsToRecent(fileName);
setWindowTitle(QString("Mandelbulber (") + fileName + ")");
gFlightAnimation->RefreshTable();
gKeyframeAnimation->RefreshTable();
gMainInterface->ReEnablePeriodicRefresh();
showDescriptionPopup();
}
void cCommandLineInterface::ReadCLI (void)
{
bool checkParse = true;
bool settingsSpecified = false;
QTextStream out(stdout);
// show input help only
if(cliData.showInputHelp)
{
out << QObject::tr("Mandelbulber also accepts an arbitrary number of input files\n"
"These files can be of type:\n"
".fract File - An ordinary fractal file\n"
".fractlist File - A queue file, all entries inside the queue file will be added to the current queue\n"
"Folder - if the specified argument is a folder all .fract files inside the folder will be added to the queue\n");
out.flush();
exit(0);
}
// list parameters only
if(cliData.listParameters)
{
QList<QString> listOfParameters = gPar->GetListOfParameters();
out << cHeadless::colorize("\nList of main parameters:\n", cHeadless::ansiYellow, cHeadless::noExplicitColor, true);
out << "KEY=VALUE\n";
for(int i = 0; i < listOfParameters.size(); i++)
{
QString parameterName = listOfParameters.at(i);
QString defaultValue = gPar->GetDefault<QString>(parameterName);
out << parameterName + "=" + defaultValue + "\n";
}
QList<QString> listOfFractalParameters = gParFractal->at(0).GetListOfParameters();
out << cHeadless::colorize(QObject::tr("\nList of fractal parameters:\n"), cHeadless::ansiYellow, cHeadless::noExplicitColor, true);
for(int i = 0; i < listOfFractalParameters.size(); i++)
{
QString parameterName = listOfFractalParameters.at(i);
QString defaultValue = gParFractal->at(0).GetDefault<QString>(parameterName);
out << parameterName + "=" + defaultValue + "\n";
}
out.flush();
exit(0);
}
// check netrender server / client
if(cliData.server)
{
int port = gPar->Get<int>("netrender_server_local_port");
if(cliData.portText != "")
{
port = cliData.portText.toInt(&checkParse);
if(!checkParse || port <= 0){
cErrorMessage::showMessage(QObject::tr("Specified server port is invalid\n"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorServerInvalidPort);
}
gPar->Set("netrender_server_local_port", port);
}
cliData.nogui = true; systemData.noGui = true;
gNetRender->SetServer(gPar->Get<int>("netrender_server_local_port"));
QElapsedTimer timer;
timer.start();
if(systemData.noGui)
{
out << QObject::tr("NetRender - Waiting for clients\n");
out.flush();
}
while(timer.elapsed() < 5000)
{
gApplication->processEvents();
}
}
else if(cliData.host != "")
{
int port = gPar->Get<int>("netrender_client_remote_port");
gPar->Set("netrender_client_remote_address", cliData.host);
if(cliData.portText != "")
{
port = cliData.portText.toInt(&checkParse);
if(!checkParse || port <= 0){
cErrorMessage::showMessage(QObject::tr("Specified client port is invalid\n"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorClientInvalidPort);
}
gPar->Set("netrender_client_remote_port", port);
}
cliData.nogui = true; systemData.noGui = true;
cliTODO = modeNetrender;
return;
}
if(cliData.queue)
{
cliTODO = modeQueue;
settingsSpecified = true;
cliData.nogui = true; systemData.noGui = true;
try
{
gQueue = new cQueue(gMainInterface, systemData.dataDirectory + "queue.fractlist", systemData.dataDirectory + "queue", NULL);
}
catch(QString &ex)
{
cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex, cErrorMessage::errorMessage);
parser.showHelp(cliErrorQueueInit);
}
}
else
{
if(args.size() > 0){
// file specified -> load it
if(args.size() == 1 && QFileInfo(args[0]).suffix() != QString("fractlist") && !QDir(args[0]).exists())
{
QString filename = args[0];
if(!QFile::exists(filename))
{
// try to find settings in default settings path
filename = systemData.dataDirectory + "settings" + QDir::separator() + filename;
}
if(QFile::exists(filename))
{
cSettings parSettings(cSettings::formatFullText);
parSettings.LoadFromFile(filename);
parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes);
settingsSpecified = true;
systemData.lastSettingsFile = filename;
}
else
{
cErrorMessage::showMessage(QObject::tr("Cannot load file!\n"), cErrorMessage::errorMessage);
qCritical() << "\nSetting file " << filename << " not found\n";
parser.showHelp(cliErrorLoadSettingsFile);
}
}
else
{
// queue render
cliTODO = modeQueue;
cliData.nogui = true; systemData.noGui = true;
try
{
gQueue = new cQueue(gMainInterface, systemData.dataDirectory + "queue.fractlist", systemData.dataDirectory + "queue", NULL);
}
catch(QString &ex)
{
cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex, cErrorMessage::errorMessage);
parser.showHelp(cliErrorQueueInit);
}
for(int i = 0; i < args.size(); i++)
{
QString filename = args[i];
if(QDir(args[i]).exists())
{
// specified input is a folder, load all fractal files contained in this folder
gQueue->AppendFolder(filename);
settingsSpecified = true;
}
else if(QFileInfo(filename).suffix() == QString("fractlist"))
{
// specified input is a queue list file, append all entries to the current queue
gQueue->AppendList(filename);
settingsSpecified = true;
}
else
{
// specified input can only be an ordinary fract file, try to append to queuelist
gQueue->Append(filename);
settingsSpecified = true;
}
}
}
}
}
// overwriting parameters
if(cliData.overrideParametersText != "")
{
QStringList overrideParameters = cliData.overrideParametersText.split("#", QString::SkipEmptyParts);
for(int i = 0; i < overrideParameters.size(); i++)
{
int fractalIndex = -1;
QRegularExpression reType("^fractal([0-9]+)_(.*)$");
QRegularExpressionMatch matchType = reType.match(overrideParameters[i]);
if (matchType.hasMatch())
{
fractalIndex = matchType.captured(1).toInt() - 1;
overrideParameters[i] = matchType.captured(2);
}
QStringList overrideParameter = overrideParameters[i].split(QRegExp("\\="));
if(overrideParameter.size() == 2)
{
if(fractalIndex >= 0 && fractalIndex < NUMBER_OF_FRACTALS)
{
gParFractal->at(fractalIndex).Set(overrideParameter[0].trimmed(), overrideParameter[1].trimmed());
}
else
{
gPar->Set(overrideParameter[0].trimmed(), overrideParameter[1].trimmed());
}
}
}
}
// specified resolution
if(cliData.resolution != "")
{
QStringList resolutionParameters = cliData.resolution.split(QRegExp("x"));
if(resolutionParameters.size() == 2)
{
int xRes = resolutionParameters[0].toInt(&checkParse);
int yRes = resolutionParameters[1].toInt(&checkParse);
if(!checkParse || xRes <= 0 || yRes <= 0){
cErrorMessage::showMessage(QObject::tr("Specified resolution not valid\n"
"both dimensions need to be > 0"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorResolutionInvalid);
}
gPar->Set("image_width", xRes);
gPar->Set("image_height", yRes);
}
else{
cErrorMessage::showMessage(QObject::tr("Specified resolution not valid\n"
"resolution has to be in the form WIDTHxHEIGHT"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorResolutionInvalid);
}
}
// specified frames per keyframe
if(cliData.fpkText != "")
{
int fpk = cliData.fpkText.toInt(&checkParse);
if(!checkParse || fpk <= 0){
cErrorMessage::showMessage(QObject::tr("Specified frames per key not valid\n"
"need to be > 0"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorFPKInvalid);
}
gPar->Set("frames_per_keyframe", fpk);
}
// specified image file format
if(cliData.imageFileFormat != "")
{
QStringList allowedImageFileFormat;
allowedImageFileFormat << "jpg" << "png" << "png16" << "png16alpha" << "exr";
if(!allowedImageFileFormat.contains(cliData.imageFileFormat)){
cErrorMessage::showMessage(QObject::tr("Specified imageFileFormat is not valid\n"
"allowed formats are: ") + allowedImageFileFormat.join(", "), cErrorMessage::errorMessage);
parser.showHelp(cliErrorImageFileFormatInvalid);
}
}
else
{
cliData.imageFileFormat = "jpg";
}
//flight animation
if(cliData.flight)
{
if(gAnimFrames->GetNumberOfFrames() > 0)
{
cliTODO = modeFlight;
cliData.nogui = true; systemData.noGui = true;
}
else
{
cErrorMessage::showMessage(QObject::tr("There are no flight animation frames in specified settings file"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorFlightNoFrames);
}
}
//keyframe animation
if(cliData.keyframe)
{
if(cliTODO == modeFlight)
{
cErrorMessage::showMessage(QObject::tr("You cannot render keyframe animation at the same time as flight animation"), cErrorMessage::errorMessage);
}
else
{
if(gKeyframes->GetNumberOfFrames() > 0)
{
cliTODO = modeKeyframe;
cliData.nogui = true; systemData.noGui = true;
}
else
{
cErrorMessage::showMessage(QObject::tr("There are no keyframes in specified settings file"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorKeyframeNoFrames);
}
}
}
// start frame of animation
if (cliData.startFrameText != "")
{
int startFrame = cliData.startFrameText.toInt(&checkParse);
if (cliTODO == modeFlight)
{
if (startFrame <= gAnimFrames->GetNumberOfFrames())
{
gPar->Set("flight_first_to_render", startFrame);
}
else
{
cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(gAnimFrames->GetNumberOfFrames()), cErrorMessage::errorMessage);
parser.showHelp(cliErrorFlightStartFrameOutOfRange);
}
}
if (cliTODO == modeKeyframe)
{
int numberOfFrames = (gKeyframes->GetNumberOfFrames() - 1) * gPar->Get<int>("frames_per_keyframe");
if (numberOfFrames < 0) numberOfFrames = 0;
if (startFrame <= numberOfFrames)
{
gPar->Set("keyframe_first_to_render", startFrame);
}
else
{
cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(numberOfFrames), cErrorMessage::errorMessage);
parser.showHelp(cliErrorKeyframeStartFrameOutOfRange);
}
}
}
// end frame of animation
if (cliData.endFrameText != "")
{
int endFrame = cliData.endFrameText.toInt(&checkParse);
if (cliTODO == modeFlight)
{
if (endFrame <= gAnimFrames->GetNumberOfFrames())
{
if (endFrame > gPar->Get<int>("flight_first_to_render"))
{
gPar->Set("flight_last_to_render", endFrame);
}
else
{
cErrorMessage::showMessage(QObject::tr("End frame has to be greater than start frame which is %1").arg(gPar->Get<int>("flight_first_to_render")),
cErrorMessage::errorMessage);
parser.showHelp(cliErrorFlightEndFrameSmallerStartFrame);
}
}
else
{
cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(gAnimFrames->GetNumberOfFrames()), cErrorMessage::errorMessage);
parser.showHelp(cliErrorFlightEndFrameOutOfRange);
}
}
if (cliTODO == modeKeyframe)
{
int numberOfFrames = (gKeyframes->GetNumberOfFrames() - 1) * gPar->Get<int>("frames_per_keyframe");
if (numberOfFrames < 0) numberOfFrames = 0;
if (endFrame <= numberOfFrames)
{
if (endFrame > gPar->Get<int>("keyframe_first_to_render"))
{
gPar->Set("keyframe_last_to_render", endFrame);
}
else
{
cErrorMessage::showMessage(QObject::tr("End frame has to be greater than start frame which is %1").arg(gPar->Get<int>("keyframe_first_to_render")),
cErrorMessage::errorMessage);
parser.showHelp(cliErrorKeyframeEndFrameSmallerStartFrame);
}
}
else
{
cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(numberOfFrames), cErrorMessage::errorMessage);
parser.showHelp(cliErrorKeyframeEndFrameOutOfRange);
}
}
}
//folder for animation frames
if(cliData.outputText != "" && cliTODO == modeFlight)
{
gPar->Set("anim_flight_dir", cliData.outputText);
}
if(cliData.outputText != "" && cliTODO == modeKeyframe)
{
gPar->Set("anim_keyframe_dir", cliData.outputText);
}
if(!settingsSpecified && cliData.nogui && cliTODO != modeNetrender)
{
cErrorMessage::showMessage(QObject::tr("You have to specify a settings file, for this configuration!"), cErrorMessage::errorMessage);
parser.showHelp(cliErrorSettingsFileNotSpecified);
}
if(cliData.nogui && cliTODO != modeKeyframe && cliTODO != modeFlight && cliTODO != modeQueue)
{
//creating output filename if it's not specified
if(cliData.outputText == "")
{
cliData.outputText = gPar->Get<QString>("default_image_path") + QDir::separator();
cliData.outputText += QFileInfo(systemData.lastSettingsFile).completeBaseName();
}
cliTODO = modeStill;
return;
}
}
// adds dynamic actions to the toolbar (example settings)
void RenderWindow::slotPopulateToolbar(bool completeRefresh)
{
WriteLog("cInterface::PopulateToolbar(QWidget *window, QToolBar *toolBar) started", 2);
QDir toolbarDir = QDir(systemData.dataDirectory + "toolbar");
toolbarDir.setSorting(QDir::Time);
QStringList toolbarFiles = toolbarDir.entryList(QDir::NoDotAndDotDot | QDir::Files);
QSignalMapper *mapPresetsFromExamplesLoad = new QSignalMapper(this);
QSignalMapper *mapPresetsFromExamplesRemove = new QSignalMapper(this);
ui->toolBar->setIconSize(
QSize(gPar->Get<int>("toolbar_icon_size"), gPar->Get<int>("toolbar_icon_size")));
QList<QAction *> actions = ui->toolBar->actions();
QStringList toolbarInActions;
for (int i = 0; i < actions.size(); i++)
{
QAction *action = actions.at(i);
if (action->objectName() == "actionAdd_Settings_to_Toolbar") continue;
if (!toolbarFiles.contains(action->objectName()) || completeRefresh)
{
// preset has been removed
ui->toolBar->removeAction(action);
}
else
{
toolbarInActions << action->objectName();
}
}
for (int i = 0; i < toolbarFiles.size(); i++)
{
if (toolbarInActions.contains(toolbarFiles.at(i)))
{
// already present
continue;
}
QString filename = systemData.dataDirectory + "toolbar/" + toolbarFiles.at(i);
cThumbnailWidget *thumbWidget = NULL;
if (QFileInfo(filename).suffix() == QString("fract"))
{
WriteLogString("Generating thumbnail for preset", filename, 2);
cSettings parSettings(cSettings::formatFullText);
parSettings.BeQuiet(true);
if (parSettings.LoadFromFile(filename))
{
cParameterContainer *par = new cParameterContainer;
cFractalContainer *parFractal = new cFractalContainer;
InitParams(par);
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
InitFractalParams(&parFractal->at(i));
/****************** TEMPORARY CODE FOR MATERIALS *******************/
InitMaterialParams(1, par);
/*******************************************************************/
if (parSettings.Decode(par, parFractal))
{
thumbWidget = new cThumbnailWidget(
gPar->Get<int>("toolbar_icon_size"), gPar->Get<int>("toolbar_icon_size"), 2, this);
thumbWidget->UseOneCPUCore(true);
thumbWidget->AssignParameters(*par, *parFractal);
}
delete par;
delete parFractal;
}
}
if (thumbWidget)
{
QWidgetAction *action = new QWidgetAction(this);
QToolButton *buttonLoad = new QToolButton;
QVBoxLayout *tooltipLayout = new QVBoxLayout;
QToolButton *buttonRemove = new QToolButton;
tooltipLayout->setContentsMargins(3, 3, 3, 3);
tooltipLayout->addWidget(thumbWidget);
QIcon iconDelete = QIcon::fromTheme("list-remove", QIcon(":system/icons/list-remove.svg"));
buttonRemove->setIcon(iconDelete);
buttonRemove->setMaximumSize(QSize(15, 15));
buttonRemove->setStyleSheet("margin-bottom: -2px; margin-left: -2px;");
tooltipLayout->addWidget(buttonRemove);
buttonLoad->setToolTip(QObject::tr("Toolbar settings: ") + filename);
buttonLoad->setLayout(tooltipLayout);
action->setDefaultWidget(buttonLoad);
action->setObjectName(toolbarFiles.at(i));
ui->toolBar->addAction(action);
mapPresetsFromExamplesLoad->setMapping(buttonLoad, filename);
mapPresetsFromExamplesRemove->setMapping(buttonRemove, filename);
QApplication::connect(buttonLoad, SIGNAL(clicked()), mapPresetsFromExamplesLoad, SLOT(map()));
QApplication::connect(
buttonRemove, SIGNAL(clicked()), mapPresetsFromExamplesRemove, SLOT(map()));
}
}
QApplication::connect(
mapPresetsFromExamplesLoad, SIGNAL(mapped(QString)), this, SLOT(slotMenuLoadPreset(QString)));
QApplication::connect(mapPresetsFromExamplesRemove, SIGNAL(mapped(QString)), this,
SLOT(slotMenuRemovePreset(QString)));
WriteLog("cInterface::PopulateToolbar(QWidget *window, QToolBar *toolBar) finished", 2);
}
void CNetRender::ProcessData(QTcpSocket *socket, sMessage *inMsg)
{
// beware: payload points to char, first cast to target type pointer, then dereference
// *(qint32*)msg->payload
//------------------------- CLIENT ------------------------
if(IsClient())
{
switch ((netCommand)inMsg->command)
{
case netRender_VERSION:
{
sMessage outMsg;
if(*(qint32*)inMsg->payload.data() == version)
{
WriteLog("NetRender - version matches (" + QString::number(version) + "), connection established");
if(systemData.noGui)
{
QTextStream out(stdout);
out << "NetRender - version matches (" + QString::number(version) + "), connection established\n";
}
// server version matches, send worker count
outMsg.command = netRender_WORKER;
QDataStream stream(&outMsg.payload, QIODevice::WriteOnly);
stream << workerCount;
QString machineName = QHostInfo::localHostName();
stream << (qint32)machineName.toUtf8().size();
stream.writeRawData(machineName.toUtf8().data(), machineName.toUtf8().size());
status = netRender_READY;
emit NewStatusClient();
}
else
{
qWarning() << "CNetRender - version mismatch! client version: " << version << ", server: " << *(qint32*)inMsg->payload.data();
outMsg.command = netRender_BAD;
}
SendData(clientSocket, outMsg);
break;
}
case netRender_STOP:
{
status = netRender_READY;
gMainInterface->stopRequest = true;
emit NotifyStatus();
WriteLog("CNetRender - STOP");
break;
}
case netRender_STATUS:
{
emit NotifyStatus();
break;
}
case netRender_JOB:
{
if (inMsg->id == actualId)
{
WriteLog("NetRender - received new job");
QDataStream stream(&inMsg->payload, QIODevice::ReadOnly);
QByteArray buffer;
qint32 size;
status = netRender_WORKING;
emit NotifyStatus();
// read settings
stream >> size;
buffer.resize(size);
stream.readRawData(buffer.data(), size);
settingsText = QString::fromUtf8(buffer.data(), buffer.size());
// read textures
for (int i = 0; i < textures.textureList.size(); i++)
{
stream >> size;
if (size > 0)
{
buffer.resize(size);
stream.readRawData(buffer.data(), size);
textures.textureList[i]->FromQByteArray(buffer);
}
}
cSettings parSettings(cSettings::formatCondensedText);
parSettings.BeQuiet(true);
parSettings.LoadFromString(settingsText);
parSettings.Decode(gPar, gParFractal);
if(!systemData.noGui)
{
gMainInterface->SynchronizeInterface(gPar, gParFractal, cInterface::write);
gMainInterface->StartRender(true);
}
else
{
//in noGui mode it must be started as separate thread to be able to process event loop
gMainInterface->headless = new cHeadless;
QThread *thread = new QThread; //deleted by deleteLater()
gMainInterface->headless->moveToThread(thread);
QObject::connect(thread, SIGNAL(started()), gMainInterface->headless, SLOT(slotNetRender()));
thread->setObjectName("RenderJob");
thread->start();
QObject::connect(gMainInterface->headless, SIGNAL(finished()), gMainInterface->headless, SLOT(deleteLater()));
QObject::connect(gMainInterface->headless, SIGNAL(finished()), thread, SLOT(quit()));
QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
}
}
else
{
WriteLog("NetRender - received JOB message with wrong id");
}
break;
}
case netRender_RENDER:
{
if (inMsg->id == actualId)
{
QDataStream stream(&inMsg->payload, QIODevice::ReadOnly);
qint32 doneSize;
stream >> doneSize;
QList<int> done;
for (int i = 0; i < doneSize; i++)
{
qint32 line;
stream >> line;
done.append(line);
}
emit ToDoListArrived(done);
}
else
{
int main(int argc, char *argv[])
{
//Initialization of system functions
InitSystem();
//configure debug output
qInstallMessageHandler(myMessageOutput);
//class for interface windows
gMainInterface = new cInterface;
WriteLog("Prepare QApplication", 2);
QCoreApplication *gCoreApplication = new QCoreApplication(argc, argv);
gCoreApplication->setOrganizationName("Mandelbulber");
gCoreApplication->setApplicationName("Mandelbulber");
gCoreApplication->setApplicationVersion(MANDELBULBER_VERSION_STRING);
UpdateLanguage(gCoreApplication);
cCommandLineInterface commandLineInterface(gApplication);
if (commandLineInterface.isNoGUI())
{
gApplication = qobject_cast<QApplication *>(gCoreApplication);
}
else
{
delete gCoreApplication;
gApplication = new QApplication(argc, argv);
gApplication->setOrganizationName("Mandelbulber");
gApplication->setApplicationName("Mandelbulber");
gApplication->setApplicationVersion(MANDELBULBER_VERSION_STRING);
}
//registering types for queued connections
qRegisterMetaType<cStatistics>("cStatistics");
qRegisterMetaType<QList<QByteArray> >("QList<QByteArray>");
qRegisterMetaType<QList<int> >("QList<int>");
qRegisterMetaType<cParameterContainer>("cParameterContainer");
qRegisterMetaType<cFractalContainer>("cFractalContainer");
qRegisterMetaType<sTextures>("sTextures");
qRegisterMetaType<cProgressText::enumProgressType>("cProgressText::enumProgressType");
qRegisterMetaType<QVector<int> >("QVector<int>");
qRegisterMetaType<CVector2<double> >("CVector2<double>");
qRegisterMetaType<QMessageBox::StandardButtons>("QMessageBox::StandardButtons");
qRegisterMetaType<QMessageBox::StandardButtons*>("QMessageBox::StandardButtons*");
qRegisterMetaType<cErrorMessage::enumMessageType>("cErrorMessage::enumMessageType");
gErrorMessage = new cErrorMessage;
//create default directories and copy all needed files
WriteLog("CreateDefaultFolders()", 2);
if (!CreateDefaultFolders())
{
qCritical() << "Files/directories initialization failed" << endl;
return 73;
}
//create internal database with parameters
gPar = new cParameterContainer;
gParFractal = new cFractalContainer;
//Allocate container for animation frames
gAnimFrames = new cAnimationFrames;
//Allocate container for key frames
gKeyframes = new cKeyframes;
gPar->SetContainerName("main");
InitParams(gPar);
for (int i = 0; i < NUMBER_OF_FRACTALS; i++)
{
gParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i));
InitFractalParams(&gParFractal->at(i));
}
/****************** TEMPORARY CODE FOR MATERIALS *******************/
//InitMaterialParams(1, gPar);
//InitMaterialParams(2, gPar);
//InitMaterialParams(3, gPar);
/*******************************************************************/
//Define list of fractal formulas
DefineFractalList(&fractalList);
//Netrender
gNetRender = new CNetRender(systemData.numberOfThreads);
//loading AppSettings
if (QFile(systemData.dataDirectory + "mandelbulber.ini").exists())
{
cSettings parSettings(cSettings::formatAppSettings);
parSettings.LoadFromFile(systemData.dataDirectory + "mandelbulber.ini");
parSettings.Decode(gPar, gParFractal);
}
systemData.loggingVerbosity = gPar->Get<int>("logging_verbosity");
UpdateDefaultPaths();
if (!commandLineInterface.isNoGUI())
{
UpdateUIStyle();
UpdateUISkin();
}
UpdateLanguage(gApplication);
commandLineInterface.ReadCLI();
if (!commandLineInterface.isNoGUI())
{
gMainInterface->ShowUi();
gFlightAnimation = new cFlightAnimation(gMainInterface,
gAnimFrames,
gMainInterface->mainImage,
gMainInterface->renderedImage,
gPar,
gParFractal,
gMainInterface->mainWindow);
gKeyframeAnimation = new cKeyframeAnimation(gMainInterface,
gKeyframes,
gMainInterface->mainImage,
gMainInterface->renderedImage,
gPar,
gParFractal,
gMainInterface->mainWindow);
QObject::connect(gFlightAnimation,
SIGNAL(updateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)),
gMainInterface->mainWindow,
SLOT(slotUpdateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)));
QObject::connect(gFlightAnimation,
SIGNAL(updateProgressHide(cProgressText::enumProgressType)),
gMainInterface->mainWindow,
SLOT(slotUpdateProgressHide(cProgressText::enumProgressType)));
QObject::connect(gFlightAnimation,
SIGNAL(updateStatistics(cStatistics)),
gMainInterface->mainWindow,
SLOT(slotUpdateStatistics(cStatistics)));
QObject::connect(gKeyframeAnimation,
SIGNAL(updateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)),
gMainInterface->mainWindow,
SLOT(slotUpdateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)));
QObject::connect(gKeyframeAnimation,
SIGNAL(updateProgressHide(cProgressText::enumProgressType)),
gMainInterface->mainWindow,
SLOT(slotUpdateProgressHide(cProgressText::enumProgressType)));
QObject::connect(gKeyframeAnimation,
SIGNAL(updateStatistics(cStatistics)),
gMainInterface->mainWindow,
SLOT(slotUpdateStatistics(cStatistics)));
try
{
gQueue = new cQueue(gMainInterface,
systemData.dataDirectory + "queue.fractlist",
systemData.dataDirectory + "queue",
gMainInterface->mainWindow);
} catch (QString &ex)
{
cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex,
cErrorMessage::errorMessage);
return -1;
}
}
