Mandelbulber v2 - 2.05

[Buddhi]

Mandelbulber v2 2.05

Free download (executables for win32 and win64 and multiplatform source): http://sourceforge.net/projects/mandelbulber/
https://github.com/buddhi1980/mandelbulber2

Together with zebastian and mclarekin we have finished new version of Mandelbulber. As you see this version provides very big bundle of changes and new features.
This time main focus was on implementation of keyframe animation and to provide documentation for parameters (tooltips).


What is new?
- added keyframe animation feature. There is possible to define keyframes and interpolate different parameters between them.
- added UI for keyframe animation with table where is possible to edit each parameter.
- implemented different interpolation types for animation: Akima, Catmull-Rom, Linear. Prepared interpolation for angular parameters.
- added selection of interpolation type for each parameter separately
- added possibility to animate color palette
- added saving of animation into *.fract file in CSV format
- possible to change image format for saving animation frames
- added exporting of flight animation to keyframe animation and vice versa
- added camera collision detection before rendering of keyframe animation
- added tooltips in English, German and Polish languages (a lot of documentation here)
- added big bundle of example settings files
- histograms moved to separate dock widget
- added saving of zBuffer into PNG 16-bit and EXR floating point format (EXR supported only under Linux). zBuffer is normalized and mapped logarithmically
- added Program Settings dialog
- added settings for default file paths
- added JPG quality settings
- in preferences dialog can be defined which layers (color, zBuffer, alpha) will be attached to saved image and which bit precision will be used
- UI skin, style and font size can be set in settings dialog. You can set much smaller fonts to work on low resolution screen.
- added selection of program language in preferences dialog
- added render statistics table (under histograms)
- improved placement of auxiliary lights
- added auto-recovery function (possible to recover work after application crash)
- added experimental gamepad control for recording flight animations (actually works under Linux with Qt5.5)
- added 'GeneralizedFoldBox' formula
- added 'Mandelbulb5' formula (much extended Mandelbulb formula)
- added 'Mandelbox - extended' formula
- added 'Quaternion - extended' formula
- Added 'bailout' parameter to be able to change escape condition fractal iteration loop. By default for deltaDE it was 1e10, but lower value increases rendering speed even 5 times without loosing quality.
- added weight function for hybrid fractal components. On each fractal tab there is setting for weight (only available when hybrid mode is enabled).
- constant multiplier parameter changed to 3D vector type
- improved importing old settings from Mandelbulber 1.21
- increased precision of some QSpinBox edit fields
- optimized reset view function (now is 100x faster!)
- added UNDO and REDO buttons below RENDER button
- increased view_distance_max to 50.0 for all toolbar presets
- increased view_distance_max calculated by ResetView function
- added new example files (also with animations)
- added loading/saving setting from/to clipboard as text (possible to copy/paste settings on community forums)
- added x2 :2 buttons for increase/decrease image resolution
- named Threads to monitor cpu / mem / ... by thread
- fixes issues with compatibility witch clang
- fixed bug: corrected problems found by Coverity Scan
- fixed bug: transform function for primitive objects didn't affected repeat operator
- fixed bug: alpha channel was always blank
- fixed bug: many typos corrected
- fixed bug: animation player crashed when in animation folder were non-image files
- fixed bug: program crashed when attempted to edit text in preview cell in Animation Flight table.
- fixed bug: program didn't consider locale settings for decimal points
- fixed bug: render of main image could start multiple times after frequent clicks on RENDER button
- fixed bug: Added waiting for all clients to be ready. It's needed for animation rendering, because sometimes client is not enough fast to take new job
- fixed bug: when rendering of animation was stopped there was saved incomplete image
- fixed bug: if QColorDialog was closed by 'Cancel' button it also took color and updated button color.
- fixed bug: if camera and target had the same coordinates, it produced NaN values for camera angles and top vector
- fixed bug: default value of color was repeated many times in MyColorButton tooltip

As always every feedback is appreciated!

Source code repository (GIT, SVN) https://github.com/buddhi1980/mandelbulber2

[Patryk Kizny]

Wow! Thats a hell lot of changes! Can't wait to test! There's no GPU/opencl support as it was in 1.21 yet? Or I missed that?

[Buddhi]

Notes from mclarekin about new formulas:

Mandelbulb, Mandelbox and Quaternion extended formulas.

Within the iteration loop of the extended formulas you can use two instances ( more if you enable “hybrid formulas”) of a basic formula plus additional transforms and tweaks. These extended formula layouts were coded to experiment with and only cover some of the infinite possibilities.

Note that backward compatibility of extended formulas .fract parameter files may not be possible with future versions of Mandelbulber, if an improved UI is implemented.

Some general user notes:
- Adding more groups of parameters increases render time.
- Adding more groups can decrease quality.
- Some parameter groups (ie box fold) have stronger influence than others. You can choose to counter this my reducing the group weight and/or tweaking the “start/stop at iteration” parameters.
- You can make animations with a parameter group being smoothly transitioned from zero “weight” to full “weight” (as you can now also do with formulas using the weight function on the existing four formula tabs when “hybrid fractals” is enabled.). However you need to experiment to find which fractals, parameter groups and settings work well.
- In fact it is all about experimentation. Very few of the Mandelbulber Version 2.05 basic possibilities have been tested by those involved with writing the code.
- For the “w” parameters in the the Quaternion – extended formula, an intial non-zero number is required. I.e. In the z = z + (const.) parameter group, make the “w” parameter not equal to 0.0.
- Julia Mode and Constant Multiplier from the Option tab DO NOT work with these extended formulas. Instead use z = z + (const.) and z = z + ( c * const.) parameter groups.

[mclarekin]

The mandebulb - extended formula has several fabs() parameter groups.  Attached .fract file uses only one group,  (keeping things simple is often best). By adjusting the parameters you can see how this shape responds. In this example the fabs() parameters group starts at iteration 0, whereas the Mandelbulb formula and associated addition of constant multiplier start at iteration 1. Try changing one or both to 2 or 0.
We are using just three of the parameter groups on this extended tab, the possibilities are already possibly infinite.

Code:

# Mandelbulber settings file
# version 2.05
# only modified parameters
[main_parameters]
ambient_occlusion 1.23;
ambient_occlusion_enabled true;
background_color_1 0 5600 8f00;
background_color_2 0 5600 8f00;
background_color_3 0 5600 8f00;
camera 0.02655082137329111 -13.9998605975508 0.01146512741119407;
camera_distance_to_target 14;
camera_rotation 0 0 0;
camera_top 0 0 1;
coloring_palette_offset 55.4;
coloring_palette_size 255;
coloring_speed 2.02;
DE_factor 0.3;
flight_last_to_render 0;
formula_1 52;
keyframe_last_to_render 0;
specular 0.31;
surface_color_palette 5e869f 5e86a0 5d859f 5d859f 5c849e 5c849e 5e839e 5e839e 5d829d 5d829c 5d829d 5d829c 5c819c 5d829d 5c819b 5e829c 5d819b 5c819b 5c819b 5d809c 5c8587 a7ea29 c0ea58 455e00 c0d135 411300 fff71f 9f3100 432300 621400 ad2609 50f07 c0b07 1b0c05 320b06 221107 18100d 66829a 201404 b34301 2d1008 412001 4a2a00 321e05 3c2304 180b03 4d2900 af7011 9b4b06 321a02 261b00 904907 f18b27 d6601a 220100 160805 260704 60160b ff5344 fa3431 840902 d34036 da2013 c42507 1d0a03 b0505 150c05 2c1f0e 352611 221407 110c06 190f05 21250c 1e1b0a 130f03 775e35 213519 b0800 271201 201f0d 240d07 330708 260905 26110e 502a15 19100b 200c05 231800 a77c00 241200 614200 cf5e00 5f0000 280906 140d03 220f01 984c18 9c1801 b94f11 4c0e00 b24d00 2b1b00 e5b433 9ab298 93aecc 91aece 92afcf 95afd0 93b0d2 95afd2 94b1d3 96b0d3 98b2d5 95b2d4 97b4d6 97b4d6 97b4d6 98b5d7 98b5d7 99b6d8 9ab7d9 9ab7d9 9bb8da 9cb9db 9bb8da 9cb9db 9cbadc 9dbbdd 9dbbdd 9ebcde 9ebcde 9bbede 9cbdde 9fbddf a0bee0 a0bee0 9fc0e1 9fc0e1 9fc0df a0c1e0 a0c1e0 a1c2e1 a4bee1 a1c2e1 a1c2e1 a2c3e2 a2c3e2 a0c2de a5c4e3 a2c3e2 a4c5e4 a3c5e1 a3c5e1 a3c5e1 50402 27393d a3c6e4 8dc298 dff71f cdf34e 243300 1e0d00 4d6207 375110 3a3404 a2c1d6 a5c5de a6c6df a6c6df a5c5da a7c6da 538105 9b3c0c a98f20 690000 101302 2d372c 253324 212a0d a3c2d7 a4c3d8 a3c2d6 a2c1d5 a2c1d5 a1c0d4 a1c0d4 a0bfd4 a0bed6 93ba3d 94bd19 a4a406 bde65c 9cbbd0 9bbace 9bbace 99bacd 99bacd 98b9cc 97b8c9 96b7ca 95b6c9 94b5c8 94b5c8 93b4c7 92b3c6 91b2c5 8db0c4 8fb0c3 8eaec3 8dadc2 8aadc1 8aadc1 88abbf 87aabe 85aabd 85a8bc 83a8bb 82a6bc 81a5bb 80a4ba 7fa3b9 7ea2b8 7da1b7 7ca0b8 7b9fb7 7a9eb6 789eb3 779db4 769cb3 759bb2 749ab1 7399b0 7298af 7196b0 6e96af 6f94ae 6c94ad 6c94ad 6b93ac 6a92ab 6890a9 6890a9 678fa8 668ea7 658da6 648ca5 648ca5 638ba4 638ba4 628aa3 6189a2 6088a1 6088a1 6287a1 6287a1 ;
target 0.02655082137329111 0.0001394024491991885 0.01146512741119407;
[fractal_1]
mandelbulb5_constantMultiplier1_enabled false;
mandelbulb5_constantMultiplier1_stop_iterations 2;
mandelbulb5_constantMultiplier2_enabled true;
mandelbulb5_constantMultiplier2_start_iterations 1;
mandelbulb5_fabsFormulaAB1_enabled true;
mandelbulb5_fabsFormulaAB1A 1.5 0 0.667;
mandelbulb5_fabsFormulaAB1B 1.5 0 0.667;
mandelbulb5_main_rotation1 45 45 45;
mandelbulb5_mandelbulb1_enabled false;
mandelbulb5_mandelbulb1_power 5;
mandelbulb5_mandelbulb1_stop_iterations 2;
mandelbulb5_mandelbulb2_enabled true;
mandelbulb5_mandelbulb2_start_iterations 1;
[fractal_2]
[fractal_3]
[fractal_4]

[mclarekin]

- Added 'bailout' parameter to be able to change escape condition fractal iteration loop. By default for deltaDE it was 1e10, but lower value increases rendering speed even 5 times without loosing quality.

I need to learn more about this new feature as the render time savings can be significant.  So far I have found that with an average mandelbox type image, dropping bailout from 100 to 10, drops render time from 140s to 90s,   I think I should get into a habit of adjusting this parameter.

[taurus]

Reads quite promising. It might take a while (lot of other stuff on my mind) but I'll take a look.
Keep up! 

[cKleinhuis]

wow, impressive progress!

[Starmute]

Is a Mac binary available?

[Buddhi]

Is a Mac binary available?

Not yet, but bermarte will prepare package soon.

[Starmute]

Great, thanks.

[taurus]

Finally, I got a first small practice in mandelbulber v2.05. I had some mixed emotions.
First the things, I terribly miss, or at least could not find a similar option compared to v1.x

• automatic adjustment of raymarching multiplyer. Indispensable, especially for animation keyframe optimisation
• the measurement tool. I often need it, to identify the corner, I am looking at. (positive/negative x,y,z. Definition of a cutting plane etc.)
• the ability to hit undo after crashing (I made it within the first hour) to regain the last step

Maybe one of you can help, to find the lost functions.

Positive to mention

• speed seems much faster than 1.x, but still nothing compared to openCL
• Importing of 1.x params seems to work without glitches
• the relative step mode (moving) seems to work efficiently for the first time, although I did not understand the behaviour of different modes yet (camera, camera+target, target). In v1.x I only used absolute steps along with the arrow buttons. only point and click navigation I mosstly used relative

All in all still some way to go yet, but some good approaches.
IMHO the biggest barrier yet is, that hybridisation seems to work completely different than in m3d. I can't see any way, to get similar results there. Not to mention the inceased rendering time.

[quaz0r]

as far as speed goes, when compiling for yourself you may as well add -march=native to take advantage of simd and any other instructions added to modern cpus in the last 30 years    i personally also roll with -Ofast, which enables -ffast-math and the like.  i dont know how buddhi feels about that.  personally i figure if a computation is going to behave badly once in a while its going to happen anyway, id rather have the speed improvements than the strict IEEE compliance.  

[mclarekin]

@ quaz0r    

@ taurus.

automatic adjusting step multiplier. I want that too, With my little knowledge I can't see why not.

reinstatement of measurement  is planned to be implemented, (hopefully soon ).

I think their use to be 100 undo's (just small .fract files that got overwritten). And you could open them just like a normal .fract file, if that has changed, i would like to see it reinstated.

speed is much the same, still ordinary C++ double precision. Even running OpenCL on my old  cpu was faster, but then it is only single precision.  But as an "explorer" I prefer speed over precision. Buddhi had been waiting for  the latest version of OpenCL to be released, and now that it has, the implementation is high on the todo list. And that will be "goodbye C++" for me. And the Custom Formula tab should have lots of improvements

Navigation seems  crazy, but it is a more correct way of doing things, as you should be able to move towards a target with the camera able to move  independently , BUT it greatly frustrated me at first, (and together with the low speed), sent me straight back to V1.21 OpenCL.

Hybrids issues are complicated. With Hybrid Enabled there are now  options of number of iterations and transform weight. There is  a trade off between new features and render time. But those additions should not have changed the render time much.

If you make a hybrid including an Extended Formula, it will be slower as there are lots of enable checkboxes in the transform controls. Having few transforms opened  will increase speed but will still not be as fast as using the generally more basic original fractal tabs. Trade off.

In dev V2.06 the Menger_Sponge Extended tab has Mandelbox formulas included,  so you can make Menger/MBox hybrids running it in one single loop (much faster.)  With lots of parameters and new transform to use.

So what we have now with the Extended formulas is vast amount of possibilities for exploring, compared to previous versions,  but the additional features have a cost in render time (especially for Mandelbox due to the number of iterations before bailout,  Every additional enable checkbox multiplied by  the number of iterations)

I am hoping that eventually there will be a dynamic array, build-a-loop type feature, where you will be able to choose only the transforms you need. Maybe like how you can currently select and choose Primitive shapes. Then you can use only the transforms you require in your completed loop.

The difference with  M3D hybrids will be in the maths.  

BTW Mandelbulber dev V2.06 has reached a stage that it has become feasible for many people to simply download the source code and install QT Creator in a linux environment and build your own loops.  

Mainly copy and paste is required and some renaming to build your own loop. Below is the Mandelbox_Extended formula. You copy and paste in two lines for each formula  in the sequence you want. For the UI  you just copy a similar UI and do a search and replace on the fractal name. Delete anything you don’t want, and copy and paste in anything new. And there is not too much more than that. Writing your own transforms is not much harder.  

Example loop below

Code:

// -------------- MANDELBOX EXTENDED----------------------------
void Mandelbox103Iteration(CVector3 &z, CVector3 &c, int &i, const cFractal *fractal, sExtendedAux &aux)
{
//boxFold1 Original (enabled); 1
boxFoldOriginalTransform3D(fractal->transform.boxFoldOriginal1, z, i, aux);

// sphericalFold1 Original (enabled); 1
sphericalFoldOriginalTransform3D(fractal->transform.sphericalFoldOriginal1, z, i, aux);

//scale Original (enabled); 1
scaleOriginalTransform3D(fractal->transform.scaleOriginal1, z, i, aux);

//mainRotation1
mainRotationTransform3D(fractal->transform.mainRotation1, z, i);

//(fabs( z + const1A.) * const1.B) + z * constC.;
fabsAddConstantTransform3D(fractal->transform.fabsAddConstant1, z, i);

// z = z + ( c * const.); Original (enabled); 1
constantMultiplierOriginalTransform3D(fractal->transform.constantMultiplierOriginal1, z, c, i);

// z = z + const; 1
additionConstantTransform3D(fractal->transform.additionConstant1, z, i);

//  z = fabs( z + constA.) - fabs( z - constB.) + ( z * constC  + constD); 1
fabsFormulaABCDTransform3D(fractal->transform.fabsFormulaABCD1, z, i);

//MAIN FORMULA
//boxFold; 1
boxFoldTransform3D(fractal->transform.boxFold1, z, i, aux);

// sphericalFold1
sphericalFoldTransform3D(fractal->transform.sphericalFold1, z, i, aux);

//scale; 1
scaleTransform3D(fractal->transform.scale1, z, i, aux);

//mainRotation2
mainRotationTransform3D(fractal->transform.mainRotation2, z, i);

// z = z + c * const; 1
constantMultiplierTransform3D(fractal->transform.constantMultiplier1, z, c, i);

// z = z + const; 2
additionConstantTransform3D(fractal->transform.additionConstant2, z, i);

//mainRotation; 3
mainRotationTransform3D(fractal->transform.mainRotation3, z, i);

//  z = fabs( z + constA.) - fabs( z - constB.) + ( z * constC  + constD); 2
fabsFormulaABCDTransform3D(fractal->transform.fabsFormulaABCD2, z, i);

// Iteration weight z  =  (  z * const.Z) + (  zA * Const.A) + ( zB * Const.B);1
iterationWeightTransform3D(fractal->transform.iterationWeight1, z, i);
}

Cheers


, .

[Buddhi]

Finally, I got a first small practice in mandelbulber v2.05. I had some mixed emotions.
First the things, I terribly miss, or at least could not find a similar option compared to v1.x

• automatic adjustment of raymarching multiplyer. Indispensable, especially for animation keyframe optimisation
• the measurement tool. I often need it, to identify the corner, I am looking at. (positive/negative x,y,z. Definition of a cutting plane etc.)
• the ability to hit undo after crashing (I made it within the first hour) to regain the last step

Maybe one of you can help, to find the lost functions.

Positive to mention

• speed seems much faster than 1.x, but still nothing compared to openCL
• Importing of 1.x params seems to work without glitches
• the relative step mode (moving) seems to work efficiently for the first time, although I did not understand the behaviour of different modes yet (camera, camera+target, target). In v1.x I only used absolute steps along with the arrow buttons. only point and click navigation I mosstly used relative

All in all still some way to go yet, but some good approaches.
IMHO the biggest barrier yet is, that hybridisation seems to work completely different than in m3d. I can't see any way, to get similar results there. Not to mention the inceased rendering time.

- automatic adjustment of raymarching multiplyer: It's already on my TODO list.
- the measurement tool: It's also on my TODO list.
- the ability to hit undo after crashing: it already saves auto-recovery information. When you restart information there should be message with question about recovering of settings. Is this doesn't work or you prefer to have something like was in od Mandelbulber?
Just be patient. I'm rewriting everything from scratch, so it takes a lot of time to re-implement all functions which were in old Mandelbulber.

About hybridisation, I have no detailed algorithm how it works in Mandelbulb3D. It's very difficult to figure out how it works from published Mandelbulb3D code (a lot of assembly code)

[DarkBeam]

In mb3d formulas are executed in the selected order with the selected iteration count so you can do eg 3 iters of Mandelbox, then 1 of Menger. afterwards restarts with 3 box 1 menger etc.
Then, you have the repeat from here ... that normally is set on fo.1
So you can do 3 iters of Mandelbox, then 1 of Menger, repeat from Mandelbulb. afterwards you will calculate only mandelbulb for all following iters.
There are even iteration modifiers but it is an experimental feature
Hope it helps?