## Formulas with i Description

## Other Sections of the Guide

### Formulas with i Description

Formula Name | Description ( i ) | Formula Type |
---|---|---|

Aexion C | A bulb formula as suggested by Aexion: http://www.fractalforums.com/the-3d-mandelbulb/iterating-c/ Added two options to power-rotate the Constant by the distance of the current vectors of Z and C (Cond Phi=1), and the following Mode options: (Bits of Mode value) Bit1: Flip atan theta components Bit2: Flip atan phi components Bit3: Flip theta and phi Bit4: Flip CyCz for angle calc Bit5: Multiply powerC by the distance of vector Z and C | Escapetime |

Aex-Octo | The "Octopus formula" kindly suggested to me by Aexion. Use in Julia mode! newx= XZmul *x*z + Cx; newy= Sqmul *(-x*x + z*z) + Cy; newz = y + Cz; | Escapetime |

Aex-TorusPow | Aexion's variation of Cosine Mandelbulb - see the thread: http://www.fractalforums.com/the-3d-mandelbulb/mandeldonuts/ | Escapetime |

Benesi1Pow2 | No “i” info | Escapetime |

Benesi2Pow2 | No “i” info | Escapetime |

Benesi2Pow6 | No “i” info | Escapetime |

Benesi3Pow2 | A formula made by Benesi @fractalforums.com, one iteration: r1 = y^2 + z^2; if (Cx < 0) || (x < sqrt(r1)) {x' = x^2 - r1 + Cx} else {x' = -x^2 + r1 + Cx} r1 = - r1^-.5 * 2 * |x|; y' = r1 * (y^2 - z^2) + Cy; z' = r1 * 2 * y * z + Cz; | Escapetime |

BenesiPine1 | The cool Benesi pinetree formula; // STEP1: "Benesi fold 1" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; // STEP2: "Benesi pinetree" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx; z = t*(yt-zt)+Cy; y = 2*t*y*z+Cz; | Escapetime |

BenesiPine2 | The cool Benesi pinetree formula. Use in conjunction with normal BenesiPine1 or it is messy! Or any other formula 🙂 (Three iters of pine1 + one of pine2) // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs(sqrt(ty+z)-offset2)*scale2*sqrt(1/2) ; y=abs(sqrt(tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs(sqrt(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); z=z*sqrt(2/3)-x*sqrt(1/3); // STEP2: "Benesi pinetree" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx; z = t*(yt-zt)+Cy; y = 2*t*y*z+Cz; | Escapetime |

Beth1032 | This is one of the plenty 'Mandalabeth' formulas made by Bethchen at fractalforums.com. | Escapetime |

Beth1522 | This is one of the plenty 'Mandalabeth' formulas made by Bethchen at fractalforums.com. | Escapetime |

Beth322 | No “i” info | Escapetime |

Beth323 | Original formula by Bethchen; implemented by LucaGN 2012 | Escapetime |

Beth432 | No “i” info | Escapetime |

Beth651 | This is one of the plenty 'Mandalabeth' formulas made by Bethchen at fractalforums.com. | Escapetime |

BPine_only | Change pixel components around if you want. Using just the x pixel component (pixel_y=0 and pixel_z=0) works well in combination with the various transforms (transform 1 through 5b...) and some of the formulas like Pine1, Pine2, Pine1SquareType... //"Benesi pinetree XYZ pixel" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx; z = t*(yt-zt); y = 2*t*y*z; ;p M Benesi | Escapetime |

BristorBrot | An easy 3D formula from Doug Bristor. Found on http://bugman123.com/Hypercomplex/index.html some additional user parameters added: x' = x*x - y*y - z*z + Cx y' = y * (X_mul * x + Z_mul * z) + Cy z' = z * (X_mul * x + Y_mul * y) + Cz David Makin variation; xmul=ymul=2 & zmul=0 | Escapetime |

BT1Pine | Transform 1 with Pine Tree Mandelbulb. T1_Count is the number of times you do T1 before the PTM, if you want to increase the amount of details. Probably never need more than 3. 😀 M Benesi T1 loop: tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; :end T1Loop; | Escapetime |

BT1Pinegon | AngleIter is the iteration number that the fractal is rotated on- IN RADIANS!!#[email protected]$ NOT DEGREES!#[email protected]# (did this to save a few computations- but I actually think that M3D has a built in angle function that I can use, so will implement that later.. maybe). Use for a single iteration of rotation. A_AfterIter is the iteration number that every iteration has a rotation applied afterwords. Use to rotate every iteration past a certain point. The rotation is just the yz plane (around the x axis), for symmetry, and ease of calculations. To warp the fractal, and do other stuff, we'll have to introduce a more computationally intensive 3d rotation function (probably copy the _rotate.m3f.... :D) in the same location as the yz plane rotation. Poly iter is the iteration that the polygonal transform is applied. 3 sides= triangle. 4=square.... 😀 M Benesi :T1 loop tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; :end T1Loop //rotation is here, with conditionals to determine whether to do it or not Just a standard 2d rotation matrix around the x axis (yz-plane rotation). // Polygon transform is here // STEP2: "Benesi pinetree" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx*x_pixel_mult; z = t*(yt-zt)+Cy*y_pixel_mult; y = 2*t*y*z+Cz*z_pixel_mult; | Escapetime |

BT1Pinehedron | Transform 1 with Pine Tree Mandelbulb. T1_Count is the number of times you do T1 before the PTM, if you want to increase the amount of details. Probably never need more than 3. AngleIter is the iteration number that is rotated on- the angle is in radians, not degrees (did this to save a few computations). Use for a single iteration of rotation. A_AfterIter is the iteration number that every iteration has a rotation applied afterwords. Use to rotate every iteration past a certain point. The rotation is just the yz plane (around the x axis), for symmetry, and ease of calculations. To warp the fractal, and do other stuff, we'll have to introduce a more computationally intensive 3d rotation function (probably copy the _rotate.m3f.... :D) in the same location as the yz plane rotation. Poly Iter, and polyafteriter are to add polyhedron transforms on specific iterations.. certain iterations affect certain locations. 😉 😀 M Benesi :T1 loop tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; :end T1Loop //rotation is here, with conditionals to determine whether to do it or not // STEP2: "Benesi pinetree" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx*x_pixel_mult; z = t*(yt-zt)+Cy*y_pixel_mult; y = 2*t*y*z+Cz*z_pixel_mult; | Escapetime |

BT2Pine | Transform 2 then Pine Tree Mandelbulb. Formula translated to Mandelbulb 3D by Luca. ;p M Benesi // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs(sqrt(ty+z)-offset2)*scale2*sqrt(1/2) ; y=abs(sqrt(tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs(sqrt(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); z=z*sqrt(2/3)-x*sqrt(1/3); // STEP2: "Benesi pinetree" xt = x*x; yt = y*y; zt = z*z; t = 2*x/sqrt(yt+zt); x = xt-yt-zt+Cx; z = t*(yt-zt)+Cy; y = 2*t*y*z+Cz; | Escapetime |

BuddhiRotX3 | // Optimized by Luca GN, 25/11/2016; removed many unnecessary multiplications double tempR = 0.; double temp = 0.; //rotation around Z axis tempR = 1.0 /sqrt(z.x * z.x + z.y * z.y); temp = z.x * z.x - z.y * z.y; z.y = 2.0 * z.x * z.y; z.x = temp; z.xy *= tempR; // only x and y must be changed // and we don't do a double multip (unnecessary) //rotation around X axis tempR = 1.0 / sqrt(z.y * z.y + z.z * z.z); temp = z.y * z.y - z.z * z.z; z.z = 2.0 * z.y * z.z; z.y = temp; z.zy *= tempR; //rotation around Y axis tempR = 1.0 / sqrt(z.x * z.x + z.z * z.z); temp = z.x * z.x - z.z * z.z; z.z = 2.0 * z.x * z.z; z.x = temp; z.xz *= tempR; z = z * length(z); z += C; // the C constant vector, or the J-Seed. | Escapetime |

BuddhiRotX3b | Depending on the options the fractal can become too noisy or very distorted, to remedy try to enable the NoYZ/R^3 option; If NoYZ/R^3 = 1 -> You disable YZ rotation altogether. The second slider stops to work, and the fractal usually tends to be less fuzzy. The formula is very different though. If NoYZ/R^3 = 2 -> Multiplying by R^2 (instead by R), it tends to smooth out the fractal a little, but don't ask me about mathematical correctness 😀 If NoYZ/R^3 = 3 -> Both of the above (well, the result is not so good but you choose). | Escapetime |

Bulbox | A hybrid of a sine power 2 bulb and the amazing box, the 3d vector length decides which formula is used: If it is bigger than 'Box/Bulb R threshold' the amazing box is used, else if smaller than '..threshold 2' the sine bulb, inbetween both formulas will be interpolated. Make the second threshold a little smaller than the first for more smoothness. | Escapetime |

BulboxP-2 | This is the concept; - At first do a Tglad folding - Calculate radius = cabs(x,y,z) - Scale the vector - Raise to power -2 the vector (according to W/N theory), and store in Tvec // W/N power -2 formula is (with unsharpening factor); // Tvec = [ ( x*x - y*y ) a ; -2*x*y*a ; -2*z*rxy*izM ] * pow(radius,-4) // and rxy = sqrt(x*x+y*y+Unsh), a = 1 - (z/rxy)^2 // (Yes both z and y have negative sign, that's why a neg ISc is better) - If radius > 1, just add C. (Gives the boxy look, never executed in "Disable box" mode) - ElseIf radius < InR, vector = ISc*Tvec + Cvec (apply the exponentiation) - Else; (interpolation, necessary to remove branch cuts) k = (R-InR)/(1-InR) x = ISc*Tvecx * (1-k) + oldx * k + Cx y = ISc*Tvecy * (1-k) + oldy * k + Cy z = ISc*Tvecz * (1-k) + oldz * k + Cz - Now multiply the vector by the scale - Finally add C The result is full of discontinuities and odd, but you might like it. Luca GN 2011 | Escapetime |

CosAziTwoStage | Experimental formula, obtained doing two different formulas subsequently; 1) Power 4 Cosine Bulb formula, without adding C; 2) Power 2 Azimuthal, adding C. (Total power; 2 x 4 = 8) Azimuthal formula by bugman; http://www.fractalforums.com/theory/3d-mandelbrot-formula-based-on-rotation-away-from-azimuthal-axis/ It has interesting features and it looks different from the original bulbs. | Escapetime |

CosAziTwoStageInv | Experimental formula, obtained doing two different formulas subsequently; 1) Power 2 Azimuthal formula, without adding C; 2) Power 4 Cosine Bulb, adding C. (Total power; 2 x 4 = 8) Azimuthal formula by bugman; http://www.fractalforums.com/theory/3d-mandelbrot-formula-based-on-rotation-away-from-azimuthal-axis/ It has interesting features and it looks different from the original bulbs. | Escapetime |

CosinePow2 | No “i” info | Escapetime |

CosinePow7 | As theorized by bugman; http://www.fractalforums.com/index.php?topic=2062.msg9019 This is the non-trigonometric power 7 mandelbulb, cosine variation. a = load1() + Cns[2]/r6*(z6-Cns[4]*z4*r2+Cns[3]*z2*r4); // ------------------- px *= (-a)*(x6+Cns[0]*x4*y2 +Cns[1]*x2*y4+Cns[2]*y6); py *= a*(y6+Cns[0]*y4*x2 +Cns[1]*y2*x4+Cns[2]*x6); pz *= z6 + Cns[2]*r2*(Cns[3]*z4-Cns[4]*z2*r2+r4); // add c and return px = px + cfg->Cx; py = py + cfg->Cy; pz = pz + cfg->Cz; | Escapetime |

CosinePow8 | No “i” info | Escapetime |

CosSinTwoStage | Experimental formula, obtained doing two different formulas subsequently; 1) Power 4 Cosine formula, without adding C; 2) Power 2 Sine Bulb, adding C. (Total power; 2 x 4 = 8) It has interesting features and it looks different from the original bulbs. | Escapetime |

Folding Int Pow | A sine integer power bulb with foldings before, like in the amazing box. | Escapetime |

Integer Power | The triplex math sine bulb, as suggested by Daniel White and Paul Nylander. These are fast implementions of powers of 2,3,4,5,6,7 and 8. If you want to make an animation with smooth power changings, please use the 'Real Power' formula. | Escapetime |

Real Power | The sine bulb where arbitrary power values can be used, the calculation is slower than of integer powers. r = sqrt(x*x + y*y + z*z) th = ArcTan2(y, x) * Float_power ph = ArcSin(z/r) * Float_power r = Power(r, Float_power) x = r * cos(ph) * cos(th) + Cx y = r * cos(ph) * sin(th) + Cy z = Z_multiplier * r * sin(ph) + Cz | Escapetime |

Tricorn | No “i” info | Escapetime |

_cylripple | You are warned; this transform may slow down and/or cause de trouble. If used correctly it can give a cool "ripple" effect... 1)Rotates the reference axis by selected angles Use with caution this option! NOTE; this will NOT affect C! 2) calculate (rho,theta): = tocylindical(x,y) (or Cx,Cy if asked) (note that if you use c you may get a very odd result sometimes!) let t1=u;t2=v; 3) cylindrical waves: u = La*sin(Lf*u); v = Ta*sin(Tf*v); 4) (x,y) := invcyl(t1*(1+u+v),t2); 3)Rotates the reference axis at the inital position (transposed rot. matrix) NOTE; this will NOT affect C! 2011 - Luca GN | Escapetime |

_DEComb_ISph_Plane | As the name states, this should be used only as the 1st transform on DeCombinates. It's a combiantion of a _SphereInv (1st iter) and a _SquareR (all other iters). Much more flexible than the normal _SquareR to get bubbles, planes or even inverse bubbles! Use Move controls to move the position of the object and Inv Center to tweak the effect. The effect will be gorgeous (a kind of deforming mirror) if the reflections are enabled. | Escapetime |

_e_3Dtess | This is a fractal non-linear tessellation in 3D (Escher's cubic tessellation). It's inspired by the famous Escher incision "Square limit". Escher's idea is much more complicate, I simplified to the essence the concept, removing his rotations (they were too tricky to code for me!). Every tile is a cube, smaller and smaller... The limit is another cube. It's already very complicated, due to the many rules and exceptions... Axiom can be a value from 0 to 3. Allow greater values is clueless, due to the strength of the scaling. You can change the effect acting with the scales and shifting the center. Use it as a pretransform only! Don't go too far with depth, or you will disturb DE with a "sand" of tiny objects, and the render will be slowed down. | Escapetime |

_IFS_tess | Be sure to apply this as a pretransform only with one iteration, I don't know what happens if you don't do so. This is a fractal linear tessellation in 3D (well, it looks more like 2D anyway). Uses an approximation of the IFS method. Remember, I said an approximation... So, you don't get the *same* result that you can get with "probability method", but you get it very faster and if you adjust parameters you can get very nice fractals. Remember that IFS programs need to allocate huge amounts of memory and take a long time for their computations, so approximation is also an advantage in terms of time. Anyway, this transform *must* be used as pre transform. NEVER iterate it, but change maxdepth instead. Don't worry, iterations are auto-limited to 40 (you will never need more than 20-25 iterations, anyway... 🙂 ) Everything outside the gasket will be brutally cutted off. It's necessary for a correct visualization. Always use an appropriate scale adjustment. TINY GUIDE: HOW TO GET SOME NICE FRACTALS Supposing to leave every other param as default: VARIATION = 1 + ROTAXIOM = -45 -> Heighway dragon (nicely curly) VARIATION = 0 + ROTAXIOM = 45 + ATOMSIZE = .5 + SCALE = 2 -> Twindragon (less disperse) VARIATION = 2 + ROTAXIOM = -45 -> Levy C "tree" VARIATION = 4 + ROTAXIOM = 45 + SCALE&DISP = 1 + ATOM = 1.1 -> Pytagoras tree (it's larger than dragons, zoom out) VARIATION = 4 + ROTAXIOM = 90 + SCALE&DISP = 1 + ATOM = 1.1 -> Mandelbrot tree (it's larger than dragons, zoom out) VARIATION = 4 + ROTAXIOM = 60 + SCALE&DISP = 1 + ATOM = 1.1 -> Equilateral tree (it's larger than dragons, zoom out) More equilateral variations: angle 30, 120 ... experiment by yourself and find new variations 🙂 Encoded directly from scratch, LucaGN 2011. I found very useful IDeviant's PDF tutorial for Pytagoras trees, so thank you! I also enclose the important part of the source code. Very simple, IFS transforms are simple! (... some checks and initializations. move y to x0, z to y0) loopbegin: if variation > 3 // Pytagoras mode k = abs(x0) if x0 != 0 k = k / x0 endif xt = x0 - k * dispersion yt = y0 - 2 * dispersion if k > 0 x0 = (+xt*cos(angle) - yt*sin(angle)) y0 = (+xt*sin(angle) + yt*cos(angle)) else x0 = (+xt*cos(angle) + yt*sin(angle)) y0 = (-xt*sin(angle) + yt*cos(angle)) endif else // Dragon mode k=1 if x0 > y0 x0 = x0 - dispersion*(sqrt(2)/2) else y0 = y0 - dispersion*(sqrt(2)/2) k=-k endif x0t = x0 x0 = (+x0t*cos(angle) - y0*sin(angle)) y0 = (+x0t*sin(angle) + y0*cos(angle)) if k>0 ( ... depending to the value of variation, swaps/changes sign of x&y) endif xt = x0 / (sqrt(2)/2) yt = y0 / (sqrt(2)/2) if abs(xt)< atomsz && abs(yt)< atomsz x = xt y = yt ( and exit loop ... else control iteration count) goto loopbegin (... then scale it, translate back. If no iter was performed, cut off. Take care of obvious special cases, like when x & y initially are < than atomsz. etc.) | Escapetime |

_MobiusTpx | This is an attempt to extend the Mobius transformation (that normally implies complex numbers) in the 3D triplex space. See Wikipedia for an explanation of what is a Mobius transform (in 2D complex plane). Why you need it? Well, with *conditional* M. transforms you can for example create quasi-fuchsian fractals, if you set all params correctly. This needs "very specialistic knowledge", because you need to use a set of appropriate parameters and conditions in order to get the correct effect. 2D conditional Mobius transforms give the famous fractals described in "Indra's pearls" book. Rewrite the triplex theory here is pointless. So check the forum; http://www.fractalforums.com/theory/triplex-algebra/ I used the so-called "non-trig forms", because they are much faster. Basically here is a rough transcription of the formula; T1 = a t* S + b if mod(T1) <= 1e-90 S' = (1e90,1e90,1e90) else T0 = a t* S + c S' = T0 t/ T1 endif T0 and T1 are 3d temporary vectors, that I must use for the computation because the transform is composite where as usual S contains the spatial coordinates x,y,z. t* is the triplex multiplication as defined in the topic. t/ is the triplex division as defined in the topic. | Escapetime |

_mulC3D | Multiplies current vector by a vector V defined as follows U = (cA*c + xyzA*xyz) * RotMatrix V = (Const + U) Theory used; White-Nylander. This can give a wide variety of rotation-type effects. | Escapetime |

_quadist | Quadratic distorsion in 3D. Gives a huge number of strange deformations used as pretransform. Use linear terms=1 and very small coeffs to get a "gentle" distorsion Works well also as an "attractor" if used alone, giving funny 3D shapes Here is the expression. Has something to do with matrix expressions; x' = x*scale + (d-a) x*x + (e-b) y*y + (f-c) z*z y' = y*scale + (f-a) x*x + (d-b) y*y + (e-c) z*z z' = z*scale + (e-a) x*x + (f-b) y*y + (d-c) z*z Formula by Luca GN 2011 | Escapetime |

_Rpow3 | Does a power of 3 on the current length of the 3d vector. Is faster than squaring. x = x * sqrRout y = y * sqrRout z = z * sqrRout | Escapetime |

_SinePow2 | Does the transformation like the sine power 2 bulb, but without adding C. You can use it for example 3 times and then adding c to make a power 8 bulb clone. | Escapetime |

_sphereinv | Sphere inversion in 3D with radius and center.
Fold mode; enable this to get conditional inversions.
MODE 1; inversion INSIDE a sphere. Choose Rad2 | Escapetime |

_SphereInvC | Complete sphere inversion of the vector and the adding constant: rSqrL = 1 / (Cx*Cx + Cy*Cy + Cz*Cz) Cx = Cx * rSqrL Cy = Cy * rSqrL Cz = Cz * rSqrL rSqrL = 1 / (x*x + y*y + z*z) x = x * rSqrL y = y * rSqrL z = z * rSqrL Suggestion: Doing it one time as first formula, repeat on the second, will invert the complete coord system. Cut off at Z=0 to see the inside. | Escapetime |

_SquareR | Squares the current length of the 3d vector. m = sqrRout / Sqrt(sqrRout) x' = x * m y' = y * m z' = z * m | Escapetime |

CosSinTwoStageInv | Experimental formula, obtained doing two different formulas subsequently; 1) Power 2 Cosine formula, without adding C; 2) Power 4 Sine Bulb, adding C. (Total power; 2 x 4 = 8) It has interesting features and it looks different from the original bulbs. | Escapetime |

Faehrten | Formula by Trafassel, found in Gestaltlupe files, added more parameters and terms. It looks like an "hyperbolic" Mandelbrot. Nice Julia sets. (original version had Squares mul = -0.5) x' = x (y*ymul+z*zmul) + Cx y' = y*y - sqmul*(x*x+z*z) + twist*x*z + Cy z' = z*z - sqmul*(x*x+y*y) + twist*x*y + Cz Luca GN 2011 | Escapetime |

Fuzzy | No “i” info | Escapetime |

General | With this you can obtain "almost" every imaginable bulb formula. The principle is simple; you can choose which angles to use, and do other tweaking. The function used is atan2() but any inverse trig function can be obtained from it. Here a "reference" of the meaning of some symbols. - args - In this section h(a,b) is C/C++ hypot() function and matches normal Euclidean metric. u(a,b) returns the greater value between abs(a), abs(b). It is a different metric, used in some IFS fractals like Mengers. d(a,b) returns the lesser value between abs(a), abs(b). Another metric... 00 to 05 are standard coupled signed axis in this order; x,y / x,z / y,x / y,z / z,x / z,y Those angles are useful to get atan2() function, or atan() (that is less symmetrical) - see also tweaks. 06 to 11 are for arcsin() and arccos() functions; x, h(z,y) / y, h(x,z) / z, h(x,y) / h(z,y), x / h(x,z), y / h(x,y), z Those are used in familiar "Mandelbulbs" to evaluate the z angle. 12 to 17 are new kind of functions; x, u(z,y) / y, u(x,z) / z, u(x,y) / u(z,y), x / u(x,z), y / u(x,y), z Use those functions to get funny "squarry" bulbs. 18 to 23 are new kind of functions; x, d(z,y) / y, d(x,z) / z, d(x,y) / d(z,y), x / d(x,z), y / d(x,y), z Don't ask me what happens when you use those functions, try by yourself! DO NOT USE OTHER VALUES or you will fall in an intentional bug. (reserved for future use) - tweaks - You have no tweak active when tweak = 0. You have ATAN active when tweak = 1. You have XENO active when tweak = 2. You have ATAN and XENO active when tweak = 2. DO NOT USE OTHER VALUES. ATAN is useful to get a different look, less symmetric. Can't exactly explain this, but works. XENO does a folding on the angle forcing it to be in the range -pi/2 ... +pi/2. The effect is similar to abs() function, but in reality it is NOT the same. In fact you can use XENO + abs() and still see a difference. See this post; http://www.fractalforums.com/index.php?topic=742.msg8288#msg8288 (thank you!) - abs - This is executed before anything else, and makes abs() of the chosen axis on request, use a nonzero value to make cool variations. SPECIAL abs mode; use -1 to add the absolute value of c (not plain c) on request. (Forces symmetrical mandels) - recipe - We have three recipes implemeted; 0 = NORMAL. 1 = COSINE. 2 = REVERSED. See http://www.fractalforums.com/theory/summary-of-3d-mandelbrot-set-formulas/ for technical info. (thank you!) Implemented by Luca G.N. 2011 | Escapetime |

GenIntPower | Derived from an idea from Aexion to also rotate the adding constant in addition to a bulb formula. This is the corresponding nearly universal bulb triplex formula that can be used standalone or in combination with the _IntPowRotateC formula. Rotation powers can be 2..11 (integer). The vector components for the complex rotation types are: 0: x|y 1: x|z 2: y|z 3: Rxy|z 4: Rxz|y 5: Ryz|x 6: y|x 7: z|x 8: z|y 9: z|Rxy 10: y|Rxz 11: x|Ryz | Escapetime |

IdesFormula | A formula made by Trafassel, the original Ide's Formula thread: http://www.fractalforums.com/videos/formula-21-%28julia-set-interpretation%29/ Formula, one iteration: x' = X_mul * x*x - (y*y + z*z) * Xsub_mul + cx; y' = Y_mul * x*y*z + cy; z' = Z_mul * z*z - (x*x + y*y) * Zsub_mul + cz; | Escapetime |

Ikenagabulb | Ikenaga map 3D, using White-Nylander triplex theory. Beautiful Julia sets (but not so good M-set...) Please, note that this function is faithful to UF 2D projection for the Julia, but differs for the M-set. This is due to the fact that M-set correct formula should be plotted after a "pretransform" like this init: ( S' = C ) -> this is done automatically by MB3D itself S'' = sqrt((1-S')/K) (this must be done manually) Where K is a constant 3D vector: (3.0 , 0.0, 0.0) - or simply a scaling by an equivalent factor ---------------------------------------------- This function was originally described in "The Armchair Universe" book. Added two user multiplicative constants a & b S' = S^3 + S*a*C - S*b - C S contains x,y,z and C contains the constants. The code is very long, because every multiplication implies 3D rotations and other "stuff" like. Plus, we need to use the stack because we must keep many temporary stuff in memory during calculus. Implemented by Luca GN 2011 | Escapetime |

IQ_NormBulb | This formula was proposed by Inigo Quilez in 2009 as a "correction" of Mandelbulb formula. http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm sq_r := sqrt(x*x+y*y+z*z) sq_xz := sqrt(x*x+z*z) r:= sq_r ^ Power theta = acos(y/sq_r) * P = atan2( sq_xz , y) * P // This is true everywhere, because sq_r is >=0 ; atan2(a,b) differs from atan(a/b) when b<0 // I must use atan2 because 'acos' is missing in assembly. zangle = atan2(x,z) * zAP x := sin(zangle)*sin(theta)*r+Cx y := cos(theta) *r+Cy z := sin(theta)*cos(zangle)*r+Cz Implemented by Luca G.N. 2011 01007010 55 PUSH EBP 01007011 8BEC MOV EBP,ESP 01007013 81EC 40000000 SUB ESP,40 01007019 53 PUSH EBX 0100701A 56 PUSH ESI 0100701B 57 PUSH EDI 0100701C 8B75 08 MOV ESI,DWORD PTR SS:[EBP+8] 0100701F 8B7E 30 MOV EDI,DWORD PTR DS:[ESI+30] 01007022 8BD8 MOV EBX,EAX 01007024 D9D0 FNOP 01007026 DD03 FLD QWORD PTR DS:[EBX] 01007028 D8C8 FMUL ST,ST // x^2 stack = 1 0100702A DD02 FLD QWORD PTR DS:[EDX] 0100702C D8C8 FMUL ST,ST // y^2 stack = 2 0100702E DD01 FLD QWORD PTR DS:[ECX] 01007030 D8C8 FMUL ST,ST //z*z stack = 3 01007032 DEC1 FADDP ST(1),ST //y^2+z^2 stack = 2 01007034 DEC1 FADDP ST(1),ST //x^2+y^2+z^2 stack=1 01007036 D9FA FSQRT 01007038 DD55 F8 FST QWORD PTR SS:[EBP-8] // r=EBP-8 r on top of stack 0100703B DD47 F0 FLD QWORD PTR DS:[EDI-10] // what is EDI 10 again?? EDI-10 is [email protected][email protected]$ 0100703E D9C9 FXCH ST(1) // r on top 01007040 D9E1 FABS // abs abs (r) 01007042 D9F1 FYL2X //log_2 (r) 01007044 D9E8 FLD1 // load value 1 to top of stack 3 on 01007046 D9C1 FLD ST(1) // load r to top 4 on stack 01007048 D9F8 FPREM // remainder of r/1 4 on stack 0100704A D9F0 F2XM1 // ST(0) *2 -1 0100704C DEC1 FADDP ST(1),ST // st(0)*2 3 on stack 0100704E D9FD FSCALE // st(0) * 2 st(1) //truncates st(1) to integer downwards // st(1) 2 on stack 01007050 D9C9 FXCH ST(1) // necessary??? 2 on stack 01007052 DDD8 FSTP ST // st=st(1)??? 01007054 DD5D F0 FSTP QWORD PTR SS:[EBP-10] // EBP-10 = above??? r^power 01007057 DD02 FLD QWORD PTR DS:[EDX] // load y 01007059 D8C8 FMUL ST,ST // y*Y 0100705B DD01 FLD QWORD PTR DS:[ECX] // load z 0100705D D8C8 FMUL ST,ST // z*z 0100705F DEC1 FADDP ST(1),ST // y*y+z*z 01007061 D9FA FSQRT // sqrt( xxx) stack only 1 01007063 DD55 E8 FST QWORD PTR SS:[EBP-18] // ebp-18 = R2 01007066 DD03 FLD QWORD PTR DS:[EBX] // load x stack 2 01007068 D9F3 FPATAN // atab (st(1)/st(0)) == atan (x/r2) stack 1 0100706A DC4F F0 FMUL QWORD PTR DS:[EDI-10] // .. * EDI-10=power * theta 0100706D D9FB FSINCOS // cos (..) , sin (...) stack 2 0100706F DD5D D8 FSTP QWORD PTR SS:[EBP-28] // ebp-28 = cos(theta) stack 1 01007072 DD5D E0 FSTP QWORD PTR SS:[EBP-20] // ebp-20 = sin (..) stack empty 01007075 90 NOP 01007076 DD02 FLD QWORD PTR DS:[EDX] // load y 01007078 DD01 FLD QWORD PTR DS:[ECX] // load z 0100707A D9F3 FPATAN // atan (y/z) 0100707C DC4F E8 FMUL QWORD PTR DS:[EDI-18] // zanglepower * atan(y/z) ??? 0100707F D9FB FSINCOS // 01007081 DD5D C8 FSTP QWORD PTR SS:[EBP-38] // EBP-38 = cos (...) 01007084 DD5D D0 FSTP QWORD PTR SS:[EBP-30] // EBP-30 = sin (...) stack empty 01007087 D9D0 FNOP 01007089 DD45 E0 FLD QWORD PTR SS:[EBP-20] // cos (theta) 0100708C DC4D D0 FMUL QWORD PTR SS:[EBP-30] // *cos (phi) // took this out 558BEC81EC400000005356578B75088B7E308BD8D9D0DD03D8C8DD02D8C8DD01 D8C8DEC1DEC1D9FADD55F8DD47F0D9C9D9E1D9F1D9E8D9C1D9F8D9F0DEC1D9FD D9C9DDD8DD5DF0DD02D8C8DD01D8C8DEC1D9FADD55E8DD03D9F3DC4FF0D9FBDD 5DD8DD5DE090DD02DD01D9F3DC4FE8D9FBDD5DC8DD5DD0D9D0DD45E0DC 4DF0DC4618DD1BDD45D8DC4DF0DC4620DD1ADD45E0DC4DC8DC4FE0DC4DF0DC46 28DD19D9D08BC35F5E5B8BE55DC20800 | Escapetime |

IQ_NormBulb_NoYZ | This formula was proposed by Inigo Quilez in 2009 as a "correction" of Mandelbulb formula. http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm sq_r := sqrt(x*x+y*y+z*z) sq_xz := sqrt(x*x+z*z) r:= sq_r ^ Power theta = acos(y/sq_r) * P = atan2( sq_xz , y) * P // This is true everywhere, because sq_r is >=0 ; atan2(a,b) differs from atan(a/b) when b<0 // I must use atan2 because 'acos' is missing in assembly. zangle = atan2(x,z) * zAP x := sin(zangle)*sin(theta)*r+Cx y := cos(theta) *r+Cy z := sin(theta)*cos(zangle)*r+Cz Implemented by Luca G.N. 2011 01007010 55 PUSH EBP 01007011 8BEC MOV EBP,ESP 01007013 81EC 40000000 SUB ESP,40 01007019 53 PUSH EBX 0100701A 56 PUSH ESI 0100701B 57 PUSH EDI 0100701C 8B75 08 MOV ESI,DWORD PTR SS:[EBP+8] 0100701F 8B7E 30 MOV EDI,DWORD PTR DS:[ESI+30] 01007022 8BD8 MOV EBX,EAX 01007024 D9D0 FNOP 01007026 DD03 FLD QWORD PTR DS:[EBX] 01007028 D8C8 FMUL ST,ST // x^2 stack = 1 0100702A DD02 FLD QWORD PTR DS:[EDX] 0100702C D8C8 FMUL ST,ST // y^2 stack = 2 0100702E DD01 FLD QWORD PTR DS:[ECX] 01007030 D8C8 FMUL ST,ST //z*z stack = 3 01007032 DEC1 FADDP ST(1),ST //y^2+z^2 stack = 2 01007034 DEC1 FADDP ST(1),ST //x^2+y^2+z^2 stack=1 01007036 D9FA FSQRT 01007038 DD55 F8 FST QWORD PTR SS:[EBP-8] // r=EBP-8 r on top of stack 0100703B DD47 F0 FLD QWORD PTR DS:[EDI-10] // what is EDI 10 again?? EDI-10 is [email protected][email protected]$ 0100703E D9C9 FXCH ST(1) // r on top 01007040 D9E1 FABS // abs abs (r) 01007042 D9F1 FYL2X //log_2 (r) 01007044 D9E8 FLD1 // load value 1 to top of stack 3 on 01007046 D9C1 FLD ST(1) // load r to top 4 on stack 01007048 D9F8 FPREM // remainder of r/1 4 on stack 0100704A D9F0 F2XM1 // ST(0) *2 -1 0100704C DEC1 FADDP ST(1),ST // st(0)*2 3 on stack 0100704E D9FD FSCALE // st(0) * 2 st(1) //truncates st(1) to integer downwards // st(1) 2 on stack 01007050 D9C9 FXCH ST(1) // necessary??? 2 on stack 01007052 DDD8 FSTP ST // st=st(1)??? 01007054 DD5D F0 FSTP QWORD PTR SS:[EBP-10] // EBP-10 = above??? r^power 01007057 DD02 FLD QWORD PTR DS:[EDX] // load y 01007059 D8C8 FMUL ST,ST // y*Y 0100705B DD01 FLD QWORD PTR DS:[ECX] // load z 0100705D D8C8 FMUL ST,ST // z*z 0100705F DEC1 FADDP ST(1),ST // y*y+z*z 01007061 D9FA FSQRT // sqrt( xxx) stack only 1 01007063 DD55 E8 FST QWORD PTR SS:[EBP-18] // ebp-18 = R2 01007066 DD03 FLD QWORD PTR DS:[EBX] // load x stack 2 01007068 D9F3 FPATAN // atab (st(1)/st(0)) == atan (x/r2) stack 1 0100706A DC4F F0 FMUL QWORD PTR DS:[EDI-10] // .. * EDI-10=power * theta 0100706D D9FB FSINCOS // cos (..) , sin (...) stack 2 0100706F DD5D D8 FSTP QWORD PTR SS:[EBP-28] // ebp-28 = cos(theta) stack 1 01007072 DD5D E0 FSTP QWORD PTR SS:[EBP-20] // ebp-20 = sin (..) stack empty 01007075 90 NOP 01007076 DD02 FLD QWORD PTR DS:[EDX] // load y 01007078 DD01 FLD QWORD PTR DS:[ECX] // load z 0100707A D9F3 FPATAN // atan (y/z) 0100707C DC4F E8 FMUL QWORD PTR DS:[EDI-18] // zanglepower * atan(y/z) ??? 0100707F D9FB FSINCOS // 01007081 DD5D C8 FSTP QWORD PTR SS:[EBP-38] // EBP-38 = cos (...) 01007084 DD5D D0 FSTP QWORD PTR SS:[EBP-30] // EBP-30 = sin (...) stack empty 01007087 D9D0 FNOP 01007089 DD45 E0 FLD QWORD PTR SS:[EBP-20] // cos (theta) 0100708F DC4D F0 FMUL QWORD PTR SS:[EBP-10] // * r^power 01007092 DC46 18 FADD QWORD PTR DS:[ESI+18] // + xpixel 01007095 DD1B FSTP QWORD PTR DS:[EBX] // save new x stack empty | Escapetime |

IQ_PineTree | This formula was proposed by Inigo Quilez in 2009 as a "correction" of Mandelbulb formula. http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm sq_r := sqrt(x*x+y*y+z*z) sq_xz := sqrt(y*y+z*z) r:= sq_r ^ Power theta = atan2( sq_yz , x) * P // This is true everywhere, because sq_r is >=0 ; atan2(a,b) differs from atan(a/b) when b<0 // I must use atan2 because 'acos' is missing in assembly. zangle = atan2(y,z) * zAP x := cos(theta)*r +Cx y := sin(theta)*sin(zangle)*r +Cy // y and z cos and sin are switched for pine tree version.... z := sin(theta)*cos(zangle)*r +Cz Implemented by Luca G.N. 2011 01007010 55 PUSH EBP 01007011 8BEC MOV EBP,ESP 01007013 81EC 40000000 SUB ESP,40 01007019 53 PUSH EBX 0100701A 56 PUSH ESI 0100701B 57 PUSH EDI 0100701C 8B75 08 MOV ESI,DWORD PTR SS:[EBP+8] 0100701F 8B7E 30 MOV EDI,DWORD PTR DS:[ESI+30] 01007022 8BD8 MOV EBX,EAX 01007024 D9D0 FNOP 01007026 DD03 FLD QWORD PTR DS:[EBX] 01007028 D8C8 FMUL ST,ST // x^2 stack = 1 0100702A DD02 FLD QWORD PTR DS:[EDX] 0100702C D8C8 FMUL ST,ST // y^2 stack = 2 0100702E DD01 FLD QWORD PTR DS:[ECX] 01007030 D8C8 FMUL ST,ST //z*z stack = 3 01007032 DEC1 FADDP ST(1),ST //y^2+z^2 stack = 2 01007034 DEC1 FADDP ST(1),ST //x^2+y^2+z^2 stack=1 01007036 D9FA FSQRT 01007038 DD55 F8 FST QWORD PTR SS:[EBP-8] // r=EBP-8 r on top of stack 0100703B DD47 F0 FLD QWORD PTR DS:[EDI-10] // what is EDI 10 again?? EDI-10 is [email protected][email protected]$ 0100703E D9C9 FXCH ST(1) // r on top 01007040 D9E1 FABS // abs abs (r) 01007042 D9F1 FYL2X //log_2 (r) 01007044 D9E8 FLD1 // load value 1 to top of stack 3 on 01007046 D9C1 FLD ST(1) // load r to top 4 on stack 01007048 D9F8 FPREM // remainder of r/1 4 on stack 0100704A D9F0 F2XM1 // ST(0) *2 -1 0100704C DEC1 FADDP ST(1),ST // st(0)*2 3 on stack 0100704E D9FD FSCALE // st(0) * 2 st(1) //truncates st(1) to integer downwards // st(1) 2 on stack 01007050 D9C9 FXCH ST(1) // necessary??? 2 on stack 01007052 DDD8 FSTP ST // st=st(1)??? 01007054 DD5D F0 FSTP QWORD PTR SS:[EBP-10] // EBP-10 = above??? r^power 01007057 DD02 FLD QWORD PTR DS:[EDX] // load y 01007059 D8C8 FMUL ST,ST // y*Y 0100705B DD01 FLD QWORD PTR DS:[ECX] // load z 0100705D D8C8 FMUL ST,ST // z*z 0100705F DEC1 FADDP ST(1),ST // y*y+z*z 01007061 D9FA FSQRT // sqrt( xxx) stack only 1 01007063 DD55 E8 FST QWORD PTR SS:[EBP-18] // ebp-18 = R2 01007066 DD03 FLD QWORD PTR DS:[EBX] // load x stack 2 01007068 D9F3 FPATAN // atab (st(1)/st(0)) == atan (x/r2) stack 1 0100706A DC4F F0 FMUL QWORD PTR DS:[EDI-10] // .. * EDI-10=power * theta 0100706D D9FB FSINCOS // cos (..) , sin (...) stack 2 0100706F DD5D D8 FSTP QWORD PTR SS:[EBP-28] // ebp-28 = cos(theta) stack 1 01007072 DD5D E0 FSTP QWORD PTR SS:[EBP-20] // ebp-20 = sin (..) stack empty 01007075 90 NOP 01007076 DD02 FLD QWORD PTR DS:[EDX] // load y 01007078 DD01 FLD QWORD PTR DS:[ECX] // load z 0100707A D9F3 FPATAN // atan (y/z) 0100707C DC4F E8 FMUL QWORD PTR DS:[EDI-18] // zanglepower * atan(y/z) ??? 0100707F D9FB FSINCOS // 01007081 DD5D C8 FSTP QWORD PTR SS:[EBP-38] // EBP-38 = cos (...) 01007084 DD5D D0 FSTP QWORD PTR SS:[EBP-30] // EBP-30 = sin (...) stack empty 01007087 D9D0 FNOP 558BEC81EC400000005356578B75088B7E308BD8D9D0DD03D8C8DD02D8C8DD01 D8C8DEC1DEC1D9FADD55F8DD47F0D9C9D9E1D9F1D9E8D9C1D9F8D9F0DEC1D9FD D9C9DDD8DD5DF0DD02D8C8DD01D8C8DEC1D9FADD55E8DD03D9F3DC4FF0D9FBDD 5DD8DD5DE090DD02DD01D9F3DC4FE8D9FBDD5DC8DD5DD0D9D0DD45D8DC 4DF0DC4618DD1BDD45E0DC4DC8DC4DF0DC4620DD1ADD45E0DC4DD0DC4FE0DC4DF0DC46 28DD19D9D08BC35F5E5B8BE55DC20800 01007089 DD45 D8 FLD QWORD PTR SS:[EBP-28] // load cos (theta) 0100708F DC4D F0 FMUL QWORD PTR SS:[EBP-10] // * r^power 01007092 DC46 18 FADD QWORD PTR DS:[ESI+18] // + xpixel 01007095 DD1B FSTP QWORD PTR DS:[EBX] // save new x stack empty | Escapetime |

IQ_PineTree_NoYZ | This formula was proposed by Inigo Quilez in 2009 as a "correction" of Mandelbulb formula. http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm sq_r := sqrt(x*x+y*y+z*z) sq_xz := sqrt(y*y+z*z) r:= sq_r ^ Power theta = atan2( sq_yz , x) * P // This is true everywhere, because sq_r is >=0 ; atan2(a,b) differs from atan(a/b) when b<0 // I must use atan2 because 'acos' is missing in assembly. zangle = atan2(y,z) * zAP x := cos(theta)*r +Cx y := sin(theta)*sin(zangle)*r z := sin(theta)*cos(zangle)*r Implemented by Luca G.N. 2011 01007010 55 PUSH EBP 01007011 8BEC MOV EBP,ESP 01007013 81EC 40000000 SUB ESP,40 01007019 53 PUSH EBX 0100701A 56 PUSH ESI 0100701B 57 PUSH EDI 0100701C 8B75 08 MOV ESI,DWORD PTR SS:[EBP+8] 0100701F 8B7E 30 MOV EDI,DWORD PTR DS:[ESI+30] 01007022 8BD8 MOV EBX,EAX 01007024 D9D0 FNOP 01007026 DD03 FLD QWORD PTR DS:[EBX] 01007028 D8C8 FMUL ST,ST // x^2 stack = 1 0100702A DD02 FLD QWORD PTR DS:[EDX] 0100702C D8C8 FMUL ST,ST // y^2 stack = 2 0100702E DD01 FLD QWORD PTR DS:[ECX] 01007030 D8C8 FMUL ST,ST //z*z stack = 3 01007032 DEC1 FADDP ST(1),ST //y^2+z^2 stack = 2 01007034 DEC1 FADDP ST(1),ST //x^2+y^2+z^2 stack=1 01007036 D9FA FSQRT 01007038 DD55 F8 FST QWORD PTR SS:[EBP-8] // r=EBP-8 r on top of stack 0100703B DD47 F0 FLD QWORD PTR DS:[EDI-10] // what is EDI 10 again?? EDI-10 is [email protected][email protected]$ 0100703E D9C9 FXCH ST(1) // r on top 01007040 D9E1 FABS // abs abs (r) 01007042 D9F1 FYL2X //log_2 (r) 01007044 D9E8 FLD1 // load value 1 to top of stack 3 on 01007046 D9C1 FLD ST(1) // load r to top 4 on stack 01007048 D9F8 FPREM // remainder of r/1 4 on stack 0100704A D9F0 F2XM1 // ST(0) *2 -1 0100704C DEC1 FADDP ST(1),ST // st(0)*2 3 on stack 0100704E D9FD FSCALE // st(0) * 2 st(1) //truncates st(1) to integer downwards // st(1) 2 on stack 01007050 D9C9 FXCH ST(1) // necessary??? 2 on stack 01007052 DDD8 FSTP ST // st=st(1)??? 01007054 DD5D F0 FSTP QWORD PTR SS:[EBP-10] // EBP-10 = above??? r^power 01007057 DD02 FLD QWORD PTR DS:[EDX] // load y 01007059 D8C8 FMUL ST,ST // y*Y 0100705B DD01 FLD QWORD PTR DS:[ECX] // load z 0100705D D8C8 FMUL ST,ST // z*z 0100705F DEC1 FADDP ST(1),ST // y*y+z*z 01007061 D9FA FSQRT // sqrt( xxx) stack only 1 01007063 DD55 E8 FST QWORD PTR SS:[EBP-18] // ebp-18 = R2 01007066 DD03 FLD QWORD PTR DS:[EBX] // load x stack 2 01007068 D9F3 FPATAN // atab (st(1)/st(0)) == atan (x/r2) stack 1 0100706A DC4F F0 FMUL QWORD PTR DS:[EDI-10] // .. * EDI-10=power * theta 0100706D D9FB FSINCOS // cos (..) , sin (...) stack 2 0100706F DD5D D8 FSTP QWORD PTR SS:[EBP-28] // ebp-28 = cos(theta) stack 1 01007072 DD5D E0 FSTP QWORD PTR SS:[EBP-20] // ebp-20 = sin (..) stack empty 01007075 90 NOP 01007076 DD02 FLD QWORD PTR DS:[EDX] // load y 01007078 DD01 FLD QWORD PTR DS:[ECX] // load z 0100707A D9F3 FPATAN // atan (y/z) 0100707C DC4F E8 FMUL QWORD PTR DS:[EDI-18] // zanglepower * atan(y/z) ??? 0100707F D9FB FSINCOS // 01007081 DD5D C8 FSTP QWORD PTR SS:[EBP-38] // EBP-38 = cos (...) 01007084 DD5D D0 FSTP QWORD PTR SS:[EBP-30] // EBP-30 = sin (...) stack empty 01007087 D9D0 FNOP 558BEC81EC400000005356578B75088B7E308BD8D9D0DD03D8C8DD02D8C8DD01 D8C8DEC1DEC1D9FADD55F8DD47F0D9C9D9E1D9F1D9E8D9C1D9F8D9F0DEC1D9FD D9C9DDD8DD5DF0DD02D8C8DD01D8C8DEC1D9FADD55E8DD03D9F3DC4FF0D9FBDD 5DD8DD5DE090DD02DD01D9F3DC4FE8D9FBDD5DC8DD5DD0D9D0DD45D8DC 4DF0DC4618DD1BDD45E0DC4DC8DC4DF0DC4620DD1ADD45E0DC4DD0DC4FE0DC4DF0DC46 28DD19D9D08BC35F5E5B8BE55DC20800 01007089 DD45 D8 FLD QWORD PTR SS:[EBP-28] // load cos (theta) 0100708F DC4D F0 FMUL QWORD PTR SS:[EBP-10] // * r^power 01007092 DC46 18 FADD QWORD PTR DS:[ESI+18] // + xpixel 01007095 DD1B FSTP QWORD PTR DS:[EBX] // save new x stack empty | Escapetime |

IQ-bulb | This formula was proposed by Inigo Quilez in 2009 as a "correction" of Mandelbulb formula. http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm sq_r := sqrt(x*x+y*y+z*z) sq_xz := sqrt(x*x+z*z) r:= sq_r ^ Power theta = acos(y/sq_r) * P = atan2( sq_xz , y) * P // This is true everywhere, because sq_r is >=0 ; atan2(a,b) differs from atan(a/b) when b<0 // I must use atan2 because 'acos' is missing in assembly. zangle = atan2(x,z) * zAP x := sin(zangle)*sin(theta)*r+Cx y := cos(theta) *r+Cy z := sin(theta)*cos(zangle)*r+Cz Implemented by Luca G.N. 2011 | Escapetime |

IQ-bulb old | This formula is kept for compatibility. Please use IQ-bulb as it's mathematically correct. Implemented by Luca G.N. 2011 | Escapetime |

JIT_AmazingSquare_02 | First test with Amzaing Box a.k.a Tglad folding. The only difference to a pure ABox is the squaring of all components at the begin. I leave it here for your own tests. It works so far, but only on 3D tab. If moving to 3Da (.DEOption = 2 or 11) I only get dust, independent from secondary settings like .RStop , or .ADEscale Old formula name: JIT_gnj_ASquare_02.m3f PARAMETERS: Fold, Rmin, Scale as usual for Aboxes FORMULA: // do pre-squaring x2 := x*x; y2 := y*y; z2 := z*z; // Abox pure x_tmp := abs(x2+Fold) - abs(x2-Fold) - x2; y_tmp := abs(y2+Fold) - abs(y2-Fold) - y2; z_tmp := abs(z2+Fold) - abs(z2-Fold) - z2; r2 := x_tmp*x_tmp + y_tmp*y_tmp + z_tmp*z_tmp; rmin2 := Rmin*Rmin; if r2 < rmin2 then begin m := rmin2; end else if r2<1 then begin m := scale/r2; end else begin m := scale; end; // Add c x := m*x_tmp + cx; y := m*y_tmp + cy; z := m*z_tmp + cz; | Escapetime |

JIT_EM_Fld_Alter2 | Folded alternative number mandelbrot defined that i^2=-1, j^2=-i, i*j=1 Should generate slightly curved and horned shapes. | Escapetime |

JIT_EM_Fld_BoxBulb | Folds pillow like mandelbulb shapes. Slow | Escapetime |

JIT_EM_Fld_Electronics | Formula version 1.1 4D Looks like electronic devices. Hypercomplex FLDs with additional 4D transformation: x1:= ( x-w + y+z )*0.5; y1:= ( x+w + y-z )*0.5; z1:= ( x+w - y+z )*0.5; w1:= ( y+z - x+w )*0.5; It came out from from hypercomplex sinh. I have no ide what this do;) * * * By Edgar Malinovsky | Escapetime |

JIT_EM_Fld_Eternal3Cryst | Formula version 1.1 4D Crystal version (no negatives) of Eternal - forever long extruded mandelbrot pow 3. * * * By Edgar Malinovsky | Escapetime |

_AmazingBox | The amazing box formula without adding the C component. Use with other formulas in combination. | Escapetime with Analytic |

_AmazingBoxSSE2 | The amazing box formula without adding the C component. Use with other formulas in combination. | Escapetime with Analytic |

_AmazingRandom | The amazing box formula without adding the C component. Use with other formulas in combination. | Escapetime with Analytic |

_Scaling | No “i” info | Escapetime with Analytic |

ABoxMapSFold | Description: A modified "Amazing Box" by an idea of Aexion, the radius for the sphere folding is modified by a 2d pixelmap, creating surface pattern on spherefold areas: x = abs(x+Fold) - abs(x-Fold) - x y = abs(y+Fold) - abs(y-Fold) - y z = abs(z+Fold) - abs(z-Fold) - z Mvec = (GetRGBfromSphereMap(@x, Map_nr) + Map_offset) * Map_scale rr = Sqr(x + Mvec[0]) + Sqr(y + Mvec[1]) + Sqr(z + Mvec[2]) if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz On higher Map scale values you might have to decrease the 'Raystep multiplier' to not overstep. If you still get much noise in combination with other formulas, try to uncheck 'Normals on DE'. Because the map function is very slow, use this formula only on one or a few iterations and do the rest with the normal ABox formula. The maps output range is 0 to 1 (black to white). The map must be in the 'Lightmap folder' specified by the 'Ini Dirs' button, named only by the map number and stored as png or jpeg image. | Escapetime with Analytic |

ABoxMod1 | if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cy y = y * m + Cx z = z * m + Cz | Escapetime with Analytic |

ABoxMod2 | A curious ABox non-conformal variation, with a different fold for z and a non-conformal inversion. Looks like a wardrobe, a phone box... or you name it! x = abs(x+Fold) - abs(x-Fold) - x y = abs(y+Fold) - abs(y-Fold) - y z = abs(z+zFold) - abs(z-zFold) - z z' = abs(z) - CHS if z' > 0 then rr = x*x + y*y + z'*z' // on top & bottom of cyl else rr = x*x + y*y // on cyl body endif if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz | Escapetime with Analytic |

ABoxModKali | Description: A modified amazing box as suggested by Kali, one iteration: x = X_add - abs(x) y = Y_add - abs(y) z = Z_add - abs(z) rr = x*x + y*y + z*z if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz | Escapetime with Analytic |

ABoxPlatinum | 'Platinum' edition is inspired by Buddhi's version. Lots of added features, but slower. The result will always be infinitely zoomable without distortion (conformal fractal). 1. You can rotate it as liked. The rotation is applied just before the C addition (Buddhi's method). 2. The sphere inversion can be fully customized; center, radius and MinR. 3. X and Y folds are rotatable. 4. Additionally, you can switch on Abs() functions for x,y,z to get abs-boxes. Luca GN 2012 Jesse 27.3.2013 speedup | Escapetime with Analytic |

ABoxPlatinumB | 'Platinum' edition is inspired by Buddhi's version. Lots of added features, but slower. X and Y folds are rotatable, but due to an approximation in the formula the result is distorted. The result will NOT be infinitely zoomable with nice results, but it's interesting anyway. I decided to leave it as a variant. If Fold angles are zero, this is absolutely identical to the normal version! Luca GN 2012 | Escapetime with Analytic |

ABoxSmoothFold | WARNING! If you use very high sharpness, I don't know what will happen (it may become extremely slow)... But it has no sense An Amazing Box, with Folding function modified as follows (x is each spatial coord); xp = fix1*x**p; (fast int pow, p is forced to be > 2) u=sgn(x)*xp+1; x=x+xp*(2*Fold-x); x=x/u; Also radius folding is smooth (when minr<0.99); if minr>0.99 r=1; // prevents fp troubles and speeds up a lot in this case else r = (x*x+y*y+z*z); m=(1+minr)/2; n=(1-minr)/2; r1=(r-m)/n; rs=sgn(r1); r1=abs(r1); rsqrt = sqrt(r1); // this slows down the convergence rp=fix2*(rsqrt**p); (fast int pow, p is forced to be > 3) r = rs*((rp+r1)/(rp+1) * n) + m; endif (then r = scale / r and is used as a multiplier for x,y,z) This "smoothens" the folding function, replacing the "sawtooth" fold with a smooth curve Result is very similar to standard ABox but with a bit of detail loss and "curvy" details... Higher sharpness -> You get closer and closer to standard ABox... Also, remember that smoothing has an interference with the scale. More smooth -> less scale Inspired from an idea of Buddhi @ FractalForums. Interesting results can be achieved with negative fix values (more smoothness, different look). Luca GN 2011 19.03.2013 Jesse speedup modification | Escapetime with Analytic |

ABoxSmoothFold2 | WARNING! If you use very high sharpness, I don't know what will happen (it may become extremely slow)... But it has no sense An Amazing Box, with Folding function modified as follows (x is each spatial coord); xp = x**p; (fast int pow) u=sgn(x)*xp; x=x+xp*(2*Fold-x); x=x/u; Also radius folding is smooth (beware! don't use minr = 1 or out of range 0-1 !!!); m=(1+minr)/2; n=(1-minr)/2; r1=(r-m)/n; rs=sgn(r1); r1=abs(r1); rp=r1**p; (fast int pow) r = rs*((rp+r1)/(rp+1) * n) + m; This "smoothens" the folding function, replacing the "sawtooth" fold with a smooth curve Result is very similar to standard ABox but with a bit of detail loss and "curvy" details... Higher sharpness -> You get closer and closer to standard ABox... Inspired from an idea of Buddhi @ FractalForums. Luca GN 2011 | Escapetime with Analytic |

ABoxVaryScale | No “i” info | Escapetime with Analytic |

ABoxVaryScale2 | Like standard ABoxVS. More elaborate power expression for the radius of sphere inversion: R = (x^P2+y^P2+z^P2)^P1 It is surely slower than the "standard" one, due to that many powers, but you can get a lot of new shapes (instead of normal "spheres"). Tip: To get the "standard" box you should use Rpow = 1 and xyz pow = 2! Luca GN 2011 | Escapetime with Analytic |

ABoxVS_icen1 | From a variation found on Buddhi's Mandelbulber, custom version (conformal).
With MinR and selectable radius; always choose MinR | Escapetime with Analytic |

ABoxVS_icen2 | From a variation found on Buddhi's Mandelbulber, custom version (non conformal). Luca GN 2011 x = abs(x+Fold) - Fold y = abs(y+Fold) - Fold z = abs(z+Fold) - Fold if (CSm == 0) x1 = x+xC; y1 = y+yC; z1 = z+zC else x1 = x+Cx; y1 = y+Cy; z1 = z+Cz endif rr = x1*x1 + y1*y1 + z1*z1 if rr < 1 then m = Scale/rr else m = Scale if (CSm == 0) x = x * m + Cx y = y * m + Cy z = z * m + Cz else x = x * m + xC y = y * m + yC z = z * m + zC endif | Escapetime with Analytic |

ABoxVSShapes | Same as normal ABox Vary Scale but "r" is replaced by another expression, to get new effects instead of a normal sphere inversion; the final look is completely different. Change the modifiers when shapes look weird. Shape mode=1 -> Torus Mod1 = Radius of the torus (big), Mod2 = Radius of the circle section Mod1 = 0 and Mod2 = 1 is the normal ABoxVaryScale (lol) Shape mode=2 -> Cylinder A Mod1 = Cut limit, Mod2 = Pendence Shape mode=3 -> Cylinder B It's similar to the precedent, but not identical at all... Shape mode=4 -> Cone A It's similar to the precedent (cut limit, pendence) but with conic look instead of cylindric. Warning, it is a discontinue formula. Use mod1=1e90 to remove all discontinuities Else just choose a low raystep/stepwidth (it renders fine) Shape mode=5 -> Cone B Nothing special to say, another variation! Shape mode=12 -> Cone C (single sided) A new, simplified formula with an alternate definition of distance Shape mode=13 -> Paraboloid Similar as above Shape mode=6 -> Squarry pyramid A Shape mode=7 -> Squarry pyramid B These variations are "extreme"... They have very strange sharpy looks, far from the usual ABox. Mods have the usual meaning. They share the discontinuity problem with the cone. Shape mode=8 -> Lemniscate of Gerono (*) A quartic solid. Mod1 = Separation between "poles", Mod2 = Size Shape mode=9 -> Pseudo-cube (* but generalized) A cube with smoothed edges, but not only!... Try neg modifiers to get funky effects (like .7 , -1 ) Shape mode=10 -> Pseudo-cube 2 A cube with smoothed edges. Mod1 = Correction (use low values), Mod2 = Size Shape mode=11 -> Pseudo-octahedron (* but modified) A solid that rensembles to a octahedron. Shape mode=14 -> BiCylinder The intersection of two orthogonal cylinders. Shape mode=15 -> Roundy Cylinder Finite cylinder that "ends" with spheric caps. Too big values for mod1 can generate (ininfluent) discontinuities Shape mode=16 -> Spheric Tetra The intersection of four spheres, each one is on the vertex of a tetrahedron. Too bad if you choose random mod values it does not work. Big values for mod1 require (very!) small values for mod2 (else you intersect non-overlapping spheres...) This shape has a different symmetry type, with interesting effects Shape mode=17 -> Bisphere Another odd shape Shape mode=any other value -> ERROR! ------ rev 19 oct 11 ------ LUCAGN Formula; Big thanks to Aexion for the inspiration on this. And thanks to http://paulbourke.net/geometry/ and to http://www-sop.inria.fr/galaad/surface/ for the shapes that i flagged as (*) !!! * Torus Simply replace r with the expression of x' of _totorical2, using mod1 as R and mod2 as a global multiplier. * Cylinders Let's find z'; If abs(z) > mod1 {z'=0} else {z'=sqr(mod1-z)} Uses mod2*(x*x+y*y) or z'*z' as the radius. A picks the biggest value and B the smallest. Both modes are great! * Cones (have some discontinuities when mod1 is low) See this algorithm; If abs(z) > mod1 {z'=1} else {z'=(mod1-z)} rho = mod2*(x*x+y*y) If rho < z' {r=rho/z'} else {r=rho} // Cone B has If rho > z' {r=rho/z'} ... * Cone C r = (min(-m1*z + sqrt(x*x+y*y), 0)*m2)^2 * paraboloid r = (min(-z, 1)*m1 + (x*x+y*y))*m2 * Squarry P. (have some discontinuities when mod1 is low) See this algorithm; If abs(z) > mod1 {z'=1} else {z'=(mod1-z)} rho = max(x*x,y*y) If rho < z' {r=rho/z'} else {r=rho} // SqP B has If rho > z' {r=rho/z'} ... * Octahedron (xx=x*x, xy = x*y and so on) r=.1*(3*xyz+(xyz)^2+m1*(xxyy+xxzz+yyzz)+m1^2*(xx+yy+zz)+m2) * Magnolia (xx=x*x, xy = x*y and so on. Plus xx' = x*abs(x), yy' = y*abs(y), zz' = z*abs(z)) r=.15*(3*xyz+(xyz)^2+m1^2*(xxyy+xxzz+yyzz)+m1*(xx'+yy'+zz')+m2) * Lemniscate This shape were suggested directly by Aexion! Thanks a lot r=((x*x - mod1)*x*x + y*y + z*z) * mod2 * Pseudocube (from http://www-sop.inria.fr thanks a lot) r=(x*x*x*x+y*y*y*y+z*z*z*z)+m2*(x*x+y*y+z*z)+m1 * Pseudocube2 r=m2*(x*x*x*x+y*y*y*y+z*z*z*z)+m1 * Bisphere r=m2*((2*x*x+y*y+z*z)/abs(4*x))^2+m1 | Escapetime with Analytic |

ABoxVSWavy | This formula has been suggested by Aexion in FF. I modified and generalized it a bit. Same as normal ABox Vary Scale but "r" is replaced by a more complicated expression, to get new "wavy" effects instead of a normal sphere inversion; // do the folding, then; rho = sqrt(x*x+y*y+z*z); // the radius theta1 = cos(f*x) * sin(f*y) + cos(f*y) * sin(f*z) + cos(f*z) * sin(f*x); theta2 = cos(f*x) + cos(f*y) + cos(f*z); if (mulmode == 1) { r = theta1 * Amp + rho * (theta2 * Amp2 + Rmul); } else { r = theta1 * Amp + theta2 * Amp2 + rho * Rmul; } endif // use r for the inversion and add c Some hints. - I often noticed that neg scale looks better. Try it! - Wave frq: Don't set too high values, or the fractal will look overly busy - Radius mul: Keep it near to 1, and use low amplitudes, to make the fractal look more "boxy" or the deformation will be stronger (Amplitudes = 0 and rmul = 1 gives the normal ABoxVS) - Alt mode: Wave2 will interfer with the radius multiplier, even more possibilities for strange looks! ( Has effect when Wave2 amp > 0 ) *** - "Original" Aexion formula It's very interesting. Set scale = -2, minr>0.5, Wave amp = 3 (or anything you like), frq <= 1, fold = 1 (or anything you like), any other param = 0. Tends to look a bit too busy but it can be good. | Escapetime with Analytic |

Amazing Box | The 'Amazing Box' aka Mandbox formula, invented by TGlad at fractalforums.com. The formula for one iteration looks like this: x = abs(x+Fold) - abs(x-Fold) - x y = abs(y+Fold) - abs(y-Fold) - y z = abs(z+Fold) - abs(z-Fold) - z rr = x*x + y*y + z*z if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz | Escapetime with Analytic |

Amazing Surf | Description: Formula proposed by Kali by a private message. I added some features btw Luca GN 2012 Scale = Scale + Scale_vary*(abs(Scale)-1) x = TgladFold(x,fold) y = TgladFold(y,fold) // z is not folded if SorC != 0 rr = x*x + y*y // cylinder shape for inversion (sometimes buggy but can be cool) else rr = x*x + y*y + z*z // sphere shape for inversion (works better) endif if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cy y = y * m + Cx z = z * m + Cz Rotate3D(x,y,z,angles) | Escapetime with Analytic |

Amazing Surf 2 | Description: Modified fold formula used here; fold X and Y is "infinitized" around the origin. | Escapetime with Analytic |

AmazingBox2 | No “i” info | Escapetime with Analytic |

ASurfMod1 | Description: Combination of Kali's ideas; Amazing Surface & AboxMod1. Luca GN 2015 | Escapetime with Analytic |

ASurfSmoothFold | Modification of ABoxSmoothFold taking off z-fold and adding a rotation. | Escapetime with Analytic |

ATetraVS | Variation of the Amazing Box Vary Scale, based on some inclined folding planes. The shapes rensemble a tetra/octahedral geometry. Formula (when Tglad folding is ON); See the ABVS, replacing folding part with; // note; RFolding seems to ignore x angle completely RotatedFolding(+45,+45,+45,Fold) // This is accurate only for the default angles, I don't know // what happens with random angles. Btw, it seems nice anyway... if (New_mode != 1) RotatedFolding(-45,-45,+45,Fold) RotatedFolding(-45,+45,-45,Fold) RotatedFolding(+45,-45,-45,Fold) // New mode (different shapes - only different folding order); else RotatedFolding(+45,-45,-45,Fold) RotatedFolding(-45,+45,-45,Fold) RotatedFolding(-45,-45,+45,Fold) endif // With default angles modes 2 & 3 aren't that interesting // I obtained them changing other signs from the matrix, don't // exactly know which angles are involved sorry The non-Tglad folding rule is the following (modifying the RotFolding axiom); x'=1-abs(x-1) // folds only the positive side Generates tetrahedral shapes (rather than octahedral) Thanks a lot to Aexion for his precious innovative ideas ... He inspired me a lot for this! Luca GN '11 | Escapetime with Analytic |

ATetraVS2 | x = x - 2*Fold45 // moves x to the second alignment y = y - 2*Fold45 // moves y to the second alignment m = x+y if m<0 n = x // does the 2nd fold x = -y y = -n endif x = x + Fold45 // and finally moves x and y back to the original spot y = y + Fold45 endif (... do it for x+y, then x+z then y+z. Like in Sierpinski3 formula but it's a folding) Luca GN 2011 ------- EDIT may 23 2012 added radius. A great improvement in the fractal look is notable when radius is near to 10... Experiment by yourself! | Escapetime with Analytic |

CantorIFS | Modified from OctahedronIFS, another 'classic', the 3D Cantor dust. | Escapetime with Analytic |

CrossBiFold | Experimental KIFS with mixed folds, for more shape variety. Formula is long enough, in synthesis; 1) abs(x,y,z) 2) Rot1(x,y,z) 3) foldOct(x,y,z) * Scale 4) x = x - Subx*(Scale-1) 5) x = TgladFold(x,FoldX) 6) foldOct(x,y,z) 7) Rot2(x,y,z) 8) (x,y,z) -= CScalex,y,z*(Scale-1) LucaGN 2012 | Escapetime with Analytic |

CrossMenger | A Knighty's attempt (really close!) to replicate Paul Bourke's
Cross Menger fractal, found in this page;
http://paulbourke.net/fractals/crossmenger/
// ---------------------------------------------------
float CrossMengerKIFS(vec3 p){//Pure KIFS... almost correct
float dd=1.;
for(int i=0; i | Escapetime with Analytic |

DodecahedronIFS | Fast implementation - Hack by blob. | Escapetime with Analytic |

DodecahedronIFSex | This formula comes from Fragmentarium's default examples. Again thanks to Syntopia and of course Knighty. Btw, this is a lot more flexible, because you can choose between 8 different rotation modes (for rot2), and choose the offsets (CScales). // Snippet from Frag's script with my tweaks; (z is a vector with x,y,z) z *= Rot1; for (n2=0; n2<7; n2++) { // this works, the original formula for some reason used 9 cycles z-=2.0 * min(0.0, dot(z, n1)) * n1; // n1 = normalizedVec(phi-1,1/(phi-1), -1) if style=n2 { z *= Rot2; } // Rotating before the 'fold loop' is finished can be fun! flip3D(n1); // flip3d(x,y,z) = (y,z,x), easier way to cycle between the fold styles without additional vecs } z =+z*Scale - offset*(Scale-1.0); if style=7 { z *= Rot2; } // This is Fragmentarium's style. | Escapetime with Analytic |

genIFS | A more general IFS based on an idea from Kali at fractalforums. It adds also the C component, so you can make julias out of the whole set. if AbsX <> 0 then x = abs(x) if AbsY <> 0 then y = abs(y) if AbsZ <> 0 then z = abs(z) x = x + OffsetX y = y + OffsetY z = z + OffsetZ Rotate(XYZ, RotMatrix) x = x + Cx y = y + Cy z = z + Cz | Escapetime with Analytic |

HalfOctIFS | A 3D half-octahedron attempt; same as normal one but the third fold is dropped. Nice shapes can be obtained with this variation. Luca GN 2011 | Escapetime with Analytic |

IcosahedronIFS | No “i” info | Escapetime with Analytic |

JCube3 | A brute-force IFS formula, that tries to replicate the "Jerusalem Cube" fractal. It is discontinue, but it's the best known approximation of the formula. Warning; GScale parameter may help to obtain more effects but discontinuities become more evident! | Escapetime with Analytic |

koch_cube | Cubic Koch fractal. Inspired from a Wikipedia image ( http://en.wikipedia.org/wiki/File:Quadratic_Koch_3D_(type1_stage2).png )
Added options for scale, stretching and other goodies
TIP - With default settings you don't see the fractal correctly; decrease DEstop, and use miniter=10 or something to see a better
plot. Be careful with scale and stretching tweaks, they greatly affect the render!
If you use xy stretch, the fractal will be less uniform but with some singularities.
----------------
; basic cubic fold (from Menger3 formula)
; scale has been replaced by a postscale
; to fix some branch cut troubles
x = abs(x)*3
y = abs(y)*3
z = abs(z)*3
if y>x
t=x
x=y
y=t
endif
if z>x
t=x
x=z
z=t
endif
if z>y
t=y
y=z
z=t
endif
x = x+xa, y=y+ya, z=z+za
( ... rotation of x,y,z on specified angles ... )
; basic vars
a=3-stretch, b=3+stretch, c=x-a, d=x-b
; the routine works only for scale = 3, else some discontinuities will appear
; Now, draw the cube WITHOUT making discontinuites in the spatial vars
; bring what falls "out of the small cube zone" in the interval (-1;1) (next iter will take care)
; z must be folded to get a homogen look
z=zfix-abs(zfix-z)
if (c | Escapetime with Analytic |

koch_oct | Modified from OctahedronIFS. | Escapetime with Analytic |

koch_surf | From a Knighty's script, modified a bit; // Fold z.xy = polyfoldsym(z.xy,shiftx,shifty,angleshift); z.y=YOff-abs(z.y-YOff); z.x+=1./3.;if(z.z>z.x) z.xz=z.zx; z.x-=1./3.; // variation is // z.x+=1./3.;if(z.z>z.x) z.xz=z.zx; z.x-=1./3.; z.x-=1./3.;if(z.z>z.x) z.xz=z.zx; z.x+=1./3.; // normal formula z = Scale * (z + Offset); z = rot * z; z = z - Offset; ---------------- FORMULA AND IMPLEMENTATION; Luca G.N. 2013 | Escapetime with Analytic |

Mandalay-KIFS | Description:
Attempt to recreate the Mandalex fractal invented by Hiato
and posted at Fractal forums, but using strictly continuous
functions. This means DE is perfect and computation is very fast.
Lots of variations are possible of course, this is
very versatile in particular.
It's a midway between a Menger, an octahedron and an Amazing
Box, with really endless possible fractals!
This formula was born with the precious and essential
help of Knighty, killed all discontinuities and simplified everything.
Speedup version 11/03/2015 by Luca
float DE(vec3 pos) {
vec4 p = vec4(pos,1), p0 = p; // p.w is the distance estimate
if(Julia) p0.xyz = JuliaC;
for (int i=0; i | Escapetime with Analytic |

Mandalex | KNOWN ISSUE: This fractal has a bad DE, due to the cuts. Description: Modified version of a fractal invented by Hiato and posted at Fractal forums. Dropped "Nonlinear pull" as it is C-dependent and involves integer division, but kept the interesting "linear pull", in a more customizable version. Please note that a negative value for pulls disable them while a negative effect works! Apply this function before folding and again after adding C; void linearPull(inout vec3 p, float lp, float effect, int fiddler) { int doLP = 0; if (abs(p.x)>w) doLP++; if (abs(p.y)>h) doLP++; if (abs(p.z)>t) doLP++; if (fiddler == doLP) { lp*=effect; if (p.x<0) p.x+=lp; else p.x-=lp; if (p.y<0) p.y+=lp; else p.y-=lp; if (p.z<0) p.z+=lp; else p.y-=lp; } }; | Escapetime with Analytic |

Menger3 | No “i” info | Escapetime with Analytic |

MengerHyper | Description: A combination of FoldingOct, SphereInv, MengerIFS for hyperbolic Menger sponges. Inspired by this post by Buddhi @ FF; http://www.fractalforums.com/3d-fractal-generation/revenge-of-the-half-eaten-menger-sponge/msg8920/#msg8920 Modified for an accurate escape-time DE and more generalized though. 13 oct 2011 Added "Fold Again" option; it causes a different look in some details, but it's not easy to spot the differences (if turned off should render a little little bit faster) | Escapetime with Analytic |

MengerIFS | Description: A 3d menger version that hormonizes more in hybrids then 'menger3'. | Escapetime with Analytic |

MengerIFS_B_2v0 | If Polyiter=0 do it every iteration, otherwise apply on poly iter. If PolyPosition=3 do both positions. If PolyStyle=1, sphere at PolyStrength=0. If PolyStyle=2, scaled sphere Description: A 3d menger version that hormonizes more in hybrids then 'menger3'. .Double Scale = 3 .Double CScale X = 1 .Double CScale Y = 1 .Double CScale Z = 0.5 .3SingleAngles Rotation = 0 .Integer PolyPosition = 0 esi-50 B0 .Integer PolyIter = 66 esi-54 AC .Integer PolyIterAfter = 66 esi-58 A8 .Double Sides = 4.0 edi-60 A0 .Double PolyStrength = 1.0 edi-68 98 .Integer RotPosition = 2 edi-6c 94 .Integer RotIter =1 edi-70 90 .Integer RotAfter = 99 edi-74 8C .Integer RotPosition = 0 edi-50 B0 .Integer PolyPosition = 0 edi-54 AC .Integer PolyIter = 66 edi-58 A8 .Double Sides = 4.0 edi-60 A0 .Double Sides2 = 4.0 edi-68 98 .Double PolyStrength = 1.0 edi-70 90 .Double PolyStrength2 = 0 edi-78 88 .Integer PolyStyle = 0 edi-7C 84 dd47a0d9e0dd45c0dd4798d9e0dd45b8 dd07dc77a0dd55f8d8c0 dd5df0dd07dc7798dd55e8d8c0dd5de0dd01dd02d9f3d9e1dc55f8dfe080e441 7f05dc65f0ebf1d9ff d9e8dee9dd4790d9e1dec9d9e8dec1dd4790 d9e4dfe09b9e7308ddd8d9e8def1eb02ddd8 dd55f0dc0add55f8d8c8dd45f0dc09dd55f0d8c8dec1d9fa d9d0dd03d9f3d9e1dc55e8dfe080e4417f05dc65e0ebf1d9ff d9e8dee9dd4788d9e1dec9d9e8dec1dd4788 d9e4dfe09b9e7308ddd8d9e8def1eb02ddd8 d9c0d9c0dc4df8 dd1ad9d0dc4df0dd19d9d0dc0bdd1b 8a47843c017572 dd4708dd55f8dd55e8d8c0dd55e0dd5df0 dd01d8c8dd02d8c8dec1d9fa dd03d9f3d9e1dc55e8dfe080e4417f05dc65e0ebf1d9ffd9e8def1d9c0d9c0 dc0bdd1bdc0add5de8dc09dd55e0dd45e8d9f3d9e1dc55f8dfe080e4417f05 dc65f0ebf1d9ffd9e8def1d9c0dc4de8dd1adc4de0dd19 00440AD0 8A47 AC MOV AL,BYTE PTR DS:[EDI-54] 00440AD3 3C 02 CMP AL,2 00440AD5 74 02 JE SHORT accessch.00440AD9 00440AD7 E9 4E010000 JMP accessch.00440C2A 00440ADC 8A47 A8 MOV AL,BYTE PTR DS:[EDI-58] 00440ADF 3C 00 CMP AL,0 00440AE1 74 08 JE SHORT accessch.00440AEB 00440AE3 8A47 A8 MOV AL,BYTE PTR DS:[EDI-58] 00440AE6 3A46 40 CMP AL,BYTE PTR DS:[ESI+40] 00440AE9 0F85 3B010000 JNZ accessch.00440C2A 00440AEF DD07 FLD QWORD PTR DS:[EDI] 00440AF1 DC77 A0 FDIV QWORD PTR DS:[EDI-60] 00440AF4 DD55 F8 FST QWORD PTR SS:[EBP-8] 00440AF7 D8C0 FADD ST,ST 00440AF9 DD5D F0 FSTP QWORD PTR SS:[EBP-10] 00440AFC DD07 FLD QWORD PTR DS:[EDI] 00440AFE DC77 98 FDIV QWORD PTR DS:[EDI-68] 00440B01 DD55 E8 FST QWORD PTR SS:[EBP-18] 00440B04 D8C0 FADD ST,ST 00440B06 DD5D E0 FSTP QWORD PTR SS:[EBP-20] 00440B09 DD01 FLD QWORD PTR DS:[ECX] 00440B0B DD02 FLD QWORD PTR DS:[EDX] 00440B0D D9F3 FPATAN 00440B0F D9E1 FABS 00440B11 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 00440B14 DFE0 FSTSW AX 00440B16 80E4 41 AND AH,41 00440B19 7F 05 JG SHORT accessch.00440B20 00440B1B DC65 F0 FSUB QWORD PTR SS:[EBP-10] 00440B1E ^EB F1 JMP SHORT accessch.00440B11 00440B20 D9FF FCOS 00440B22 D9E8 FLD1 00440B24 DEE9 FSUBP ST(1),ST 00440B26 DD47 90 FLD QWORD PTR DS:[EDI-70] 00440B29 D9E1 FABS 00440B2B DEC9 FMULP ST(1),ST 00440B2D D9E8 FLD1 00440B2F DEC1 FADDP ST(1),ST 00440B31 DD47 90 FLD QWORD PTR DS:[EDI-70] 00440B34 D9E4 FTST 00440B36 DFE0 FSTSW AX | Escapetime with Analytic |

MengerIFSplus | Description: Same as normal MengerIFS, but you can move the rotation center arbitrarily for many more variations. It should be obvious that since you leave all rotations zero you will never notice any effect. Plus, you will see that dX and rotation X are independent; only dY and dZ will modify it. Same for all other axis. "Hacked" from Jesse's formula (Luca GN 2011). Idea taken from the original KIFS thread. | Escapetime with Analytic |

MengerKoch | Description: Menger modified formula to get results similar to the Koch snowflake. Too bad the effect is not accurate, but it's still good. LGN 2011 | Escapetime with Analytic |

MengerKochV2 | Description: Menger modified formula to get results similar to the Koch snowflake. The result in my opinion is very interesting. The main param is Edge1. Produces great results for a wide range of values. You can get more variations setting a positive value for Edge2 too - works good with values less than 1. LGN 2011 | Escapetime with Analytic |

MengerSmt | Description: A 3d menger sponge with rounded edges and organic look. Downsides; details get (very!) quickly lost. edit 27 october; added a different smoothing type (visible when smoothing is less than 0) and differentiated edge smoothing from linear (lots of effects possible now!). Luca GN 2015 ------------------- procedure MengerIFSsmooth(var x, y, z, w: Double; PIteration3D: TPIteration3D); var t: Double; sc, sc1, sc2: Double; Cx, Cy, Cz: Double; s: Double; begin sc := 3.0; sc1 := sc-1.0; sc2 := sc1/sc; Cx := 1.0; Cy := 1.0; Cz := 0.5; t := 9999999.0; s := 0.005; x := sqrt(x*x+s); y := sqrt(y*y+s); z := sqrt(z*z+s); t:=x-y; t:= 0.5*(t-sqrt(t*t+s)); x:=x-t; y:= y+t; t:=x-z; t:= 0.5*(t-sqrt(t*t+s)); x:=x-t; z:= z+t; t:=y-z; t:= 0.5*(t-sqrt(t*t+s)); y:=y-t; z:= z+t; z := z - Cz*sc2; z := - sqrt(z*z+s); z := z + Cz*sc2; x := sc*x-Cx*sc1; y := sc*y-Cy*sc1; z := sc*z; w := sc*w; end; | Escapetime with Analytic |

OctaFullIFS | No “i” info | Escapetime with Analytic |

OctahedronIFS | No “i” info | Escapetime with Analytic |

OctKoch | Octahedral version of the cute fractal I called "MengerKochV2". This has nothing to do with Menger though. Inspired by a Tglad render I saw on the forums btw. Looks like a castle with infinite towers. 1) abs(x,y,z) 2) Rot1(x,y,z) 3) foldOct(x,y,z) 4) x = x - Subx*(Scale-1) 5a) x = TgladFold(x,FoldX) // Now I am uncertain; for the correct effect I think here goes an abs(x). // But the formula looks nice in both versions. 5b) x=abs(x) (optional) 6) foldOct(x,y,z) 7) (x,y,z) -= CScalex,y,z*(Scale-1) 8) Rot2(x,y,z) 9) (x,y,z) *= Scale Luca GN 2012 | Escapetime with Analytic |

SierpHilbert | This fractal is an hybridation of Sierpinski and Hilbert axioms, with these parameters. In reality, an uncountable number of curves and fractals can be obtained varying the parameters. | Escapetime with Analytic |

Sierpinski3 | No “i” info | Escapetime with Analytic |

Sierpinski3alt | Alternate version of Sierpinski3. Instead of two rotations only one but with selectable center. Rotation1 is a pre-rotation in reality (less useful I think). It should be obvious that since you leave all rotations zero you will never notice any effect. Plus, you will see that dX and rotation X are independent; only dY and dZ will modify it. Same for all other axis. "Hacked" from Jesse's formula (Luca GN 2011). Idea taken from the original KIFS thread. | Escapetime with Analytic |

SierpinskiFull | A Sierpinski3 "clone" but with full tetrahedral symmetry planes. Difference is evident in all non-standard modes (example, if you change CScales or rotations). Also in combination with other formulas expect more symmetry. Very intriguing new mode is "reversed fold"! Quite different shapes are obtained. Ideas taken from original KIFS thread by Knighty. Bonus mode; Enable edges to get a "SierpHilbert" like fractal. Normal full tetra-fold; if(x-y<0){x1=y;y=x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(y-z<0){y1=z;z=y;y=y1;} if(x+y<0){x1=-y;y=-x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(y+z<0){y1=-z;z=-y;y=y1;} Reversed full tetra-fold; if(x+y<0){x1=-y;y=-x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(y+z<0){y1=-z;z=-y;y=y1;} if(x-y<0){x1=y;y=x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(y-z<0){y1=z;z=y;y=y1;} | Escapetime with Analytic |

SurfBox | infinity, you get Tglad's fold. I found that 2000 can be enough. If foldMod = 2*fold, you get the perfect Mixed Folding, simulating abs() and fold at the same time. If foldMod = 4*fold, you get a double folding just like doing fold twice. // Mixed fold by Luca 2016. http://www.fractalforums.com/index.php?topic=25307 // do this for all 3d axis, or 4d axis if you have a 4d abox // Tglad normal fold is cfg->x = fabs(cfg->x + fold) - fabs(cfg->x - fold) - cfg->x; sg = sign(cfg->x); folder = sg * cfg->x- fold; // fold is Tglad's folder += fabs(folder); folder = min(folder, foldModX); // and Y,Z,W cfg->x -= sg*folder; | Escapetime with Analytic |

_Atan4D | Too bad, you need to choose a low bailout or a high multiplier: else this formula will not work. See "_Atanh4D" 's comments. But in my tests this function worked better and showed prettier effects. Note also that the computations are slowed down a bit (due to the complicate formula, two atan and a log plus other stuff for each pixel in 3D is not so fast to calculate). Computes atan(Q+P) * a, following Hamiltonian (non commutative) theory. Q is a quat that contains in order (x,y,z,w). P is the phase (to vary a bit the effect) a is the amplitude. (set this to a value > 1 to force convergence) This formula should be used with non comm.quaternions but you can use it for everything. I implemented this code: Translate x y z w by P at first T1 = sqrt(w*w+y*y+z*z); if T1 < 0.00001 goto real if (x=0)&(T1-1 < 0.00001) goto real T2 = (atan(x,1-y) - atan(-x,1+y))*.5 T3 = ( log(((y+1)^2+x*x)/((1-y)^2+x*x)) )*.25/T1 x = T2; y = T3 * y; z = T3 * z; w = T3 * w; goto end real: // Real numbers -> shortcut x = atan(x) end: Do a scaling by a | Escapetime 4D |

_conj4D | Description: Complex conjugate function The simplest function ever... Works well in 4D also Warning: This function in most cases simply screws up the fractal. Transforms a Mandelbrot set in a tricorn. Formula by Luca GN 2011 conj(S) = (x,-y,-z,-w) | Escapetime 4D |

_coordvspow | Description: With this tool you can create a custom linear combination of transformations. The basic is the power (standard White/Nylander theory), you can choose an arbitrary float number, and you can add/subtract various other coordinate transformations. Used alone with _addC allows you to create strange variations of the Mandelbulb. Please note that I wanted a general algorithm, so this is slow (especially the power routine). Only power = 1 is fast (simply gives x,y,z unaltered), and power = 0 is same as pow 1, to avoid bugs or weird stuff. Warning, the more transforms you turn on, more time is needed... Because a transform that has weight 0% is not calculated at all. version 1.0 - Power routine, Cylindric, Spheric and inverse ones version 1.1 - Experimental feature of exp3D(). Too bad triplex functions are really complicated (and slow!) and they don't give that many remarkable effects, but still they are not that bad. Sine function is even more complicated than exp, | Escapetime 4D |

_Exp4D | non unicity of log(). The identity is valid only in "zones near to origin". exp(P*log(Q)) = Q ^ P so with those function you can raise Q to arbitrary powers (if Q belongs to the interval). Enormous thanks to Dirk Meyer for the basic code! Enormous thanks to Dirk Meyer for the basic code! Enormous thanks to "ArtNouveaU Tiny Library" (1997) for the fast assembly implementation of exp() function! I implemented this code: T1 = sqrt(w*w+y*y+z*z); calculate sin,cos of T1; T2 = exp(x); x = T2*cos(T1); T2 = T2*sin(T1); if (T1 > 1e-200) T2 = T2/T1; y = T2*y; z = T2*z; w = T2*w; | Escapetime 4D |

_julibrot | This PRE-transform is a standard Juli-brot mode in 4D with two 2D Julia seeds. They affect z,w,Cx,Cy, leaving unchanged everything else. Try to use this with any formula, but don't be surprised of the strange results! Julibrot mode was theorized by Mandelbrot, as a 3D extension of his fractal, because combines Julia seeds and Mandelbrot mode. To see this at his best, use it with Mandel 4D Bi-Complex formula, that treats 4D vector as a system of two distinct complex numbers. | Escapetime 4D |

_Log4D | Description: Computes log(Q), following Hamiltonian theory, exact for all Q but truncated for (Re(Q)>0 & Re(Q)<1e-200). Q is a quat that contains in order (x,y,z,w). Remember that log(exp(Q)) = Q but exp(log(Q)) *generally* is not Q due to non unicity of log(). The identity is valid only in "zones near to origin". exp(P*log(Q)) = Q ^ P so with those function you can raise Q to arbitrary powers (if Q belongs to the interval). Enormous thanks to Dirk Meyer for the basic code! I implemented this code: T1 = sqrt(w*w+y*y+z*z); if (T1 != 0){ T2 = atan2(T1,x)/T1; T3 = x*x + T1*T1; if (T3 > 1e-200) { x = .5 * log (T3); } else { x = -460; // -460 = ln (1e-200) } y = T2 * y; z = T2 * z; w = T2 * w; } else { y = atan2(x,0); if (x > 1e-200) { x = log (x); } else { x = -460; // -460 = ln (1e-200) } } | Escapetime 4D |

_Rpow3_4d | Description: Does a power of 3 on the current length of the 4d vector. x = x * sqrRout y = y * sqrRout z = z * sqrRout w = w * sqrRout with: sqrRout = x*x + y*y + z*z + w*w (in 4d mode) | Escapetime 4D |

_Scalingplus | Description: Just like normal scaling, but with selectable values for each dimension. Useful for "coordinate fixing" especially in different coordinate systems. | Escapetime 4D |

_setw | Description: Normally, w and cw are zero, so you see 4D effect indirectly. This option sets those vars as a linear (or non linear) combination of x,y,z! It's better use this together with Mandel bicomplex. Will effectively work with any 4D formula, showing many new shapes/effects! Shows similar effects as Fractint-Ultrafractal quats but in real 3D. 🙂 Sets w and Cw variables as follows: in mode 0: (std average) w := (xm*x+ym*y+zm*z)/(xm+ym+zm) Cw := w else (arbitrary pow average) using absolute values of x,y,z (avoids troubles with powers): w := ((xm*(x^p)+ym*(y^p)+zm*(z^p))/(xm+ym+zm))^(1/p) Cw := w Use this mode with two non-zero multipliers, many cool effects will be generated! Actually, also power 1 gives a very nice effect, due to the abs function! BE SURE TO USE AS A PRETRANSFORM and USE NEGATIVE VALUES AT YOUR RISK! Implemented by Luca G.N. 2011 | Escapetime 4D |

_Sin4Dplus | This formula should be used with non comm.quaternions, lots of wonderful intricate structures appear. Try also to change the bailout, setting a high value. Or use a higher/lower amplitude to see various effects. Also, this formula can give interesting results with all other formulas available (even if it is a "side effect"). I implemented this code: Translate x y z w by P at first T1 = sqrt(w*w+y*y+z*z); if T1 != 0 calculate sin & cos of x; T2 = exp(T1); calculate sinh(T1) = .5 * (T2 - 1/T2); calculate cosh(T1) = .5 * (T2 + 1/T2); x = sin x * cosh T1; T1 = cos x * sinh T1 / T1; y = T1 * y; z = T1 * z; w = T1 * w; else // Real numbers -> shortcut x = sin x endif Do a scaling by a | Escapetime 4D |

_SphereInvC4d | Description: Complete sphere inversion of the vector and the adding constant: rSqrL = 1 / (Cx*Cx + Cy*Cy + Cz*Cz + Cw*Cw) Cx = Cx * rSqrL Cy = Cy * rSqrL Cz = Cz * rSqrL Cw = Cw * rSqrL rSqrL = 1 / (x*x + y*y + z*z + w*w) x = x * rSqrL y = y * rSqrL z = z * rSqrL w = w * rSqrL Performing it only once as first formula inverses the whole coordinate system. You might have to cut off to see the inside then. | Escapetime 4D |

_Tanh4D | Description: *WARNING* - Too bad, this function is actually almost useless, even if the 2D slices look pretty. (Also, AFAIK, use it as a pre-transform is not a good idea.) Why? This is due to the "nature" of the function itself, because the function is numerically accurate (compared with UltraFractal's tanh, gives the same results for z=w=0 and default settings). tanh is convergent for "big" values of the argument, and convergent functions are NOT supported by Mandelbulb3D for now. (DE works for "divergent" fractals only). The only way to avoid this is setting low pre-muls and a high final mul. But this destroys the effect of the function itself - and leads to noisy images. Useless again! The only way to use it seems to be: use low bailouts. Same issues of the previous. I release it for experimental purposes or for future use only. -------------------------------------------- This is the definition of the function tanh: tanh(x) := (exp(2*x)-1)/(exp(2*x)+1) (alternate definition - I use this for speed reasons) tanh is a "sigmoid" type function (see Wikipedia) | Escapetime 4D |

Aexion1 | y' = y*y - x*x + 2*w*z + Cy z' = z*z - w*w + 2*x*y + Cz w' = w*w - z*z + 2*x*y + Cw Notice: Some formulas are also incrementing the FirstIt value, so a combination with those would not work properly. The transform makes a 4d mode necessary, but the 4d rotations are not very useful with this formula. | Escapetime 4D |

Barnsley2_4Dc | variations (rotations will modify the condition). Remember that this formula is discontinue (acts like a scissor); so also the shapes always have sharp edges. Barnsley 2 commutative 4D formula ---------------- S is the quaternion that contains (x,y,z,w+wadd). K is the quaternion that contains (dx,dy,dz,dw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz + Aw Bw , Ay Bx + Ax By - Aw Bz - Az Bw , Az Bx - Aw By + Ax Bz - Ay Bw , Aw Bx + Az By + Ay Bz + Ax Bw) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum ---------------- if (mul * Sx * Cy + mul * Sy * Cx > Thresold ) S' = ( ( S + K ) q* C) else S' = ( ( S - K ) q* C) endif ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Barnsley2_4Dnc | also the shapes always have sharp edges. Barnsley 2 non-commutative 4D formula ( xyzw q* C version ) ---------------- S is the quaternion that contains (x,y,z,w+wadd). K is the quaternion that contains (dx,dy,dz,dw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz - Aw Bw , Ax By + Ay Bx + Az Bw - Aw Bz , Ax Bz - Ay Bw + Az Bx + Aw By , Ax Bw + Ay Bz - Az By + Aw Bx) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum ---------------- if (mul * Sx * Cy + mul * Sy * Cx > Thresold ) S' = ( ( S + K ) q* C) else S' = ( ( S - K ) q* C) endif ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Barnsley4Dc | Olivier Steiger. Thank you! Also added Flip option. Less interesting, but can be also good Barnsley (and Tent Map) commutative 4D formula ---------------- S is the quaternion that contains (x,y,z,w+wadd). K is the quaternion that contains (dx,dy,dz,dw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz + Aw Bw , Ay Bx + Ax By - Aw Bz - Az Bw , Az Bx - Aw By + Ax Bz - Ay Bw , Aw Bx + Az By + Ay Bz + Ax Bw) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum ---------------- if ConjMode = ON Cy = -Cy // 2D flip endif if FlipMode = ON flip Cx & Cy endif if tent = ON // thresold is ignored if Sx > |K|/2 S' = ( ( K - S ) q* C) else S' = ( ( S ) q* C) endif S' = 2*S' else if Sx > thresold S' = ( ( S + K ) q* C) else S' = ( ( S - K ) q* C) endif endif (Flip, Conj do NOT change really C value. Cx and Cy are stored in the stack and modified temporarily) ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Barnsley4Dc2 | stack and modified temporarily) ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Beth1241 | Description: This is one of the plenty 'Mandalabeth' formulas made by Bethchen at fractalforums.com. | Escapetime 4D |

CommQuat | Description: A formula from Fracmonk on fractalforums.com, some additional user parameters added: x' = X_mul * (x*x - y*y - 2*z*w) + Cx y' = Y_mul * (2*x*y + z*z - w*w) + Cy z' = Z_mul * (2*x*z - 2*y*w) + Cz w' = W_mul * (2*x*w + 2*y*z) + W_add + Cw | Escapetime 4D |

CubicQuat | Description: An attempt to replicate a formula from Gilles Nadau (2003) - from UF database It is an "approximation" of the original one. That formula have an additional "twisting" parameter, like this. Modified, some additional user parameters added: x' = X_mul * x*x - (Y_mul * y*y + Z_mul *z*z + W_mul * w*w) + Cx + Cy * X_twist y' = 2*Y_mul * x*y + Cy + Cx * Y_twist z' = 2*Z_mul * x*z + Cz w' = 2*W_mul * x*w + W_add + Cw | Escapetime 4D |

EiffieQ | Description: Eiffie's Eiffel tower quaternion, found in Shadertoy. Expression; z=vec4(z.x*z.x-z.y*z.y-z.z*z.z+z.w*z.w,-2.0*(z.x*z.y-z.z*z.w),-2.0*(z.x*z.z-z.y*z.w),2.0*(z.x*z.w+z.y*z.z))+c; | Escapetime 4D |

GeneralQuat | Description: A generalization of a power 2 formula with 4 components. The user values are in the range of 1 to 4, positive or negative. They represents the 4d vector component to which the term is added, or subtracted if negative. 1: real part (X) 2: i(maginary) part (Y) 3: j (Z) 4: k (W) The squaring part looks like this: (x,iy,jz,kw)² = xx + i 2xy + j 2xz + ij yz + ji yz - yy + jj zz + k 2xw + ik yw + ki yw + jk zw + kj zw + kk ww Where the basic components are fix: x' = x*x - y*y + Cx y' = 2*x*y + Cy z' = 2*x*z + Cz w' = 2*x*w + Cw And all other terms can be user specified, depending on the desired result of i,j and k combinations: ij yz + ji yz + jj zz + ik yw + ki yw + jk zw + kj zw + kk ww The default values represents the associative and commutative version: x' = x*x - y*y + 2*w*z + Cx y' = 2*x*y - z*z + w*w + Cy z' = 2*x*z - 2*y*w + Cz w' = 2*y*z + 2*x*w + Cw | Escapetime 4D |

Hopf4D | Description: Hopf fibration squaring formula, from Bugman. http://www.fractalforums.com/theory/3d-mandelbrot-formula-based-on-the-hopf-map/ | Escapetime 4D |

hyperd_1 | Description: This formula was inspired by: http://www.fractalforums.com/general-discussion-b77/hyper-dual-numbers/ It is mathematically meaningless - but can give cool fractals // original formula: // a.x*b.x, a.x*b.y + a.y*b.x, a.x*b.z+a.z*b.x, a.x*b.w+a.y*b.z+a.z*b.y+a.w*b.x // was too unregular - especially x component so I fixed a=x, b=y, c=z, d=w, pow = IntPower; do { // do allows you to choose a higher pow newa = xa - yb - ( zc + wd ) - ( zd + wc )*zwMul; // instead of xa // if you remove yb and ( zc + wd ) you get weird things... newb = xb + ya; newc = xc + za + ( yd + wb )*ywMul; newd = xd + wa + ( yc + zb )*yzMul; pow--, a=newa, ... d=newd; } while pow>0; x=a+Cx, y=b+Cy, z=c+Cz, w=d+Cw LUCAGN 2011 | Escapetime 4D |

Lambda4Dc | Lambda but close. This implementation uses a commutative quat product, I found the formula here; http://home.comcast.net/~cmdaven/hyprcplx.htm Lambda commutative 4D formula (approximate, not the exact Lambda formula) ---------------- S is the quaternion that contains (x,y,z,w). K is the quaternion that contains (dx,dy,dz,dw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz + Aw Bw , Ay Bx + Ax By - Aw Bz - Az Bw , Az Bx - Aw By + Ax Bz - Ay Bw , Aw Bx + Az By + Ay Bz + Ax Bw) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum ---------------- S' = ( K - S q* S ) Note that S q* S = (x^2-y^2-z^2-w^2,2xy,2xz,2wx) S'' = S' q* C ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Lambda4Dnc | Lambda non-commutative 4D formula (approximate, not the exact Lambda formula) ---------------- S is the quaternion that contains (x,y,z,w). K is the quaternion that contains (dx,dy,dz,dw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (non-commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz - Aw Bw , Ax By + Ay Bx + Az Bw - Aw Bz , Ax Bz - Ay Bw + Az Bx + Aw By , Ax Bw + Ay Bz - Az By + Aw Bx) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum ---------------- S' = ( K - S q* S ) Note that S q* S = (x^2-y^2-z^2-w^2,2xy,2xz,2wx) S'' = S' q* C ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

Magnet4D | Theorically this is a convergent formula so it should NOT be supported by MB... Use "Cutting" at z=0 to see interesting views. This fractal is made of "closed cells", so normal views do not show many details... --- FIX THE MSET AT Z=0 SLICE (NOT COMPATIBLE WITH JULIA!) --- Put the formula as the first one, and set a nonzero value for "Fix z zero". This allows you to see the real magnet set at z=0, but x add will no longer work correctly. Please note that NOT all values are allowed for the multipliers; some will break the convergent bailout rule. Simply don't use those values! // z = ((z*z + pixel - 1) / (2*z + pixel - 2))^2 // bailout if |z| > bailout or |z-1| < small bailout. // This is an approximated version because I don't know how // to implement small bail. if fixz!=0 and itercount == 0 x=y=x1=y1=0; // forces the conformance to Magnet 2D set, // and avoids the 0-squaring bug (we will simply skip squaring part...) z1=z; // avoids weird errors due to uninitialized z1, and gives fancy 3D shape (if zmul=-1) else r1 = (x*x+y*y); r2 = (1 - z*z/r1); // "normal" formula for xyz squaring // does NOT work if x=y=0 but normally you will not notice it. x1 = (x*x - y*y) * r2; y1 = 2 * x*y * r2; z1 = 2 * z * sqrt r1; z1 *= zmul; endif x1 += Cx*cmu + xadd; y1 += Cy*cmu ; z1 += Cz*cmu ; // --- x2 = 2*x + xadd - 1 + Cx*cmd ; y2 = 2*y + Cy*cmd ; z2 = 2*zmul*z + Cz*cmd ; // --- R = x2*x2 + y2*y2 + z2*z2 ; r1 = sqrt(x1*x1+y1*y1); r2 = sqrt(x2*x2+y2*y2); z = r2 * z1 - r1 * z2; z = z / R; z *= zmul; R = (1 + z1 * z2/(r1*r2)) / R; x = +(x1 * x2 + y1 * y2) * R; y = -(x1 * y2 - y1 * x2) * R; // --- r1 = (x*x+y*y); r2 = (1 - z*z/r1); // "normal" formula for xyz squaring (again) // does NOT work if x=y=0 but normally you will not notice it. x' = (x*x - y*y) * r2; y' = 2 * x*y * r2; z' = 2 * z * sqrt r1; z' *= zmul; (... assign x=x' ... ) // I use w to fix bailout only. Don't care about w... w = (x-1)^2+y*y+z*z3; w = 1/w; // w will be added to x,y,z to see when we are bailing out | Escapetime 4D |

Makin4D p2a | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float s=|z| float t=|w| complex wt = w w = 2.0*z*w if s>=t z = sqr(z)*(1.0 - t/s) else z = (s/t-1.0)*sqr(wt) endif (now add C) | Escapetime 4D |

Makin4D p2b | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float m = |z|+|w| w = 2.0*z*w z = 2.0*sqr(z) float n = cabs(z) z = z*(1-m/n) (now add C) | Escapetime 4D |

Makin4D p4a | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float s=|z| float t=|w| complex wt = w w = 2.0*z*w if s>=t z = sqr(z)*(1.0 - t/s) else z = (s/t-1.0)*sqr(wt) endif (repeat twice then add C) | Escapetime 4D |

Makin4D p4b | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float m = |z|+|w| w = 2.0*z*w z = 2.0*sqr(z) float n = cabs(z) z = z*(1-m/n) (twice then add C) | Escapetime 4D |

Makin4D p8a | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float s=|z| float t=|w| complex wt = w w = 2.0*z*w if s>=t z = sqr(z)*(1.0 - t/s) else z = (s/t-1.0)*sqr(wt) endif (repeat three times then add C) | Escapetime 4D |

Makin4D p8b | Formula proposed by David Makin at the forums ( July 21, 2014 ). // here z and w are the complex // numbers containing x,y,z and w coords; float m = |z|+|w| w = 2.0*z*w z = 2.0*sqr(z) float n = cabs(z) z = z*(1-m/n) (three times then add C) | Escapetime 4D |

Mandel4DBiC | The good old 4D Mandelbrot in a basic bicomplex system. The first "3D fractals" ever were created in a similar way. Bicomplex numbers are just combiantions of complex numbers, so the easiest formula looks like this x' = x*x - y*y + Cx y' = 2*x*y + Cy z' = z*z - w*w + Cz w' = 2*z*w + Cw + wadd This involves in the most annoying squared quat-fractal of all times. But try to rotate and twist it in 4D, if you do so some interesting variations will appear! Also, this formula creates interesting variations together with Julibrot transform. ---------------- IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

MandyCousin | Description: A formula from David Makin. Found on http://bugman123.com/Hypercomplex/index.html some additional user parameters added: x' = X_mul * (x*x - y*y - z*z + w*w) + Cx y' = Y_mul * (x*y + z*w) + Cy z' = Z_mul1 * x*z + Z_mul2 * y*w + Cz w' = W_mul * (x*w + y*z) + W_add + Cw Zmul2 can be +2 for the standard variation 1 or -2 for the standard variation 2. | Escapetime 4D |

MandyCousin2 | Description: A formula from Stig Pettersson. Found on sp.ufm - it is very similar to Mandy Cousin, only two terms with different sign. He called it "MQuaternion". some additional user parameters added: x' = X_mul * (x*x - y*y - z*z - w*w) + Cx y' = Y_mul * (x*y - z*w) + Cy z' = Z_mul1 * x*z + Z_mul2 * y*w + Cz w' = W_mul * (x*w + y*z) + W_add + Cw | Escapetime 4D |

MandyCousin3 | Description: Complexified quaternions; this formula was found in T. Gintz's site. It's almost identical to MandyCousin. But different results are possible. some additional user parameters added: x' = X_mul * (x*x - y*y + z*z + w*w) + Cx y' = Y_mul * (x*y + z*w) + Cy z' = Z_mul1 * x*z + Z_mul2 * y*w + Cz w' = W_mul * (x*w - y*z) + W_add + Cw | Escapetime 4D |

PG-bulb | Description: This formula comes from Pseudogenius: http://www.fractalforums.com/3d-fractal-generation/a-different-3d-mandelbrot/ It is a midway between Mandelbulb and "squarry" quaternions I generalized it for any int power as follows. (here ax = a*x and so on) a=x, b=y, c=z, d=w+wadd, i=power-1 (if power is not in range I force i=7 to avoid loop troubles!!!) if oldangles = ON // angles never change = we will use always Cx & Cy as the reference! // this mode looks more interesting! costheta=(Cx^2-Cy^2)/(Cx^2+Cy^2); sintheta=(2*Cx*Cy)/(Cx^2+Cy^2); else // angles change at every function call // more fuzzy costheta=(a^2-b^2)/(a^2+b^2); sintheta=(2*a*b)/(a^2+b^2); endif do a'=ax-by-costheta*(cz)+sintheta*(cw+zd)+costheta*(dw); b'=ay+bx-sintheta*(cz)-costheta*(cw+zd)+sintheta*(dw); c'=az+xc-bw-yd; d'=aw+xd+bz+yc; (now copy a' in a ...) i=i-1; until i>0; x=a+Cx, y=b+Cy, z=c+Cz, w=d+Cw | Escapetime 4D |

QuadrayBrot | Description: This formula uses quadray numbers in 4D. Formula: ctx = fabs(Cx+ Cy+ Cz); cty = fabs(-Cx -Cy + Cz); ctz = fabs(-Cx + Cy-Cz); ctw = fabs(Cx-Cy -Cz); wz=2*w*z; xy=2*x*y; x'=x*x-y*y+wz+ctx; y'=y*y-x*x+wz+cty; z'=z*z-w*w+xy+ctz; w'=w*w-z*z+xy+ctw; Invented and kindly shared by Aexion, the author of Incendia, 2011. Implementation Luca GN. | Escapetime 4D |

Quaternion | A 4d quaternion formula, one iteration: x' = x*x - y*y - z*z - w*w + Cx y' = 2*(y*x + z*w) + Cy z' = 2*(z*x + YW_multiplier*y*w) + Cz w' = 2*(w*x + y*z) + W_add + Cw | Escapetime 4D |

QuatPow | This is a slow formula. If you don't like to wait, don't use it. This 4-D formula raises the coord. quat by arbitrary quat powers, following Hamiltonian theory. Plus, you can play with "anisotropic" angular powers; they are apx,apy,apz,apw. They give strange sharpy effects. If this is not enough, you can modify the influence of c premultiplying it by a factor. Don't use this formula mindlessly; remember that negative powers are not supported by MB. ---------------- P is the quaternion that contains (px,py,pz,pw). C is the quaternion that contains (Cx,Cy,Cz,Cw). Defining quat multiplication as follows (non-commutative rule); A q* B := ( Ax Bx - Ay By - Az Bz - Aw Bw , Ax By + Ay Bx + Az Bw - Aw Bz , Ax Bz - Ay Bw + Az Bx + Aw By , Ax Bw + Ay Bz - Az By + Aw Bx) A + B := ( Ax + Bx , ... , Aw + Bw ) term by term sum log() and exp() are _log4D and _exp4D formulas respectively ---------------- S' = log( S ) S'' is obtained multiplying S'x by apx, S'y by apy ... S''' = S'' q* P S'''' = exp ( S''') S''''' = S'''' + ( C * cmul ) ---------------- FORMULA AND IMPLEMENTATION; 100% by Luca G.N. 2011. | Escapetime 4D |

_ScaleC4d | Scale the 4d vector length and the 4d C vector: x = x * Scale y = y * Scale z = z * Scale w = w * Scale Cx = Cx * Scale_C Cy = Cy * Scale_C Cz = Cz * Scale_C Cw = Cw * Scale_C Useful for scaling the whole coordinate system in DEcomb mode, for example. | Escapetime 4D with Analytic |

ABoxMod4d | Description: A modification and simplification of the amazing box as suggested by Trafassel. The formula is a bit changed, but not to affect the outcome: x = abs(x+Fold) - Fold y = abs(y+Fold) - Fold z = abs(z+Fold) - Fold w = abs(w+Fold) - Fold rr = x*x + y*y + z*z + w*w + 1e-60 if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz w = w * m + W_add + Cw | Escapetime 4D with Analytic |

ABoxSphereOffset4d | Description: A 4d "Amazing Box" (invented by TGlad) aka Mandbox variation, having an offset for the sphere folding: x = abs(x+Fold) - abs(x-Fold) - x - Sphere_offset_X y = abs(y+Fold) - abs(y-Fold) - y - Sphere_offset_Y z = abs(z+Fold) - abs(z-Fold) - z - Sphere_offset_Z w = abs(w+Fold) - abs(w-Fold) - w - Sphere_offset_W rr = x*x + y*y + z*z + w*w if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Sphere_offset_X + Cx y = y * m + Sphere_offset_Y + Cy z = z * m + Sphere_offset_Z + Cz w = w * m + Sphere_offset_W + W_add + Cw | Escapetime 4D with Analytic |

ABoxVaryScale4d | Description: A 4d "Amazing Box" (invented by TGlad) aka Mandbox variation, having a changing scale with iterationcount and a power function on the sphere folding: Scale = Scale + Scale_vary*(abs(Scale)-1) x = abs(x+Fold) - abs(x-Fold) - x y = abs(y+Fold) - abs(y-Fold) - y z = abs(z+Fold) - abs(z-Fold) - z w = abs(w+Fold) - abs(w-Fold) - w rr = pow(x*x + y*y + z*z + w*w, R_power) if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else if rr < 1 then m = Scale/rr else m = Scale x = x * m + Cx y = y * m + Cy z = z * m + Cz w = w * m + W_add + Cw | Escapetime 4D with Analytic |

HalfOct4a | Description: NOTE: If the formula does not render correctly together with 3D formulas check "Disable analytical DE". An attempt to make a 4D KIFS with half octahedral planes. w is folded like x,y,z: if(x-y<0){x1=y;y=x;x=x1;} if(x+y<0){x1=-y;y=-x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(x-w<0){x1=w;w=x;x=x1;} if(x+w<0){x1=-w;w=-x;x=x1;} Half octahedral planes were defined in original KIFS thread. LUCA GN 2011 | Escapetime 4D with Analytic |

HalfOct4b | Description: NOTE: If the formula does not render correctly together with 3D formulas check "Disable analytical DE". An attempt to make a 4D KIFS with half octahedral planes. w is folded like in Sierpinski4: if(x-y<0){x1=y;y=x;x=x1;} if(x+y<0){x1=-y;y=-x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(z.x+z.w<0.0) z.xw = -z.wx; if(z.y+z.w<0.0) z.yw = -z.wy; if(z.z+z.w<0.0) z.zw = -z.wz; Half octahedral planes were defined in original KIFS thread. LUCA GN 2011 | Escapetime 4D with Analytic |

Menger4 | Description:
NOTE: If the formula does not render correctly together with 3D formulas check "Disable analytical DE".
Thanks a lot (I mean a lot) to Syntopia for the ideas that made easily possible this formula.
This is a 4D extension of the 3D Menger KIFS, with a built-in 4D rotation.
In fact if you try CScaleW=0 you get again the normal 3D Menger solid!
"Source code" with small modifications and comments;
Menger4IFS(x,y,z,w){
r=x*x+y*y+z*z;
for(i=0;i | Escapetime 4D with Analytic |

Menger4ex | Description: NOTES: See Menger4. This is a 4D extension of the 3D Menger KIFS, with a built-in 4D rotation plus you can move arbitrarily in 4D the rotation center. Of course this has no effect until you change the rotation angles - if you leave zero, no rotation and no offset! 🙂 LUCA GN 2011 | Escapetime 4D with Analytic |

MixPinski4 | Description:
NOTE: If the formula does not render correctly together with 3D formulas check "Disable analytical DE".
A strange but intriguing fractal, that mixes Sierpinski and Menger folds. The amazing thing is that in 3D it does not work so well!
MixPinski4(x,y,z,w){
r=x*x+y*y+z*z;
for(i=0;i | Escapetime 4D with Analytic |

MixPinski4ex | Description: NOTES: See Sierpinski4ex and Menger4ex for any explanation. LUCA GN 2011 | Escapetime 4D with Analytic |

Octahedron4 | Description: See Sierpinski4, but instead of tetrahedral shapes you will get octahedral ones. This is my own formula. Source code; float Octahedron4(vec4 z) { // ... See Sierpinski4 until folding then // This is the hyper-octaedral folding x=abs(x);y=abs(y);z=abs(z);w=abs(w); if(x-y<0){x1=y;y=x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(y-z<0){y1=z;z=y;y=y1;} // ... fold w like in Menger4 ... and finally // ... See Sierpinski4 } LUCA GN 2011 | Escapetime 4D with Analytic |

Sierpinski4 | This is a 4D extension of the 3D Sierpinski KIFS, with a built-in 4D rotation. In fact if you try CScaleW=0 you get again the normal 3D Sierpinski solid! "Source code" with small modifications and comments; float Sierpinski4(vec4 z) { float r; int n = 0; while (n < Iterations) { // This is the hyper-tetraedral folding if(z.x+z.y<0.0) z.xy = -z.yx; if(z.x+z.z<0.0) z.xz = -z.zx; if(z.y+z.z<0.0) z.zy = -z.yz; if(z.x+z.w<0.0) z.xw = -z.wx; if(z.y+z.w<0.0) z.yw = -z.wy; if(z.z+z.w<0.0) z.zw = -z.wz; Rotate4D (z,Angles4D); // <- placed by me to make it a "true" KIFS z = z*Scale - Offset4*(Scale-1.0); n++; } return (length(z) ) * pow(Scale, -float(n)); } | Escapetime 4D with Analytic |

Sierpinski4ex | Description: NOTES: See Sierpinski4. This is a 4D extension of the 3D Sierpinski KIFS, with a built-in 4D rotation, plus you can move arbitrarily in 4D the rotation center. Of course this has no effect until you change the rotation angles - if you leave zero, no rotation and no offset! 🙂 LUCA GN 2011 | Escapetime 4D with Analytic |

_Abs4d | Takes the absolute values of all 4 vector components: x' = abs(x) y' = abs(y) z' = abs(z) w' = abs(w) | Escapetime Transformations Only |

_AbsX | Description: Absolute value for x (with fixing constant) - Can work as a "mirror" or... ?! Formula by Luca GN 2011 x' = abs(x+fixX)-fixX | Escapetime Transformations Only |

_AbsY | Description: Absolute value for y (with fixing constant) - Can work as a "mirror" or... ?! Formula by Luca GN 2011 y' = abs(y+fixY)-fixY | Escapetime Transformations Only |

_AbsZ | Description: Absolute value for z (with fixing constant) - Can work as a "mirror" or... ?! Formula by Luca GN 2011 z' = abs(z+fixZ)-fixZ | Escapetime Transformations Only |

_addC | No “i” info | Escapetime Transformations Only |

_asdamTrans | A cool 3D transform suggested by Asdam in the forums; vec3d += Scale * Rotation * vec3d / cabs3d(vec3d) Where cabs3d(x,y,z) = sqrt(x*x + y*y + z*z) Somewhat similar to a pinch/punch effect. LucaGN & Asdam 2012 | Escapetime Transformations Only |

_BenesiSpheric | Description: Warps a cube to a sphere; transform made by M.Benesi and Luca. Inverse of "_BenesiUnSpheric". Can be used in conjunction with it for cool effects (place some formulas in the middle to see what happens). / spheric code rCyz= (z.y*z.y)/(z.z*z.z); rCxyz= (z.y*z.y+z.z*z.z)/(z.x*z.x); if (rCyz<1.) {rCyz=sqrt(rCyz+1.);} else {rCyz=sqrt(1./rCyz+1.);} if (rCxyz<1.) {rCxyz=sqrt(rCxyz+1.);} else {rCxyz=sqrt(1./rCxyz+1.);} z.yz*=rCyz; z*=rCxyz/sr32; | Escapetime Transformations Only |

_BenesiT1 | Description: Cool?? 😀 absolute value xyz transform; // STEP1: "Benesi transform 1" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; Coded & invented by M.Benesi 2015 | Escapetime Transformations Only |

_BenesiT2 | Description: Another transform suggested & coded by M.Benesi (2015); // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs(sqrt(ty+z)-offset2)*scale2*sqrt(1/2) ; y=abs(sqrt(tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs(sqrt(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); z=z*sqrt(2/3)-x*sqrt(1/3); | Escapetime Transformations Only |

_BenesiT3 | Description: Another transform suggested & coded by M.Benesi (2015); // STEP1: "Benesi fold 3" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); //replace squaring with abs D8C8 to D9E1 done tx=abs(tx-y); ty=abs(tx+y); x=abs(ty+z-offset2)*scale2*sqrt(1/2) ; //remove sqrt part for these three done y=abs(tx+z-offset2)*scale2*sqrt(1/2) ; z=abs(tx+ty-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) | Escapetime Transformations Only |

_BenesiUnSpheric | Description: Warps a sphere to a cube; transform made by M.Benesi, optimized by Luca. Inverse of "_BenesiSpheric". Can be used in conjunction with it for cool effects (place some formulas in the middle to see what happens). void unSpheric (inout vec3 z) { float rCyz= (z.y*z.y)/(z.z*z.z); if (rCyz<1.) {rCyz=1./sqrt(rCyz+1.);} else {rCyz=1./sqrt(1./rCyz+1.);} z.yz*=rCyz; float rCxyz= (z.y*z.y+z.z*z.z)/(z.x*z.x); if (rCxyz<1.) {rCxyz=1./sqrt(rCxyz+1.);} else {rCxyz=1./sqrt(1./rCxyz+1.);} z.xyz*=rCxyz*sr32; } | Escapetime Transformations Only |

_Bmod_FernTransform | Use for example with CylinderIFS [0.03,2,1,0,0,0,0,0,0] as first formula. DD01dd02dd03D9C1D9E1D84FBCD8C1D9E0D85FF4DFE0D0EC723e D847F4D947F0DCCBDCCADEC9D9C1D84FE8D9C1D84FECDEE9D9CAD8 4FECD9C9D84FE8DEC1D9C2D84FE0D9C1D84FE4DEE9D9CBD84FE4D9C9D84FE0DE C1EB6a D9C9D9E4DFE0D0EC7228 D9C9D847C0D9C1D84FC8D9C1D84FCCDEE9D9CA D84FCCD9C9D84FC8DEC1D947D0DCCBDCCADEC9EB30 D9E0D9E4DFE0D0EC7226 D9C9D847C4D9C1D84FD4D9C1D84FD8DEE9D9CAD84FD8D9C9D8 4FD4DEC1 D947DCDCCBDCCADEC9dd1bdd1add19 0043C270 DD01 FLD QWORD PTR DS:[ECX] 0043C272 DD02 FLD QWORD PTR DS:[EDX] 0043C274 DD03 FLD QWORD PTR DS:[EBX] 0043C276 D9C1 FLD ST(1) 0043C278 D9E1 FABS 0043C27A D84F BC FMUL DWORD PTR DS:[EDI-44] 0043C27D D8C1 FADD ST,ST(1) 0043C27F D9E0 FCHS 0043C281 D85F F4 FCOMP DWORD PTR DS:[EDI-C] 0043C284 DFE0 FSTSW AX 0043C286 D0EC SHR AH,1 0043C288 72 3E JB SHORT accessch.0043C2C8 0043C28A D847 F4 FADD DWORD PTR DS:[EDI-C] 0043C28D D947 F0 FLD DWORD PTR DS:[EDI-10] 0043C290 DCCB FMUL ST(3),ST 0043C292 DCCA FMUL ST(2),ST 0043C294 DEC9 FMULP ST(1),ST 0043C296 D9C1 FLD ST(1) 0043C298 D84F E8 FMUL DWORD PTR DS:[EDI-18] 0043C29B D9C1 FLD ST(1) 0043C29D D84F EC FMUL DWORD PTR DS:[EDI-14] 0043C2A0 DEE9 FSUBP ST(1),ST 0043C2A2 D9CA FXCH ST(2) 0043C2A4 D84F EC FMUL DWORD PTR DS:[EDI-14] 0043C2A7 D9C9 FXCH ST(1) 0043C2A9 D84F E8 FMUL DWORD PTR DS:[EDI-18] 0043C2AC DEC1 FADDP ST(1),ST 0043C2AE D9C2 FLD ST(2) 0043C2B0 D84F E0 FMUL DWORD PTR DS:[EDI-20] 0043C2B3 D9C1 FLD ST(1) 0043C2B5 D84F E4 FMUL DWORD PTR DS:[EDI-1C] 0043C2B8 DEE9 FSUBP ST(1),ST 0043C2BA D9CB FXCH ST(3) 0043C2BC D84F E4 FMUL DWORD PTR DS:[EDI-1C] 0043C2BF D9C9 FXCH ST(1) 0043C2C1 D84F E0 FMUL DWORD PTR DS:[EDI-20] 0043C2C4 DEC1 FADDP ST(1),ST 0043C2C6 EB 6A JMP SHORT accessch.0043C332 0043C2C8 D9C9 FXCH ST(1) 0043C2CA D9E4 FTST 0043C2CC DFE0 FSTSW AX 0043C2CE D0EC SHR AH,1 0043C2D0 72 28 JB SHORT accessch.0043C2FA 0043C2D2 D9C9 FXCH ST(1) 0043C2D4 D847 C0 FADD DWORD PTR DS:[EDI-40] 0043C2D7 D9C1 FLD ST(1) 0043C2D9 D84F C8 FMUL DWORD PTR DS:[EDI-38] 0043C2DC D9C1 FLD ST(1) 0043C2DE D84F CC FMUL DWORD PTR DS:[EDI-34] 0043C2E1 DEE9 FSUBP ST(1),ST 0043C2E3 D9CA FXCH ST(2) 0043C2E5 D84F CC FMUL DWORD PTR DS:[EDI-34] 0043C2E8 D9C9 FXCH ST(1) 0043C2EA D84F C8 FMUL DWORD PTR DS:[EDI-38] 0043C2ED DEC1 FADDP ST(1),ST 0043C2EF D947 D0 FLD DWORD PTR DS:[EDI-30] 0043C2F2 DCCB FMUL ST(3),ST 0043C2F4 DCCA FMUL ST(2),ST 0043C2F6 DEC9 FMULP ST(1),ST 0043C2F8 EB 30 JMP SHORT accessch.0043C32A 0043C2FA D9E0 FCHS 0043C2FC D9E4 FTST 0043C2FE DFE0 FSTSW AX 0043C300 D0EC SHR AH,1 0043C302 72 26 JB SHORT accessch.0043C32A 0043C304 D9C9 FXCH ST(1) 0043C306 D847 C4 FADD DWORD PTR DS:[EDI-3C] 0043C309 D9C1 FLD ST(1) 0043C30B D84F D4 FMUL DWORD PTR DS:[EDI-2C] 0043C30E D9C1 FLD ST(1) 0043C310 D84F D8 FMUL DWORD PTR DS:[EDI-28] 0043C313 DEE9 FSUBP ST(1),ST 0043C315 D9CA FXCH ST(2) 0043C317 D84F D8 FMUL DWORD PTR DS:[EDI-28] 0043C31A D9C9 FXCH ST(1) 0043C31C D84F D4 FMUL DWORD PTR DS:[EDI-2C] 0043C31F DEC1 FADDP ST(1),ST 0043C321 D947 DC FLD DWORD PTR DS:[EDI-24] 0043C324 DCCB FMUL ST(3),ST 0043C326 DCCA FMUL ST(2),ST 0043C328 DEC9 FMULP ST(1),ST dd1b dd1a dd19 end | Escapetime Transformations Only |

_boxtiling | Description: 4D tiling, the entire space will be filled with copies of a box with center in the origin and desired dimensions. All boxes are equal, and the tiling is (theorically) infinitely extended (but it depends to the floating point precision, so it is not really). It can be easily turned off for one (or more?) dimension(s) if you just set to 0 the corresponding size. With this trick you can do any 3D, 2D, 1D "box-tiling" that you can even think with various effects. Works perfectly with IFS fractals and has strange effects on normal ones. For people with familiarity with UltraFractal; this is an extension of the "Gaussian integer" concept. xi = every dimension (x,y,z,w) i = 1 to 4 if sizei <> 0 xi = xi - frndint(xi/sizei)*sizei (where xi is x,y,... etc. ) endif next i frndint -> rounds a float to the nearest integer | Escapetime Transformations Only |

_BPolyCircleTransformV2 | Mandelbulb, after transform 1, before Pine Only without yz components. Use it sparingly... or a lot. I was thinking of having both an x-range, and a w-range for this one, so if we store an old iteration value of the x-range somewhere, we'll be able to access it again. Tried it with ECX+8, think I'm going to have to ask Andreas about this one. <-- note to Andreas... 😀 Starts at x=xStart Increases strength * polystrength until it reaches xStart+xStartEnd then stays transformed and starts to drop off at xEnd-sStartEnd rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz/=cos(rCyz); Polystrength <= z.yz*=cos(rCyz) 😀 M Benesi Code stuff.... dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd47e8d9e1dec9d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19 dd03dc57e0dfe09b9e0F86BA000000dc57d0dfe09b9e0F83AD000000 dd57e0dd57d8d9e1dec1DD5DF8DC55F8DFE09B9E730E DC67E0DC77D8DC4FE8DD5DE8EB34 D9D0DD57D0DD57D8D9E1DEC1DD5DF8DC55F8DFE09B9E7610 D9E0DC47D0DC77D8DC4FE8DD5DE8EB0CDDD8DD47E8DD5DE8EB02DDD8 dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd45e8d9e1dec9d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19 0043D25B DD03 FLD QWORD PTR DS:[EBX] 0043D25D DC57 E0 FCOM QWORD PTR DS:[EDI-20] 0043D260 DFE0 FSTSW AX 0043D262 9B WAIT 0043D263 9E SAHF 0043D264 76 66 JBE SHORT accessch.0043D2CC 0043D266 DC57 D0 FCOM QWORD PTR DS:[EDI-30] 0043D269 DFE0 FSTSW AX 0043D26B 9B WAIT 0043D26C 9E SAHF 0043D26D 73 66 JNB SHORT accessch.0043D2D5 0043D26F DD57 E0 FST QWORD PTR DS:[EDI-20] 0043D272 DD57 D8 FST QWORD PTR DS:[EDI-28] 0043D275 D9E1 FABS 0043D277 DEC1 FADDP ST(1),ST 0043D279 DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043D27C DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043D27F DFE0 FSTSW AX 0043D281 9B WAIT 0043D282 9E SAHF 0043D283 73 0E JNB SHORT accessch.0043D293 0043D285 DC67 E0 FSUB QWORD PTR DS:[EDI-20] 0043D288 DC77 D8 FDIV QWORD PTR DS:[EDI-28] 0043D28B DC4F E8 FMUL QWORD PTR DS:[EDI-18] 0043D28E DD5D E8 FSTP QWORD PTR SS:[EBP-18] 0043D291 EB 66 JMP SHORT accessch.0043D2F9 0043D293 DD57 D0 FST QWORD PTR DS:[EDI-30] 0043D296 DD57 D8 FST QWORD PTR DS:[EDI-28] 0043D299 D9E1 FABS 0043D29B DEC1 FADDP ST(1),ST 0043D29D DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043D2A0 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043D2A3 DFE0 FSTSW AX 0043D2A5 9B WAIT 0043D2A6 9E SAHF 0043D2A7 76 10 JBE SHORT accessch.0043D2B9 0043D2A9 D9E0 FCHS 0043D2AB DC47 D0 FADD QWORD PTR DS:[EDI-30] 0043D2AE DC77 D8 FDIV QWORD PTR DS:[EDI-28] 0043D2B1 DC4F E8 FMUL QWORD PTR DS:[EDI-18] 0043D2B4 DD5D E8 FSTP QWORD PTR SS:[EBP-18] 0043D2B7 EB 08 JMP SHORT accessch.0043D2C1 0043D2B9 DDD8 FSTP ST 0043D2BB DD47 E8 FLD QWORD PTR DS:[EDI-18] 0043D2BE DD5D E8 FSTP QWORD PTR SS:[EBP-18] 0043D2C1 DD07 FLD QWORD PTR DS:[EDI] 0043D2C3 DC77 F0 FDIV QWORD PTR DS:[EDI-10] 0043D2C6 DD55 F8 FST QWORD PTR SS:[EBP-8] 0043D2C9 D8C0 FADD ST,ST 0043D2CB DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0043D2CE DD01 FLD QWORD PTR DS:[ECX] 0043D2D0 DD02 FLD QWORD PTR DS:[EDX] 0043D2D2 D9F3 FPATAN | Escapetime Transformations Only |

_BPolyCircleTransformV2_W | Description: Polygon circle transform centered on the x axis (transforms yz plane). I made it for before Pine Tree Mandelbulb, after transform 1, before Pine Only without yz components. Use it sparingly... or a lot. I'm thinking of having both an x-range, and a w-range for this one, so if we store an old iteration value of the x-range somewhere, we'll be able to access it again. Starts at x=xStart Increases strength * polystrength until it reaches xStart+xStartEnd then stays transformed and starts to drop off at xEnd-sStartEnd rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz/=cos(rCyz); Polystrength <= z.yz*=cos(rCyz) 😀 M Benesi dd46c8d9e1dd47c8d9e1dd5df8dc55f8dfe09b9e7605DD65f8ebf2dc47c0 0043E60B DD46 C8 FLD QWORD PTR DS:[ESI-38] 0043E60E D9E1 FABS 0043E610 DD47 C8 FLD QWORD PTR DS:[EDI-38] 0043E613 D9E1 FABS 0043E615 DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043E618 DC55 F8 FCOM QWORD PTR SS:[EBP-8] old stuff 0043E61B DFE0 FSTSW AX 0043E61D 9B WAIT 0043E61E 9E SAHF 0043E61F 76 05 JBE SHORT accessch.0043E626 0043E621 DD65 f8 FLD QWORD PTR DS:[EDI-38] ebf2 eb Code stuff.... dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd47e8d9e1dec9d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19 dd03dc57e0dfe09b9e0F86BA000000dc57d0dfe09b9e0F83AD000000 dd57e0dd57d8d9e1dec1DD5DF8DC55F8DFE09B9E730E DC67E0DC77D8DC4FE8DD5DE8EB34 D9D0DD57D0DD57D8D9E1DEC1DD5DF8DC55F8DFE09B9E7610 D9E0DC47D0DC77D8DC4FE8DD5DE8EB0CDDD8DD47E8DD5DE8EB02DDD8 dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd45e8d9e1dec9d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19 0043D25B DD03 FLD QWORD PTR DS:[EBX] 0043D25D DC57 E0 FCOM QWORD PTR DS:[EDI-20] 0043D260 DFE0 FSTSW AX 0043D262 9B WAIT 0043D263 9E SAHF 0043D264 76 66 JBE SHORT accessch.0043D2CC 0043D266 DC57 D0 FCOM QWORD PTR DS:[EDI-30] 0043D269 DFE0 FSTSW AX 0043D26B 9B WAIT 0043D26C 9E SAHF 0043D26D 73 66 JNB SHORT accessch.0043D2D5 0043D26F DD57 E0 FST QWORD PTR DS:[EDI-20] 0043D272 DD57 D8 FST QWORD PTR DS:[EDI-28] 0043D275 D9E1 FABS 0043D277 DEC1 FADDP ST(1),ST 0043D279 DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043D27C DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043D27F DFE0 FSTSW AX 0043D281 9B WAIT 0043D282 9E SAHF 0043D283 73 0E JNB SHORT accessch.0043D293 0043D285 DC67 E0 FSUB QWORD PTR DS:[EDI-20] 0043D288 DC77 D8 FDIV QWORD PTR DS:[EDI-28] 0043D28B DC4F E8 FMUL QWORD PTR DS:[EDI-18] 0043D28E DD5D E8 FSTP QWORD PTR SS:[EBP-18] 0043D291 EB 66 JMP SHORT accessch.0043D2F9 0043D293 DD57 D0 FST QWORD PTR DS:[EDI-30] 0043D296 DD57 D8 FST QWORD PTR DS:[EDI-28] 0043D299 D9E1 FABS 0043D29B DEC1 FADDP ST(1),ST 0043D29D DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043D2A0 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043D2A3 DFE0 FSTSW AX 0043D2A5 9B WAIT 0043D2A6 9E SAHF 0043D2A7 76 10 JBE SHORT accessch.0043D2B9 0043D2A9 D9E0 FCHS | Escapetime Transformations Only |

_BPolygonFromCircle | Description: Circle to polygon transform centered on the x axis (transforms yz plane). I made it for before Pine Tree Mandelbulb, after transform 1. Use it sparingly... or a lot. Beware of negative numbers.. might do something wacky. Well... for anything below 2.5 sides it will be wacky. rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz*=cos(rCyz); 😀 M Benesi | Escapetime Transformations Only |

_BPolygonFromCircleV2 | Description: Circle to polygon transform centered on the x axis (transforms yz plane). I made it for before Pine Tree Mandelbulb, after transform 1. Use it sparingly... or a lot. Beware of negative numbers.. might do something wacky. Well... for anything below 2.5 sides it will be wacky. UPDATE: Smooth transition from circle to polygon. PolyStrength=0 is still a circle, Polystrength=1 is full polygon. Negative numbers... well, you play with it. rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz*=cos(rCyz); 😀 M Benesi notes: dd47e8 dd5de8 load mult save to ebp-18 558BEC81EC300000005356578B75088B7E308BD8D9D0dd07 dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 80e4417f05dc65f0ebf1d9ffd9c0dc0add1ad9d0dc09dd19D9D0 8BC35F5E5B89EC5DC20800 0042E99F DD07 FLD QWORD PTR DS:[EDI] load pi 0042E9A1 DC77 F0 FDIV QWORD PTR DS:[EDI-10] pi/sides 0042E9A4 DD55 F8 FST QWORD PTR SS:[EBP-8] save 0042E9A7 D8C0 FADD ST,ST 0042E9A9 DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0042E9AC DD01 FLD QWORD PTR DS:[ECX] 0042E9AE DD02 FLD QWORD PTR DS:[EDX] 0042E9B0 D9F3 FPATAN 0042E9B2 D9E1 FABS 0042E9B4 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0042E9B7 DFE0 FSTSW AX 0042E9B9 80E4 41 AND AH,41 0042E9BC 7F 05 JG SHORT accessch.0042E9C3 0042E9BE DC65 F0 FSUB QWORD PTR SS:[EBP-10] 0042E9C1 ^EB F1 JMP SHORT accessch.0042E9B4 0042E9C3 D9FF FCOS 558BEC81EC300000005356578B75088B7E308BD8D9D0dd07 dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 80e4417f05dc65f0ebf1d9ffd9e8dee9dc4de8d9e8dec1d9c0dc0add1ad9d0dc09dd19D9D0 8BC35F5E5B89EC5DC20800 d9e8 fld1 dee9 fsubp cos-1 DC4D E8 fmul e8 d9e8 dec1 d9e8dee9dc4de8d9e8dec1 0042E9C5 D9C0 FLD ST 0042E9C7 DC0A FMUL QWORD PTR DS:[EDX] 0042E9C9 DD1A FSTP QWORD PTR DS:[EDX] 0042E9CB D9D0 FNOP 0042E9CD DC09 FMUL QWORD PTR DS:[ECX] 0042E9CF DD19 FSTP QWORD PTR DS:[ECX] | Escapetime Transformations Only |

_BPolygonToCircle | Description: Circle to polygon transform centered on the x axis (transforms yz plane). I made it for before Pine Tree Mandelbulb, after transform 1. Use it sparingly... or a lot. rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz/=cos(rCyz); 😀 M Benesi | Escapetime Transformations Only |

_BPolygonToCircleV2 | Description: Circle to polygon transform centered on the x axis (transforms yz plane). I made it for before Pine Tree Mandelbulb, after transform 1. Use it sparingly... or a lot. UPDATE V2: Polystrength <0 transforms from circle to Poly! rCyz=abs(atan(z.z,z.y)); while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz/=cos(rCyz); Polystrength <= z.yz*=cos(rCyz) 😀 M Benesi dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dc4fe8d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19D9D0 0043D1F2 DD07 FLD QWORD PTR DS:[EDI] 0043D1F4 DC77 F0 FDIV QWORD PTR DS:[EDI-10] 0043D1F7 DD55 F8 FST QWORD PTR SS:[EBP-8] 0043D1FA D8C0 FADD ST,ST 0043D1FC DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0043D1FF DD01 FLD QWORD PTR DS:[ECX] 0043D201 DD02 FLD QWORD PTR DS:[EDX] 0043D203 D9F3 FPATAN 0043D205 D9E1 FABS 0043D207 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043D20A DFE0 FSTSW AX 0043D20C 9B WAIT 0043D20D 9E SAHF 0043D20E 76 05 J=Be SHORT accessch.0043D215 0043D210 DC65 F0 FSUB QWORD PTR SS:[EBP-10] 0043D213 ^EB F2 JMP SHORT accessch.0043D207 0043D215 D9FF FCOS /////move 0043D217 D9E8 FLD1 0043D219 DEE9 FSUBP ST(1),ST dd47e8d9e1dec9 dd07dc77f0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd47e8d9e1dec9d9e8dec1 dd47e8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19D9D0 //out maybe?? 0043D21B DC4F E8 FMUL QWORD PTR DS:[EDI-18] 0043D21E D9E8 FLD1 0043D220 DEC1 FADDP ST(1),ST //// move 0043D222 DD47 E8 FLD QWORD PTR DS:[EDI-18] 0043D225 D9E4 FTST 0043D227 DFE0 FSTSW AX 0043D229 9B WAIT 0043D22A 9E SAHF 0043D22B 73 08 Jbe SHORT accessch.0043D235 0043D22D DDD8 FSTP ST 0043D22F D9E8 FLD1 0043D231 DEF1 FDIVRP ST(1),ST 0043D233 EB 02 JMP SHORT accessch.0043D237 0043D235 DDD8 FSTP ST 0043D237 D9C0 FLD ST 0043D239 DC0A FMUL QWORD PTR DS:[EDX] 0043D23B DD1A FSTP QWORD PTR DS:[EDX] 0043D23D D9D0 FNOP 0043D23F DC09 FMUL QWORD PTR DS:[ECX] 0043D241 DD19 FSTP QWORD PTR DS:[ECX] 0043D243 D9D0 FNOP | Escapetime Transformations Only |

_BPolyhedronFromSphere | Description: Sphere to polyhedron transform. Does not make regular polydedra, except for the cube! I'm probably going to make a single regular tetrahedron/sphere and a sphere/tetrahedron transform, so we can do stuff with the Sierpinski tetrahedron (combine it with the Pine Tree, by sphering it first!). We can already make a Menger a sphere, do the Pine Tree thing, and square it up, do the Menger since we have the cube to sphere and sphere to cube transforms.... 😉 Here is the math, so it can easily be translated to other languages: rCyz=abs(atan(z.z,z.y)); //atan is atan2 (arg!!!!) abs is absolute value while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } // if rCyz> pi/sides, subtract 2*pi/sides from it z.yz*=cos(rCyz); // until it isn't greater than pi/sides... //z.yz*=whatever; means y= y*whatever and z= z*whatever rCxyz=abs(atan(sqrt(z.z*z.z+z.y*z.y),z.x)); while (rCxyz>pi/sides2) {rCxyz-=2.*pi/sides2; } // same concept here!!!! z.xyz*=cos(rCxyz); 😀 M Benesi | Escapetime Transformations Only |

_BPolyhedronToSphere | Here is the math, so it can easily be translated to other languages: rCyz=abs(atan(z.z,z.y)); //atan is atan2 (arg!!!!) abs is absolute value while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } // if rCyz> pi/sides, subtract 2*pi/sides from it z.yz/=cos(rCyz); // until it isn't greater than pi/sides... //z.yz/=whatever; means y= y/whatever and z= z/whatever rCxyz=abs(atan(sqrt(z.z*z.z+z.y*z.y),z.x)); while (rCxyz>pi/sides2) {rCxyz-=2.*pi/sides2; } // same concept here!!!! z.xyz/=cos(rCxyz); 😀 | Escapetime Transformations Only |

_BRotateFromMag | Description: Rotates from the magnitude axis (-1,-1,-1) --> (1,1,1) to the x-axis (-1,0,0) --> (1,0,0) tx=y+x; y=y-x; x=z*sqrt(1/3)+tx*sqrt(2/3); z=z*sqrt(2/3)-tx*sqrt(1/3); 😀 M Benesi | Escapetime Transformations Only |

_BRotateToMag | Description: This rotates the whole coordinate system so that the x-axis (-1,0,0) --> (1,0,0) lies on the mag axis (-1,-1,-1) --> (1,1,1). // this.. I think. Maybe... 😀 tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3)); x=(tx-y); y=(tx+y); 😀 M Benesi | Escapetime Transformations Only |

_BSkewXmaxV1 | Description: Alters the x variable- which the T1 Pine Tree Mandelbulb revolves around. Altering the one variable, rotating around the x axis, doing things to only the x variable... it works well with that particular type of fractal. This formula isn't complete. I wrote it, made an assembly language mistake, and it was surrendipitous, so here we are. I didn't finish adding everything that I intended to add, or setting it up completely. This is an alpha version. This formula WILL be changed, thus the "V1" at the end of its name. The newer one will be V2, and have different features. ss1= (xmax-|x|)*(|x|-xmin) * ScaleX; ss2 = (xpixelmax-|xpixel|)* (|xpixel|-xpixelmin) *pixelScale; yz = sqrt(y^2+z^2)*yzScale //finish yzpart... still have 2 options that don't work!!! x' = x- yz -ss1-ss2; 😀 M Benesi | Escapetime Transformations Only |

_BSpinBobber_333 | dd47c8d9e4dfe09b9e7507ddd8e91d010000ddd8 dd47c0dc67d0d9e1dd47c8d9e1dd5dc8dc55c8dfe09b9e7305dd5dc8eb02ddd8 dd47c0dc67d0D9E4DFE09b9eddd8dd45c8d9e10f83e8000000 d9e0dd5dc8dd03d9d0dc57d0dfe09b9e7607ddd8e9c9000000 dc57c0dfe09b9e730Ddc67c0dc47d0dd1be9b3000000 dd47c0dc67d0dc55c8dfe09b9ed9d0 7307dc65c8ebf0d9d0 dd5dc0d9d0dd47c0dc65c0dd5db8dc55b8dfe09b9e7336 d9d0 dc65b8dd45c0dc4f10dd5dc8dc55c8dfe09b9e760Adc47d0dd1be963000000 ddd8dd47c0dd03d9e0dec1dc47d0dd1be94e000000 dd47d0dd47c8d9e1d9e0dec1dd5dc0dc55c0dfe09b9e7309 dd47c8d9e1dec1ebee dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0c d9e0dd45c8dec1dc47d0dd1b e9d6000000e9d100000090 DD5DC890dd03dc57d0dfe09b9e7307ddd8e9ba000000 dc57c0dfe09b9e760Ddc67c0dc47d0dd1be9a4000000 dd47c0dc67d0dc55c8dfe09b9ed9d0 7605dc65c8ebf0 dd5dc0d9d0dd47c0dc65c0dd5db8dc55b8dfe09b9e762e dc65b8dd45c0dc4f10dd5dc8dc55c8dfe09b9e7307 dc47d0dd1beb5b ddd8dd47c0dd03d9e0dec1dc47d0dd1beb49 dd47d0dd47c8d9e1dec1dd5dc0dc55c0dfe09b9e760b dd47c8d9e1d9e0dec1ebec dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0c d9e0dd45c8dec1dc47d0dd1b zero cycle check good: 00432E89 DD47 C8 FLD QWORD PTR DS:[EDI-38] 00432E8C D9E4 FTST 00432E8E DFE0 FSTSW AX 00432E90 9B WAIT 00432E91 9E SAHF 00432E92 75 07 JNZ SHORT accessch.00432E9B 00432E94 DDD8 FSTP ST 00432E96 E9 1D010000 JMP accessch.00432FB8 00432E9B DDD8 FSTP ST if |end-start| <= |cycle| set |cycle| 00432E9D DD47 C0 FLD QWORD PTR DS:[EDI-40] 00432EA0 DC67 D0 FSUB QWORD PTR DS:[EDI-30] 00432EA3 D9E1 FABS 00432EA5 DD47 C8 FLD QWORD PTR DS:[EDI-38] 00432EA8 D9E1 FABS 00432EAA DD5D C8 FSTP QWORD PTR SS:[EBP-38] 00432EAD DC55 C8 FCOM QWORD PTR SS:[EBP-38] 00432EB0 DFE0 FSTSW AX 00432EB2 9B WAIT 00432EB3 9E SAHF 00432EB4 73 05 JNB SHORT accessch.00432EBB 00432EB6 DD5D C8 FSTP QWORD PTR SS:[EBP-38] 00432EB9 EB 02 JMP SHORT accessch.00432EBD 00432EBB DDD8 FSTP ST pos or neg?? 00432EBD DD47 C0 FLD QWORD PTR DS:[EDI-40] 00432EC0 DC67 D0 FSUB QWORD PTR DS:[EDI-30] 00432EC3 D9E4 FTST 00432EC5 DFE0 FSTSW AX 00432EC7 9B WAIT 00432EC8 9E SAHF 00432EC9 DDD8 FSTP ST 00432ECB DD45 C8 FLD QWORD PTR SS:[EBP-38] 00432ECE D9E1 FABS 00432ED0 0F83 E8000000 JNB accessch.00432FBE negative direction... check stuff, what up with cutoff??? 00432ED6 D9E0 FCHS 00432ED8 DD5D C8 FSTP QWORD PTR SS:[EBP-38] -|cycle| good 00432EDB DD03 FLD QWORD PTR DS:[EBX] 00432EDD D9D0 FNOP 00432EDF DC57 D0 FCOM QWORD PTR DS:[EDI-30] 00432EE2 DFE0 FSTSW AX 00432EE4 9B WAIT 00432EE5 9E SAHF 00432EE6 76 07 JBE SHORT accessch.00432EEF x<=start keep going 00432EE8 DDD8 FSTP ST 00432EEA E9 C9000000 JMP accessch.00432FB8 00432EEF DC57 C0 FCOM QWORD PTR DS:[EDI-40] 00432EF2 DFE0 FSTSW AX 00432EF4 9B WAIT 00432EF5 9E SAHF 00432EF6 73 0D JNB SHORT accessch.00432F05 x>= end keep going else 00432EF8 DC67 C0 FSUB QWORD PTR DS:[EDI-40] 00432EFB DC47 D0 FADD QWORD PTR DS:[EDI-30] 00432EFE DD1B FSTP QWORD PTR DS:[EBX] 00432F00 E9 B3000000 JMP accessch.00432FB8 00432F05 DD47 C0 FLD QWORD PTR DS:[EDI-40] 00432F08 DC67 D0 FSUB QWORD PTR DS:[EDI-30] | Escapetime Transformations Only |

_BSpinBobber_333spintop | dd03dc67E8d9e1dd5dE8 DD03DC5FE8DFE09B9E7319 dd45e8dc4fb8d9e0d9e8dec1dd5dd8dd45e8dc4fe0dc07eb07d9e8dd5dd8dd07dc47d8 d9fbdd5df8dd55f0dd01dec9dd02dc4df8dec1dd02dc4df0dd01dc4df8d9e0dec1 dd45d8DEC9dd1aDD45d8DEC9dd19 EB02DDD8 dd47c8d9e4dfe09b9e7507ddd8e91d010000ddd8 dd47c0dc67d0d9e1dd47c8d9e1dd5dc8dc55c8dfe09b9e7305dd5dc8eb02ddd8 dd47c0dc67d0D9E4DFE09b9eddd8dd45c8d9e10f83e8000000 d9e0dd5dc8dd03d9d0dc57d0dfe09b9e7607ddd8e9c9000000 dc57c0dfe09b9e730Ddc67c0dc47d0dd1be9b3000000 dd47c0dc67d0dc55c8dfe09b9ed9d0 7307dc65c8ebf0d9d0 dd5dc0d9d0dd47c0dc65c0dd5db8dc55b8dfe09b9e7336 d9d0 dc65b8dd45c0dc4f10dd5dc8dc55c8dfe09b9e760Adc47d0dd1be963000000 ddd8dd47c0dd03d9e0dec1dc47d0dd1be94e000000 dd47d0dd47c8d9e1d9e0dec1dd5dc0dc55c0dfe09b9e7309 dd47c8d9e1dec1ebee dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0c d9e0dd45c8dec1dc47d0dd1b e9d6000000e9d100000090 DD5DC890dd03dc57d0dfe09b9e7307ddd8e9ba000000 dc57c0dfe09b9e760Ddc67c0dc47d0dd1be9a4000000 dd47c0dc67d0dc55c8dfe09b9ed9d0 7605dc65c8ebf0 dd5dc0d9d0dd47c0dc65c0dd5db8dc55b8dfe09b9e762e dc65b8dd45c0dc4f10dd5dc8dc55c8dfe09b9e7307 dc47d0dd1beb5b ddd8dd47c0dd03d9e0dec1dc47d0dd1beb49 dd47d0dd47c8d9e1dec1dd5dc0dc55c0dfe09b9e760b dd47c8d9e1d9e0dec1ebec dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0c d9e0dd45c8dec1dc47d0dd1b spinpart: .Double xTwistStart = -.4 18 .Double xTwistMult = 0.4 20 .Double xSpinAngle = 0.0 28 004335A4 DD03 FLD QWORD PTR DS:[EBX] 004335A6 DC67 E8 FSUB QWORD PTR DS:[EDI-18] -twiststart 004335A9 D9E1 FABS 004335AB DD5D E8 FSTP QWORD PTR SS:[EBP-18] 004335AE DD03 FLD QWORD PTR DS:[EBX] 004335B0 DC5F E8 FCOMP QWORD PTR DS:[EDI-18] 004335B3 DFE0 FSTSW AX 004335B5 9B WAIT 004335B6 9E SAHF 004335B7 73 19 JNB SHORT accessch.004335D2 x>twiststart jump eldse 004335B9 DD45 E8 FLD QWORD PTR SS:[EBP-18] load difference 004335BC DC4F B8 FMUL QWORD PTR DS:[EDI-48] *fatness mult 004335BF D9E0 FCHS 004335C1 D9E8 FLD1 004335C3 DEC1 FADDP ST(1),ST 004335C5 DD5D D8 FSTP QWORD PTR SS:[EBP-28] save thethingy 004335C8 DD45 E8 FLD QWORD PTR SS:[EBP-18] load x-twistrat 004335CB DC4F E0 FMUL QWORD PTR DS:[EDI-20] *twistmult 004335CE DC07 FADD QWORD PTR DS:[EDI] +pi/2 004335D0 EB 07 JMP SHORT accessch.004335D9 jump to angle calc 004335D2 D9E8 FLD1 load1 004335D4 DD5D D8 FSTP QWORD PTR SS:[EBP-28] save to fatnessmult thing for?? 004335D7 DD07 FLD QWORD PTR DS:[EDI] pi/2 004335D9 DC47 D8 FADD QWORD PTR DS:[EDI-28] +twistangle 004335DC D9FB FSINCOS 004335DE DD5D F8 FSTP QWORD PTR SS:[EBP-8] 004335E1 DD55 F0 FST QWORD PTR SS:[EBP-10] 004335E4 DD01 FLD QWORD PTR DS:[ECX] 004335E6 DEC9 FMULP ST(1),ST 004335E8 DD02 FLD QWORD PTR DS:[EDX] 004335EA DC4D F8 FMUL QWORD PTR SS:[EBP-8] 004335ED DEC1 FADDP ST(1),ST 004335EF DD02 FLD QWORD PTR DS:[EDX] 004335F1 DC4D F0 FMUL QWORD PTR SS:[EBP-10] 004335F4 DD01 FLD QWORD PTR DS:[ECX] 004335F6 DC4D F8 FMUL QWORD PTR SS:[EBP-8] 004335F9 D9E0 FCHS 004335FB DEC1 FADDP ST(1),ST 004335FD DD45 D8 FLD QWORD PTR SS:[EBP-28] 00433600 DEC9 FMULP ST(1),ST 00433602 DD1A FSTP QWORD PTR DS:[EDX] 00433604 DD45 D8 FLD QWORD PTR SS:[EBP-28] 00433607 DEC9 FMULP ST(1),ST 00433609 DD19 FSTP QWORD PTR DS:[ECX] 0043360B EB 02 JMP SHORT accessch.0043360F 0043360D DDD8 FSTP ST zero cycle check good: 00432E89 DD47 C8 FLD QWORD PTR DS:[EDI-38] 00432E8C D9E4 FTST 00432E8E DFE0 FSTSW AX | Escapetime Transformations Only |

_BStellahedron_F_Sphere | Description: Sphere to polyhedron with Stellation angles transform. Does not make regular polydedra, except for the cube! If you're mixing it with a Menger, remember to put the polyhedra to sphere (polyhedra with sides=4 and sides2=4) transform after this one... this doesn't include the cube to sphere transform. rCyz=abs(atan(z.z,z.y)); //atan is atan2 while (rCyz>pi/sides) {rCyz-=2.*pi/sides; } z.yz*= (cos(pi / sides * .5) * cos(rCyz - starangle) ) / cos( pi / (sides) * .5 - starangle); //z.yz*=whatever; means y= y*whatever and z= z*whatever rCxyz=abs(atan(sqrt(z.z*z.z+z.y*z.y),z.x)); while (rCxyz>pi/sides2) {rCxyz-=2.*pi/sides2; } // same concept here!!!! z*=(cos(pi/sides2*.5)*cos(rCxyz-starangle2))/cos(pi/(sides2)*.5-starangle2); 😀 M Benesi | Escapetime Transformations Only |

_BT1_4D_clampXYZ | Description: This isn't very different from the 3d version of Transform 1. This particular 4d version keeps the original magnitude of xyz=sqrt(x^2+y^2+z^2) and scales xyz so that they keep the same magnitude because a portion of the magnitude becomes part of the w variable when you use this... this keeps the total magnitude the same if you're doing a 3d fractal, but introduces a bit more... not much. The 3d version is pretty much the best because it is faster.. although in the future, higher dimensional versions might become more interesting as processing power increases. Maybe the math... adding cos(sqrt(1/dimensions)) and sin(sqrt((dimensions-1)/dimensions)) can help people understand non-visualizable concepts such as rotations in extra dimensions. calculate magnitude of xyz Rotate from x (-1,0,0,0)-->(1,0,0,0) to "mag axis" (-1,-1,-1,-1) --> (1,1,1,1) Take absolute value of variables Rotate back to x axis; normalize xyz; multiply by original magnitude; scale and add in offset rxyz=sqrt(x^2+y^2+z^2); new w=abs(x*sqrt(1/4) + w*sqrt(3/4)); // (yes... sqrt of 1/4 is... 1/2 [email protected]#!) x= x*sqrt(3/4) - w/2; // yup... tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); tx=x*sqrt(3/4)+w*sqrt(1/4); //.5!#[email protected]# w=-x*sqrt(1/4) +w*sqrt(3/4); rxyz=rxyz/sqrt(x^2+y^2+z^2); x*=rxyz; y*=rxyz; z*=rxyz; | Escapetime Transformations Only |

_BT1_4D_Transform1 | Description: This isn't very different from the 3d version of Transform 1. The 3d version is better because it is faster.. although in the future, higher dimensional versions might become more interesting as processing power increases. Rotate from x (-1,0,0,0)-->(1,0,0,0) to "mag axis" (-1,-1,-1,-1) --> (1,1,1,1) Take absolute value of variables Rotate back to x axis; scale and add in offset new w=abs(x*sqrt(1/4) + w*sqrt(3/4)); // (yes... sqrt of 1/4 is... 1/2 [email protected]#!) x= x*sqrt(3/4) - w/2; // yup... tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); tx=x*sqrt(3/4)+w*sqrt(1/4); //.5!#[email protected]# w=-x*sqrt(1/4) +w*sqrt(3/4); x=scale*tx-offset; //scale =2 offset=2 y=scale*y; z=scale*z; w=scale*w; Rotate towards mag WITH ABS (D9E1): 😀 M Benesi | Escapetime Transformations Only |

_BT1_Transform1 | Description: Cool?? 😀 absolute value xyz transform; // STEP1: "Benesi transform 1" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); x=abs(tx-y*sqrt(1/2)); y=abs(tx+y*sqrt(1/2)); tx=x*sqrt(1/2)+y*sqrt(1/2); y=-x*sqrt(1/2)+y*sqrt(1/2); x=tx*sqrt(2/3)+z*sqrt(1/3); z=-tx*sqrt(1/3)+z*sqrt(2/3); x=scale*x-offset; //scale =2 offset=2 y=scale*y; z=scale*z; 😀 | Escapetime Transformations Only |

_BT2_Transform2 | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs(sqrt(ty+z)-offset2)*scale2*sqrt(1/2) ; y=abs(sqrt(tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs(sqrt(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) 😀 M Benesi | Escapetime Transformations Only |

_BT2_Transform2V2 | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs(sqrt(ty+z)-offset2)*scale2*sqrt(1/2) ; y=abs(sqrt(tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs(sqrt(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) 😀 M Benesi | Escapetime Transformations Only |

_BT3_Transform3 | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); //replace squaring with abs D8C8 to D9E1 done tx=abs(tx-y); ty=abs(tx+y); x=abs(ty+z-offset2)*scale2*sqrt(1/2) ; //remove sqrt part for these three done y=abs(tx+z-offset2)*scale2*sqrt(1/2) ; z=abs(tx+ty-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) 😀 M Benesi | Escapetime Transformations Only |

_BT3_Transform3V2 | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=abs(x*sqrt(1/3) + z*sqrt(2/3)); //replace squaring with abs D8C8 to D9E1 done tx=abs(tx-y); ty=abs(tx+y); x=abs(ty+z-offset2)*scale2*sqrt(1/2) ; //remove sqrt part for these three done y=abs(tx+z-offset2)*scale2*sqrt(1/2) ; z=abs(tx+ty-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) 😀 M Benesi | Escapetime Transformations Only |

_BT4_Transform4 | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs((ty+z)-offset2)*scale2*sqrt(1/2) ; // take out square roots!!! D9FA removed... y=abs((tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs((tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) ;p M Benesi | Escapetime Transformations Only |

_BT4_Transform4V2 | Update: T4Strength determines the strength of application. Should be cool... MBenesi 😀 newx= oldx* (1-T4Strength) + xtemp * T4Strength newy= oldy* (1-T4Strength) + ytemp * T4Strength newz= oldz* (1-T4Strength) + ztemp * T4Strength Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^2; tx=(tx-y)^2; ty=(tx+y)^2; x=abs((ty+z)-offset2)*scale2*sqrt(1/2) ; // take out square roots!!! D9FA removed... y=abs((tx+z)-offset2)*scale2*sqrt(1/2) ; z=abs((tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) ;p M Benesi d9e8 fld1 dee9 fsubp cos-1 DC4D E8 fmul e8 d9e8 dec1 d9e8 fld1 DC67 E0 subtract edi-20 dd55d0 save to d0 dc0b fmul ebx dd5de8 dc4fd0 fmul edi-20 d9e8 dc67e0 d9c0d9c0 dc0bdd5de8 e8=x dc0add5de0 e0=y dc09dd5dd8 d8=z DD03DC0FDD01DC4F08D9E0DEC1DC4F10DD5DF8DD02DC4F10DD1A90 DD03DC4F08DD01DC0FDEC190DD45F8 DC2290DD45F8DC0290D8C8DD5DF0D8C8DD5DF8D8C8DD19D9D0DD45F0DC01 DC67E8D9E1DC4FF0DC4F10DD1B90DD45F8DC01DC67E8D9E1DC4FF0DC4F10 DD1A90DD45F8DC45F0DC67E8D9E1DC4FF0DD1990DD02DC03DD02DC23DD1A DD5DF890DD45F8DC0FDD01DC4F08DEC1DD45F8DC4F08D9E0DD01DC0F90DEC1DD 19DD1B90D9D0 00435941 DD03 FLD QWORD PTR DS:[EBX] dd55e8 save to ebp-18 00435943 DC0F FMUL QWORD PTR DS:[EDI] 00435945 DD01 FLD QWORD PTR DS:[ECX] dd55e0 ebp-20 00435947 DC4F 08 FMUL QWORD PTR DS:[EDI+8] 0043594A D9E0 FCHS 0043594C DEC1 FADDP ST(1),ST 0043594E DC4F 10 FMUL QWORD PTR DS:[EDI+10] 00435951 DD5D F8 FSTP QWORD PTR SS:[EBP-8] 00435954 DD02 FLD QWORD PTR DS:[EDX] dd55d8 00435956 DC4F 10 FMUL QWORD PTR DS:[EDI+10] 00435959 DD1A FSTP QWORD PTR DS:[EDX] 0043595B 90 NOP 0043595C DD03 FLD QWORD PTR DS:[EBX] 0043595E DC4F 08 FMUL QWORD PTR DS:[EDI+8] 00435961 DD01 FLD QWORD PTR DS:[ECX] 00435963 DC0F FMUL QWORD PTR DS:[EDI] 00435965 DEC1 FADDP ST(1),ST 00435967 90 NOP 00435968 DD45 F8 FLD QWORD PTR SS:[EBP-8] 0043596B DC22 FSUB QWORD PTR DS:[EDX] 0043596D 90 NOP 0043596E DD45 F8 FLD QWORD PTR SS:[EBP-8] 00435971 DC02 FADD QWORD PTR DS:[EDX] 00435973 90 NOP 00435974 D8C8 FMUL ST,ST 00435976 DD5D F0 FSTP QWORD PTR SS:[EBP-10] 00435979 D8C8 FMUL ST,ST 0043597B DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043597E D8C8 FMUL ST,ST 00435980 DD19 FSTP QWORD PTR DS:[ECX] 00435982 D9D0 FNOP 00435984 DD45 F0 FLD QWORD PTR SS:[EBP-10] 00435987 DC01 FADD QWORD PTR DS:[ECX] 00435989 DC67 E8 FSUB QWORD PTR DS:[EDI-18] 0043598C D9E1 FABS 0043598E DC4F F0 FMUL QWORD PTR DS:[EDI-10] 00435991 DC4F 10 FMUL QWORD PTR DS:[EDI+10] 00435994 DD1B FSTP QWORD PTR DS:[EBX] 00435996 90 NOP 00435997 DD45 F8 FLD QWORD PTR SS:[EBP-8] | Escapetime Transformations Only |

_BT5b_Transform5b | Description: This is one of the "hollowing" out transforms I wrote to combine with the T1 Pine Tree Mandelbulb. Use sparingly (ever few iterations, maybe the next to last iteration you want to increase the detail level of). // STEP1: "Benesi fold 2" tx=(x*sqrt(2/3)-z*sqrt(1/3))*sqrt(1/2); y=y*sqrt(1/2); z=(x*sqrt(1/3) + z*sqrt(2/3))^8; // change to nth power easier to just make tx=(tx-y)^8; // one that is s^2^2^2 ty=(tx+y)^8; x=abs(sqrt(sqrt(...(ty+z)-offset2)*scale2*sqrt(1/2) ; // add in 2 square roots D9FA removed... y=abs(sqrt(sqrt(...(tx+z)-offset2)*scale2*sqrt(1/2) ; // z=abs(sqrt(sqrt(...(tx+ty)-offset2)*scale2 ; tx=y+x; y=y-x; x=z*sqrt(1/3)+x*sqrt(2/3); // should be +tx*sqrt(2/3) code is correct Checked... z=z*sqrt(2/3)-x*sqrt(1/3); // should be -tx*sqrt(1/3) ;p M Benesi | Escapetime Transformations Only |

_BTwistBraid_V3v2after | dc4f88 dd4598dc4fa8d9ffdc4f88dc4fb0dec9 dd02d8c8dd01d8c8dec1d9fadd5df8 dd4598dc4fa8d9ffdc4f88dec1 dd02d8c8dd01d8c8dec1d9fadd4598dc4fa8d9ffdc4f88dec1dd5df8 // braid part .Double BraidSpeed = 1.0 10 f0 .Double xBraidius = 1.0 18 e8 .Double xtRAA = -0.5 edi-10 F0 .Double xSpinCalcStart = 0.0 edi-18 E8 .Double xSpinMult = 1.0 edi-20 E0 .Double xSpinAngle = 0.0 edi-28 D8 .Double AccordionStart= -0.6 Start D0 .Double endLength= .2 end length C8 .Double AccordionEnd= -1.0 END C0 .Double FatnessMultSpin= 1.0 edi-48 B8 .Double FatnessMultAcc= 1.0 edi-50 B0 .Double FatnessMultAcc= 0.0 50 b0 .Double BraidQ = 0.4 58 a8 .Double BraidP = 0.4 60 a0 .Double InnerBraidius = 2.0 68 98 .Double xBraidSpeed = 0.0 70 90 .Double xBraidN = 3.0 78 88 004395B1 DD03 FLD QWORD PTR DS:[EBX] 004395B3 DC67 E8 FSUB QWORD PTR DS:[EDI-18] 004395B6 D9E1 FABS 004395B8 DD5D E8 FSTP QWORD PTR SS:[EBP-18] 004395BB DD47 E0 FLD QWORD PTR DS:[EDI-20] 004395BE D9E4 FTST 004395C0 DFE0 FSTSW AX 004395C2 9B WAIT 004395C3 9E SAHF 004395C4 74 46 JE SHORT accessch.0043960C 004395C6 DDD8 FSTP ST 004395C8 DD47 B8 FLD QWORD PTR DS:[EDI-48] 004395CB D9E0 FCHS 004395CD D9E8 FLD1 004395CF DEC1 FADDP ST(1),ST 004395D1 DD5D D8 FSTP QWORD PTR SS:[EBP-28] 004395D4 DD03 FLD QWORD PTR DS:[EBX] 004395D6 DC4F E0 FMUL QWORD PTR DS:[EDI-20] 004395D9 DC07 FADD QWORD PTR DS:[EDI] 004395DB D9FB FSINCOS 004395DD DD5D F8 FSTP QWORD PTR SS:[EBP-8] 004395E0 DD55 F0 FST QWORD PTR SS:[EBP-10] 004395E3 DD01 FLD QWORD PTR DS:[ECX] 004395E5 DEC9 FMULP ST(1),ST 004395E7 DD02 FLD QWORD PTR DS:[EDX] 004395E9 DC4D F8 FMUL QWORD PTR SS:[EBP-8] 004395EC DEC1 FADDP ST(1),ST 004395EE DD02 FLD QWORD PTR DS:[EDX] 004395F0 DC4D F0 FMUL QWORD PTR SS:[EBP-10] 004395F3 DD01 FLD QWORD PTR DS:[ECX] 004395F5 DC4D F8 FMUL QWORD PTR SS:[EBP-8] 004395F8 D9E0 FCHS 004395FA DEC1 FADDP ST(1),ST 004395FC DD45 D8 FLD QWORD PTR SS:[EBP-28] 004395FF DEC9 FMULP ST(1),ST 00439601 DD1A FSTP QWORD PTR DS:[EDX] 00439603 DD45 D8 FLD QWORD PTR SS:[EBP-28] 00439606 DEC9 FMULP ST(1),ST 00439608 DD19 FSTP QWORD PTR DS:[ECX] 0043960A EB 02 JMP SHORT accessch.0043960E 0043960C DDD8 FSTP ST 0043960E DD47 C8 FLD QWORD PTR DS:[EDI-38] 00439611 D9E4 FTST 00439613 DFE0 FSTSW AX 00439615 9B WAIT 00439616 9E SAHF 00439617 75 07 JNZ SHORT accessch.00439620 00439619 DDD8 FSTP ST 0043961B E9 1D010000 JMP accessch.0043973D 00439620 DDD8 FSTP ST 00439622 DD47 C0 FLD QWORD PTR DS:[EDI-40] 00439625 DC67 D0 FSUB QWORD PTR DS:[EDI-30] 00439628 D9E1 FABS 0043962A DD47 C8 FLD QWORD PTR DS:[EDI-38] 0043962D D9E1 FABS 0043962F DD5D C8 FSTP QWORD PTR SS:[EBP-38] 00439632 DC55 C8 FCOM QWORD PTR SS:[EBP-38] 00439635 DFE0 FSTSW AX 00439637 9B WAIT 00439638 9E SAHF 00439639 73 05 JNB SHORT accessch.00439640 0043963B DD5D C8 FSTP QWORD PTR SS:[EBP-38] 0043963E EB 02 JMP SHORT accessch.00439642 00439640 DDD8 FSTP ST 00439642 DD47 C0 FLD QWORD PTR DS:[EDI-40] 00439645 DC67 D0 FSUB QWORD PTR DS:[EDI-30] 00439648 D9E4 FTST 0043964A DFE0 FSTSW AX 0043964C 9B WAIT | Escapetime Transformations Only |

_BTwistBraid_V3v3 | dd07dc4f10dd4790dc6718dec1dc7790dec9dd5dd8 1) finish smooth growth of original split. 2) to smooth circle power... done 3) implement additional splits with smooth growth a) additional split start.. or start at end of cycle for space?? probably not. b) growth period (how long "x length" to grow from 0 to full splitradius) c) length before next split d) loop where??? Last line copies original x to esi-38, which is the "w" coordinate! Can use in other formulas to keep track of original x. .Double blank = 0.0 edi-10 f0 .Double blank = 0.0 edi-18 e8 .Double PolySides = 0.0 edi-20 e0 .Double Smooth = 0.0 edi-28 d8 .Double AccordionStart= -0.4 edi-30 d0 .Double CycleLength= .9 edi-38 c8 .Double AccordionEnd= 22.0 edi-40 c0 .Double Twist= 0.0 edi-48 b8 .Double Oscillation11= 0.0 edi-50 b0 .Double Oscillation22 = 0.0 edi-58 a8 .Double OscillationStrength = 0.0 edi-60 a0 .Double OscillationLength = 1.0 edi-68 98 .Double NumberOfSplits = 6.0 edi-70 90 .Double splitRadius = 2.0 edi-78 88 .Double ThickTwist = 2.0 edi-70 80 dd07dc4f10dd4790dc7790dec9dd5dd8 //implement smoothing function: square to circle (dc7708 is 2.... basically can set sides, but... with it at 4 it works well for the mehh... I might do the sides thing). polysides in this... change start part: dd4718dc77e0 to dd07dc7708 to make it just squares... dd47d8d9e4dfe09b9e745dd9e0dd5dd8 dd4720dc77e0dd55f8d8c0dd5df0dd01dd02d9f3d9e1dc55f8dfe0 9b9e7605dc65f0ebf2 d9ffd9e8dee9dd45d8d9e1dec9d9e8dec1 dd45d8d9e4dfe09b9e7308 ddd8d9e8def1eb02ddd8d9c0dc0add1ad9d0dc09dd19eb02ddd8 0043CDEC DD07 FLD QWORD PTR DS:[EDI] 0043CDEE DC77 18 FDIV QWORD PTR DS:[EDI+18] 0043CDF1 DD55 F8 FST QWORD PTR SS:[EBP-8] 0043CDF4 D8C0 FADD ST,ST 0043CDF6 DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0043CDF9 DD01 FLD QWORD PTR DS:[ECX] 0043CDFB DD02 FLD QWORD PTR DS:[EDX] 0043CDFD D9F3 FPATAN 0043CDFF D9E1 FABS 0043CE01 DC55 F8 FCOM QWORD PTR SS:[EBP-8] 0043CE04 DFE0 FSTSW AX 0043CE06 9B WAIT 0043CE07 9E SAHF 0043CE08 76 05 JBE SHORT accessch.0043CE0F 0043CE0A DC65 F0 FSUB QWORD PTR SS:[EBP-10] 0043CE0D ^EB F2 JMP SHORT accessch.0043CE01 0043CE0F D9FF FCOS 0043CE11 D9E8 FLD1 0043CE13 DEE9 FSUBP ST(1),ST 0043CE15 DD47 E8 FLD QWORD PTR DS:[EDI-18] 0043CE18 D9E1 FABS 0043CE1A DEC9 FMULP ST(1),ST 0043CE1C D9E8 FLD1 0043CE1E DEC1 FADDP ST(1),ST 0043CE20 DD47 E8 FLD QWORD PTR DS:[EDI-18] 0043CE23 D9E4 FTST 0043CE25 DFE0 FSTSW AX 0043CE27 9B WAIT 0043CE28 9E SAHF 0043CE29 73 08 JNB SHORT accessch.0043CE33 0043CE2B DDD8 FSTP ST 0043CE2D D9E8 FLD1 0043CE2F DEF1 FDIVRP ST(1),ST 0043CE31 EB 02 JMP SHORT accessch.0043CE35 0043CE33 DDD8 FSTP ST 0043CE35 D9C0 FLD ST 0043CE37 DC0A FMUL QWORD PTR DS:[EDX] 0043CE39 DD1A FSTP QWORD PTR DS:[EDX] 0043CE3B D9D0 FNOP 0043CE3D DC09 FMUL QWORD PTR DS:[ECX] 0043CE3F DD19 FSTP QWORD PTR DS:[ECX] ////////////// // not used: /////////////////////////////////////////// r= cos(Q *x + RAIDIUS) * mult y= r cos (P *x) +Y z= r sin (P *x) +Z | Escapetime Transformations Only |

_BTwistBraid_V4v0alpha | 1) finish smooth growth of original split. 2) to smooth circle power... done 3) implement additional splits with smooth growth a) additional split start.. or start at end of cycle for space?? probably not. b) growth period (how long "x length" to grow from 0 to full splitradius) c) length before next split d) loop where??? Last line copies original x to esi-38, which is the "w" coordinate! Can use in other formulas to keep track of original x. .Double blank = 0.0 edi-10 f0 .Double blank = 0.0 edi-18 e8 .Double blankP = 0.0 edi-20 e0 .Double BlankS = 0.0 edi-28 d8 .Double AccordionStart= -0.4 edi-30 d0 .Double CycleLength= .9 edi-38 c8 .Double AccordionEnd= 22.0 edi-40 c0 .Double Twist= 0.0 edi-48 b8 .Double Oscillation11= 0.0 edi-50 b0 .Double Oscillation22 = 0.0 edi-58 a8 .Double OscillationStrength = 0.0 edi-60 a0 .Double OscillationLength = 1.0 edi-68 98 .Double NumberOfSplits = 6.0 edi-70 90 .Double splitRadius = 2.0 edi-78 88 .Double ThickTwist = 2.0 edi-70 80 dd03dd5d98 too... .:D // twist: 0043FC35 DD47 80 FLD QWORD PTR DS:[EDI-80] 0043FC38 D9E0 FCHS 0043FC3A D9E8 FLD1 0043FC3C DEC1 FADDP ST(1),ST 0043FC3E DD5D D8 FSTP QWORD PTR SS:[EBP-28] 0043FC41 DD47 B8 FLD QWORD PTR DS:[EDI-48] 0043FC44 D9E4 FTST 0043FC46 DFE0 FSTSW AX 0043FC48 9B WAIT 0043FC49 9E SAHF 0043FC4A 74 3A JE SHORT accessch.0043FC86 0043FC4C DDD8 FSTP ST 0043FC4E DD03 FLD QWORD PTR DS:[EBX] 0043FC50 DC4F B8 FMUL QWORD PTR DS:[EDI-48] 0043FC53 DC07 FADD QWORD PTR DS:[EDI] 0043FC55 D9FB FSINCOS 0043FC57 DD5D F8 FSTP QWORD PTR SS:[EBP-8] 0043FC5A DD55 F0 FST QWORD PTR SS:[EBP-10] 0043FC5D DD01 FLD QWORD PTR DS:[ECX] 0043FC5F DEC9 FMULP ST(1),ST 0043FC61 DD02 FLD QWORD PTR DS:[EDX] 0043FC63 DC4D F8 FMUL QWORD PTR SS:[EBP-8] 0043FC66 DEC1 FADDP ST(1),ST 0043FC68 DD02 FLD QWORD PTR DS:[EDX] 0043FC6A DC4D F0 FMUL QWORD PTR SS:[EBP-10] 0043FC6D DD01 FLD QWORD PTR DS:[ECX] 0043FC6F DC4D F8 FMUL QWORD PTR SS:[EBP-8] 0043FC72 D9E0 FCHS 0043FC74 DEC1 FADDP ST(1),ST 0043FC76 DD45 D8 FLD QWORD PTR SS:[EBP-28] 0043FC79 DEC9 FMULP ST(1),ST 0043FC7B DD1A FSTP QWORD PTR DS:[EDX] 0043FC7D DD45 D8 FLD QWORD PTR SS:[EBP-28] 0043FC80 DEC9 FMULP ST(1),ST 0043FC82 DD19 FSTP QWORD PTR DS:[ECX] 0043FC84 EB 10 JMP SHORT accessch.0043FC96 0043FC86 DDD8 FSTP ST 0043FC88 DD45 D8 FLD QWORD PTR SS:[EBP-28] 0043FC8B DC0A FMUL QWORD PTR DS:[EDX] 0043FC8D DD1A FSTP QWORD PTR DS:[EDX] 0043FC8F DD45 D8 FLD QWORD PTR SS:[EBP-28] 0043FC92 DC09 FMUL QWORD PTR DS:[ECX] 0043FC94 DD19 FSTP QWORD PTR DS:[ECX] // box fold accordion x axis 0043FC96 DD47 C8 FLD QWORD PTR DS:[EDI-38] 0043FC99 D9E4 FTST 0043FC9B DFE0 FSTSW AX 0043FC9D 9B WAIT 0043FC9E 9E SAHF 0043FC9F 75 07 JNZ SHORT accessch.0043FCA8 0043FCA1 DDD8 FSTP ST 0043FCA3 E9 1D010000 JMP accessch.0043FDC5 0043FCA8 DDD8 FSTP ST 0043FCAA DD47 C0 FLD QWORD PTR DS:[EDI-40] 0043FCAD DC67 D0 FSUB QWORD PTR DS:[EDI-30] 0043FCB0 D9E1 FABS 0043FCB2 DD47 C8 FLD QWORD PTR DS:[EDI-38] 0043FCB5 D9E1 FABS 0043FCB7 DD5D C8 FSTP QWORD PTR SS:[EBP-38] 0043FCBA DC55 C8 FCOM QWORD PTR SS:[EBP-38] 0043FCBD DFE0 FSTSW AX 0043FCBF 9B WAIT 0043FCC0 9E SAHF 0043FCC1 73 05 JNB SHORT accessch.0043FCC8 0043FCC3 DD5D C8 FSTP QWORD PTR SS:[EBP-38] 0043FCC6 EB 02 JMP SHORT accessch.0043FCCA 0043FCC8 DDD8 FSTP ST 0043FCCA DD47 C0 FLD QWORD PTR DS:[EDI-40] | Escapetime Transformations Only |

_BTwistBraid_V5v1_DifOsc | SLICES SECTION VARIABLES AND CONSTANTS: EBP - 8 2PI EBP - 10 2PI/SLICES EBP - 18 PI/SLICES VARIABLE CHANGED IN LOOP EBP - 20 PI/SLICES EBP - 28 PI*(SLICES-4)/SLICES VARIABLE CHANGED IN LOOP EBP - 30 2PI - 2PI/SLICES EBP - 38 FLOOR SLICES EBP - 40 VARIABLE FLOOR SLICES, THEN SQRT(Y^2+Z^2) AFTER LOOP EBP - 50 OMEGA!!! .Double blank = 0.0 edi-10 F0 .Double blank = 0.0 edi-18 .Double Blank = 4.0 edi-20 E0 .Double Blank = 0.0 edi-28 .Double AccordionStart= -0.4 edi-30 D0 .Double CycleLength= .6 edi-38 .Double AccordionEnd= 32.0 edi-40 C0 .Double Twist= 0.3 edi-48 .Double OscillationStrenth1= 0.0 edi-50 B0 .Double OscillationLength2 = 0.66 edi-58 .Double OscillationStrenth2 = 0.0 edi-60 A0 .Double OscillationLength2 = 1.32 edi-68 .Double NumberOfSplits = 5.0 edi-70 90 .Double splitRadius = 2.66 edi-78 .Double ThickTwist = 0.0 edi-80 /////////////////////////////////later/////////////////////////////////// change: dd47d0dd47c8d9e1dec1dd5dc0dc55c0dfe09b9e760b dd47c8d9e1d9e0dec1ebec dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0cd9e0dd45c8dec1dc47d0dd1b to: dd47d0dd47c8d9e1dec1dd5dc0dc55c0dfe09b9e760b dd47c8d9e1d9e0dec1ebec dc67d0dd45c8dc4f10dd5dc0dc55c0dfe09b9e7307dc47d0dd1beb0cd9e0dd45c8dec1dc47d0dd1b /////////////////////////////////////////////////////////////////////////////////////// .Double OscillationStrenth1= 0.0 edi-50 .Double OscillationLength2 = 0.66 edi-58 .Double OscillationStrenth2 = 0.0 edi-60 .Double OscillationLength2 = 1.32 edi-68 .Double NumberOfSplits = 5.0 edi-70 .Double splitRadius = 2.66 edi-78 ryz=sqrt(z.y*z.y+z.z*z.z); ebp- (70???) dd01d8c8dd02d8c8dec1d9fadd5d70 omega=atan(z.z,z.y); dd01dd02d9f3 if (omega<0.0) {omega+=pi2;} d9e4dfe09b9e7303dc45f8 r2=pi*(splits+floor(splits))/splits; = ebp-18 DD45c8dc4590dc7590dc4f20dd5d88 dd45c8 load floor splits dc4590 + splits dc7590 /splits dc4f20 * pi dd5d88 DD45c8dc4590dc7590dc4f20dd5d88 dd4590dc65c8dc7590dc4f20d9e0dc45e8dd5d80 d9e0 - dc45e8 +pi/splits dd5d80 | Escapetime Transformations Only |

_BTwistBraid_V5v4beta | Blanks are.. because I put stuff in that I took out and I haven't cleaned up the code yet. IT IS MESSY! Disassembly will result in frustration and maniacal laughter. Accordion function is like box counting along the x-axis, except it is continuous (it does not cause breaks like box tiling... but I'm sure you can get it to cause breaks if you try). Start is basically where you start copying from, cycle is the cycle length, end is where it ends. if cycle= 2 start is -1, and end is 10: Starting at x=-1, x goes up to 0 then down to -1 at x=1, from 1 to 2 x goes up to 0, 2 to 3 x goes down to -1, 3 to 4 up to 0, 4 to 5 down to -1,5 thru 9 does it a few more times, at 9,it splits the last cycle in half, so starts at -1, goes to -.5, back to -1; after the end.. x just goes up. Twist twists it along the length of the function. Only twist on iteration 1 if you're doing multiple iterations to do the split thing! Oscillations apply along the length of the function. Sort of fun to play with, mixed with spherical Mengers, accordion function, and a bit of oscillations with the split function. You can make pretty Menger pseudofractals with just oscillations, twists, and accordion, and split. Number of Splits: number of splits (yup). If you set it to an integer value, you can do neat stuff as long as you align the fractals using SplitAdjust on the last iteration you do in a row! SplitAdjust aligns the fractals in the splits. If you're just doing Mengers? You don't really need to align them (well, the one I use!) because they are already symmetrically aligned at SplitAdjust=0 so you can just do multiple iterations. You can rotate Mengers 45 degrees (.7853982) and play with them too- although if you change the polygon shape of the Menger (make it a triangle or hexagon instead), you need to be careful (well, you're not going to break anything) if you're doing multiple spliterations. If you're doing the BT1PinegonV2? You need 2 formula tabs at the moment. The last one only do one iteration, and set SplitAdjust to approximately .5236 (pi/6). The first on you can leave at SplitAdjust=0. Here's a multisplit example with BT1PinegonV2, MengerIFS_B_2.0, and this formula. If you switch it from Menger to BT1Pinegon, activate the second slot with this formula in it- it has .5236 in SplitAdjust. Actually- it might have .532 because I was using the wrong value for a while because.. umm.. I typed wrong? Nah.. I just don't have pi/6 memorized. mehh. Mandelbulb3Dv18{ g.....s/...c3...w....2....Uq4JbehvHH.vGfolbG/45E.O9P7Rnlk.Y1u8arN7g2.dcjhKwaufwj ................................r7BL5R4Zly1........Y./..................y.2...wD ...Uz6....ER/.../M.0/.....kY/...O/....E3.....MqYf4SsH0tD/..........G0dkpXm1..... ./....kD12..02............................................U0.....y1...sD...../.. .z1...sDH6SHF80IOxPxdU4OS8NXzwls5Y5L.prDdR./myQsUxXUvX/W9O4Tza2J1cvMdqsD3kX0o.2L EyXXZGo7WSnMz.BFsa.ZM9pjU.....oOF.............sD.6....sD..G..................... .............oAnAt1...sD....zw1.........................................7....k1. .....4iSoz1.......kz.cF0c1kG.s6.P....U5....O....m....c3...k1....o....A1.....SN5Y ...U.W1Q3JJT94NJ8gW9J/....6.pc..oiyi..kvrEtMc7xD6ocyFE0ujz1..........2.28.kFrA0. .Ub96aAIVz9.1se7Umvxz0........../EU0.wzzz1...........s/...................E.2c.. zzzz.............0........E..........2./8.kzzzD............8.................... /EU0.wzzz1...................................YxzV1UvNPcveeWCNq0.yRiibHJJHDxo..XR SvBmx3CcN/UvNPcvQsLsUa3.ibhVi1bTV1OK.sSq4uCly3CcN/UvNPcvMwLsUa3.ibhVinqTV1OK.sSq 4uCkz3CcN/UvNPcv..EsUa3feeWCNqGQIJ36wk8EwyLsUa3f................................ E....EE7F3.0....I...../...kL0FpRdB5R07LMdFqLKJXRn6KNo34.Z7KNaxaQZ/.............. .....................................................wFVf53iSIyj........kz1..... ...2./....................k53iSIsuFtz...........TIsuFVf5pz1........4.h53iSIsuR.E ...........................3....E....wZEIRLOnFbEm3KOYxZJpMbATB5PdBKNWJaNj7LN.... ..........................................................................kzzzzz zzzxz................................wFVf53iSIyD..........k53iSIsuFxz........./E ..........2..........w4w3aAJ/1yD.....E/...E1....0FJAEZaPZRqPiNZA.MJBq3nL2ZaNDBrM ..................U.06U.0.................2........../........zD................ ........................D/2...................zD..........2.......kH./......../E ........kznkpX0LD8Qyz...........KaNaNaNaNyH.....I....w....EHZtqNZ7LG4BpL0xZAq/1. ..........................U/4MU.06......0..........0./........zD........kz1..... ...sz...................................................kz1..................U.E ........E.2........wz.........zD........kz1.............} {Titel: starslices2} Here is a pretty pillar example, uses this formula and MengerIFS_B_2.0. Change twist a bit, the oscillations, the polystrength of the Menger (I think I coded it wrong!! 😀 Should check, but it works... ) Mandelbulb3Dv18{ g.....E/...k1...w....2....kDo5OaGZ2E.vTMM0ysc54Emf8YsHB85.ohfSnrSTP..PhjRc.Oi30k ................................T2r8yQES3z1........Y./..................y.2...wD ...Uz6....UQ..../M.0/.....k6/...Y/....E3.....wl0RNlfPFsD/.......BJJ/0dkpXm1.Deee z.kAnAfD12..0..........wz.................................U0.....y1...sD...../.. .z1...sDYnunDJB50yXvKG8R4kZQzWDjZ0/N8RojW6.a7pxBFxHFcBRmlP8EzcDQTOubrEsDfTzWJRK3 mxP48eTfZEWUziZY8o4rLtoDU.....oM0.............sD.6....sD..G..................... .............oAnAt1...sD....zw1.........................................L....k1. .....4iSoz1.......kz.wzzz1.U..6.P....U5...EB....m....c3....F....6/...I1.....SF52 ...U.qFG9yzb2zzzRYoWzz7lz16.pc..zXCc..kvrEtMc7xD6ocyFE0ujz1..........2.28.kFrA0. .Ub96aAIVz9.1se7Umvxz0........../EU0.wzzz1...........s/...................E.2c.. zzzz.............0...................2./8.kzzzD............8.................... /EU0.wzzz1...................................2CcN/UvNPcveeWCNq0.yRiibHJJUk1f..XR SvBmx3CcN/UvNPcvQsLsUa3.ibhVi1bTV1OK.sSq4uCly3CcN/UvNPcvMwLsUa3.ibhVinqTV1OK.sSq 4uCkz3CcN/UvNPcv..EsUa3feeWCNqGQIJ36wk8EwyLsUa3f................................ E....AU6V2E.....I....w....EHZtqNZ7LG4BpL0xZAq/1.Z/EN.61...................U/4MU. | Escapetime Transformations Only |

_CelticMode | Description: This effect works at best with every formula that at z=0 show a Mandelbrot set, and if it's at power 2. The M-set must be correctly oriented; I taken "Integer power" as reference. Most formulas have this orientation. This works perfectly with 4-D formulas as well! Too bad, KaliLinComb and Riemann have non-standard orientation and they will not work. Put this effect AFTER that formula. If done correctly, you should see a 3D Celtic set! You can easily obtain the "Druid set". Follow these instructions DRUID MODE 1 (normal) Formula1 = Int power or whatever you like, itercount = 1 Formula2 = This transformation, itercount = 1 Formula3 = Same as formula 1. DRUID MODE 1 (alternate) Formula1 = Int power or whatever you like, itercount = 2 Formula2 = This transformation, itercount = 1. If you increase the power, you get higher order celtic sets, less recognizable but also interesting. Julia sets are also very promising. Cut also at z=0 to see very interesting things... Celtic formula was invented by Paul Carlson. Formula: x' = abs(x+Cx*G)-Cx*G + x*E if M>0 z' = abs(z+Cz*M)-Cz*H endif Unlike UF Celtic set, this set is "conservative" (preserves orientation of the fractal) - so is also perfect for hybrids | Escapetime Transformations Only |

_CondItcountR | Description:
This formula modifies the iteration count on another formula by a condition on the current 3d vector length (R):
if R < R1 { ItCount[Formula[Formula nr]] = ItCount_R | Escapetime Transformations Only |

_CondItcountSwitch | Description: Warning! Use at your risk, if misused this can freeze the program. Put other two formulas in the alternation BEFORE pressing calculate. I reccomend to use more than just three formulas in total btw to justify the use of this switch... If possible avoid to use this in association with AboxVaryScale or other iter-dependent formulas. Best used with IFS formulas, less useful with bulbs but still interesting in some cases. This formula modifies the iteration count (depending on how many times it's executed) of another formula that MUST exist or the program may freeze: if ExecCount < CVal { ItCount[Formula[Formula nr]] = ICILO } else if ExecCount = CVal { ItCount[Formula[Formula nr]] = ICIEQ } else { ItCount[Formula[Formula nr]] = ICIHI } Because the formula iteration counts are not resetted on iteration start, you should only modify formulas that are following this one. Else the initial iteration count of the modified formula depends on the last mofification of a previous iteration loop. | Escapetime Transformations Only |

_CondItcountSwX2 | Description: Warning! Use at your risk, if misused this can freeze the program. BE SURE TO READ the instructions of _CondItcountSwitch before using it. This is just an extended version because you can manipulate the itercounts of two formulas instead of one. Do NOT mess too much with this btw, or weird things can happen. But if you know what you are doing, this switch can do amazing things! | Escapetime Transformations Only |

_CondLyapunov | Description: Warning! Use at your risk, if misused this can freeze the program. Put other two formulas in the alternation BEFORE pressing calculate. I reccomend to use more than just three formulas in total btw to justify the use of this switch... If possible avoid to use this in association with AboxVaryScale or other iter-dependent formulas. Best used with IFS formulas, less useful with bulbs but still interesting in some cases. This formula modifies the iteration counts of two formulas, in a similar manner of Lyapunov's formula sequence style. The modification involves a bit of binary maths. In "simple" words, if N = counts how many times this check occurs, and S = sequential code; N2 = N & 15 // Aexion suggested 7 but this allows longer sequences S = (S >> N2)) & 1 // and 1 checks the parity // now force valid choices for formula A and B then ... if (S) then execute formula A and skip formula B else execute formula B and skip formula A Execute means that iter count will be set = 1 and skip = 0 of course. Luca GN 2012 (suggested by Aexion) | Escapetime Transformations Only |

_CondLyapunovEx | Description: Warning! Use at your risk, if misused this can freeze the program. Put other two formulas in the alternation BEFORE pressing calculate. I reccomend to use more than just three formulas in total btw to justify the use of this switch... If possible avoid to use this in association with AboxVaryScale or other iter-dependent formulas. Best used with IFS formulas, less useful with bulbs but still interesting in some cases. This formula modifies the iteration counts of two formulas, in a similar manner of Lyapunov's formula sequence style. Use this in some hybrids to get a better control of the flow than the normal CondLyapunov! The itercount can be set on a custom value 0 to 100 instead of just 1 or 0. Luca GN 2012 | Escapetime Transformations Only |

_conj | Description: Complex conjugate function The simplest function ever... 3D only conjugation Warning: This function in most cases simply screws up the fractal. Transforms a Mandelbrot set in a tricorn. Formula by Luca GN 2011 conj(S) = (x,-y,-z,w) | Escapetime Transformations Only |

_conj2D | Description: Complex conjugate function The simplest function ever... Normal complex conjugation - affects only y! Warning: This function in most cases simply screws up the fractal. Transforms a Mandelbrot set in a tricorn. Formula by Luca GN 2011 conj(S) = (x,-y,z,w) | Escapetime Transformations Only |

_cosmartin | Description: CosMartin deformation in 4D - variation with four parameters and strength (inspired from CosMartin formula from Mark Townsend) Formula by Luca GN 2011 This deformation needs some iterations to take a defined form, try 10-12. The effect strength grows strongly for even small increments of the constants, choose wisely. x' = ( y - a cos(b x) )* Strength y' = ( c - x ) * Strength z' = ( w - a cos(b z) )* Strength w' = ( d - z ) * Strength | Escapetime Transformations Only |

_DonutTransform | Description: Based on Aexions ideas, this performs a toroidal transform to be used as first formula as pre-transform, and choosing 'repeat from here' on the next formula(s). It is a 3d transform, but the result is 4d, so a combination with 4d formulas would make a better sense (like the 4D ABox). const float delta=rOffset; const float angle=atan2(ny,nx)*Order; const float radius=sqrt(nx*nx+ny*ny); const float t_radius=radius-Offset; x =sin(angle)*radius-delta; y =cos(angle)*radius-delta; w =t_radius*t_radius+z*z-delta; z =z-delta; // ... and do the same for C values | Escapetime Transformations Only |

_dynamic | Description: Dynamic deformation in 3D - variation with four parameters and strength (inspired from 2D dynamic formula from Mark Townsend) Formula by Luca GN 2011 Please, note that it is slow. Sometimes VERY slow! x' = (x - a cos(c y) - b sin(d z))* Strength y' = (y - a cos(c z) - b sin(d x)) * Strength z' = (z - a cos(c x) - b sin(d y)) * Strength | Escapetime Transformations Only |

_dynamicfast | Description: See _gnarl2D_2, this is a polynomial version, faster and accurate (1e-6 MAX error, stopping at x^7) - no visible difference in practice! No sin() functions are used. The numerical coefficients are taken from the tables found here: http://www.geometrictools.com/GTEngine/Include/GteConstants.h | Escapetime Transformations Only |

_flipC-xyz | Description: Just for fun! Swaps x, y, z values with Cx, Cy, Cz. See "_updateC.m3f" for instructions. But you can use this for wild experiments. | Escapetime Transformations Only |

_FlipXZc | Description: Exchanging the x and z values, if option is not zero then Cx and Cz too: x' = z z' = x if Flip_also_C <> 0 {Cx' = Cz; Cz' = Cx} Note: Changing C does not work in Julia mode. | Escapetime Transformations Only |

_FlipYZc | Description: Exchanging the y and z values, if option is not zero then Cy and Cz too: y' = z z' = y if Flip_also_C <> 0 {Cy' = Cz; Cz' = Cy} Note: Changing C does not work in Julia mode. | Escapetime Transformations Only |

_Fold45double | Description: This folding is center-symmetrical, but can give unexpected results. You can modify this with the fixing factor (example, for a triple Sierpinski pyramid or similar effects...) Variation of _Fold45single; it's more like Tglad's folding on a single chosen direction. The main difference is that it introduces rotations in some areas. This can be interesting. Use itercount>1 to see cool multi-folds! See the basic version for more comments. if (PR == 1) dd = -(x*xsig + y*ysig + z*zsig)*h // pre-rotation; center rotated, sides normal x' = -(x - dd*xsig) // Switch both signs to keep the correct effect! y' = -(y - dd*ysig) z' = -(z - dd*zsig) endif // k is forced to be positive dd = (x*xsig + y*ysig + z*zsig - k) // first half if dd*q > 0 dd = dd*h x' = x - dd*xsig y' = y - dd*ysig z' = z - dd*zsig else dd = dd + 2*k + k2fix // second half if dd*q < 0 dd = dd*h x' = x - dd*xsig y' = y - dd*ysig z' = z - dd*zsig endif endif | Escapetime Transformations Only |

_Fold45single | Description: This folding introduce asymmetry, and can give unexpected results. Basically, it's like "_Abs" modifier but it introduces a rotation in some areas. Use itercount>1 to see cool multi-folds! Works with any plane inclined like the OctahedronIFS folding planes (eight in total). The planes are defined by +-x+-y+-z-k=0 (45 deg for each axis) Two modes available. Formula by Luca GN 2011 if (PR == 1) dd = -(x*xsig + y*ysig + z*zsig)*h // pre-rotation; center rotated, sides normal x' = -(x - dd*xsig) // Switch both signs to keep the correct effect! y' = -(y - dd*ysig) z' = -(z - dd*zsig) endif // xsig is +1 if you leave "Use -x" to 0, -1 otherwise. // Same for ysig, zsig dd = (x*xsig + y*ysig + z*zsig - k) // q is +1 in Mode 0, -1 otherwise. if dd*q > 0 dd = dd*h // h=2/3=0.6666 ... x' = x - dd*xsig y' = y - dd*ysig z' = z - dd*zsig endif | Escapetime Transformations Only |

_Folding1 | Box folding like in the amazing box. | Escapetime Transformations Only |

_Folding2 | Fold with z' = z+abs(z-2*fold)-abs(z-fold)-fold | Escapetime Transformations Only |

_FoldingCTetra3d | Description: Referring to C vector components (and optionally to xyz too, after it); 1st half tetrahedral symmetry planes: if(x+y<0){x1=-y;y=-x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(y+z<0){y1=-z;z=-y;y=y1;} 2nd half tetrahedral symmetry planes: if(x-y<0){x1=y;y=x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(y-z<0){y1=z;z=y;y=y1;} Code taken from the forums, KIFS original thread side note - if you disable the 1st half, 2nd half will be done even if you disable it... (to avoid a NOP transform) Coded by Luca GN 2011 | Escapetime Transformations Only |

_FoldingIcosa | Just like IcosahedronIFS, just dropped anything but the rotation and the dodeca-fold. LucaGN 2012 | Escapetime Transformations Only |

_FoldingInfy | Description: Continuous, seamless folding of 4D space. Boxtiling "enhanced" version. xi = every dimension (x,y,z,w) i = 1 to 4 m = sizei*4; n = sizei; t = 0 if sizei <> 0 t = xi - frndint(xi/m)*m // boxtiling (where xi is x,y,... etc. ) xi = abs(t+n) - abs(t-n) - t // folding // optimize this is pointless I think... so I leave it as is endif next i frndint -> rounds a float to the nearest integer | Escapetime Transformations Only |

_FoldingOct | No “i” info | Escapetime Transformations Only |

_FoldingTetra3d | Description: Note that this code does NOT affect the Menger-type formulas. 1st half tetrahedral symmetry planes: if(x+y<0){x1=-y;y=-x;x=x1;} if(x+z<0){x1=-z;z=-x;x=x1;} if(y+z<0){y1=-z;z=-y;y=y1;} 2nd half tetrahedral symmetry planes: if(x-y<0){x1=y;y=x;x=x1;} if(x-z<0){x1=z;z=x;x=x1;} if(y-z<0){y1=z;z=y;y=y1;} Code taken from the forums, KIFS original thread side note - if you disable the 1st half, 2nd half will be done even if you disable it... (to avoid a NOP transform) Coded by Luca GN 2011 | Escapetime Transformations Only |

_FoldingTetraKaleid | Description: Combination of; 1. Tetra3D folding, 1st half only 2. Fold45single with default inclination 3. Edventually, undo the sign changes done by 1st folding The effect is "visually perfect" for symmetric cubic 3D fractals, like; Amazing Box, ABoxVaryScale, MengerIFS, Menger3 ... when used as a pre-transform. Everything else can have "strange" effects. Undo Tetra3D can be good for non-cubic fractals (else not noticeable), and for all "adding c" fractals. Be aware! It introduces some cuts (DE trouble...) | Escapetime Transformations Only |

_FoldingVar | The folding position is influenced by amounts of the input vector: Xfold = Fold_X + x * Fold_xx + y * Fold_xy + z * Fold_xz Yfold = Fold_Y + x * Fold_yx + y * Fold_yy + z * Fold_yz Zfold = Fold_Z + x * Fold_zx + y * Fold_zy + z * Fold_zz x = abs(x + Xfold) - abs(x - Xfold) - x y = abs(y + Yfold) - abs(y - Yfold) - y z = abs(z + Zfold) - abs(z - Zfold) - z | Escapetime Transformations Only |

_GenCWarp | Description: Combination of _RotateC and Aexion's "C Iteration" concept, but with "General" formula to include an immense number of combinations. http://www.fractalforums.com/the-3d-mandelbulb/iterating-c/ Sample Aexion's code; // C transformation // My note - here I placed a CRotation! const float rc = sqrt(cx*cx + cy*cy + cz*cz); const float theta1 = atan2(sqrt(cx*cx + cz*cz) , cy)*8; // args can be freely selected const float phi1 = atan2(cz,cx)*8; // args can be freely selected // this is standard recipe but you can choose from 3... const float sintheta1=rc * cos(theta1); cx = sintheta1 * cos(phi1); cy = sintheta1 * sin(phi1); cz = rc * sin(theta1); My implementation is much more flexible and complicated to be explained here. However who cares... This formula is just for fun! Here a "reference" of the meaning of some symbols. - args - In this section h(a,b) is C/C++ hypot() function and matches normal Euclidean metric. u(a,b) returns the greater value between abs(a), abs(b). It is a different metric, used in some IFS fractals like Mengers. d(a,b) returns the lesser value between abs(a), abs(b). Another metric... Here x is meant to be Cx, and so on... 00 to 05 are standard coupled signed axis in this order; x,y / x,z / y,x / y,z / z,x / z,y Those angles are useful to get atan2() function, or atan() (that is less symmetrical) - see also tweaks. 06 to 11 are for arcsin() and arccos() functions; x, h(z,y) / y, h(x,z) / z, h(x,y) / h(z,y), x / h(x,z), y / h(x,y), z Those are used in familiar "Mandelbulbs" to evaluate the z angle. 12 to 17 are new kind of functions; x, u(z,y) / y, u(x,z) / z, u(x,y) / u(z,y), x / u(x,z), y / u(x,y), z Use those functions to get funny "squarry" bulbs. 18 to 23 are new kind of functions; x, d(z,y) / y, d(x,z) / z, d(x,y) / d(z,y), x / d(x,z), y / d(x,y), z Don't ask me what happens when you use those functions, try by yourself! DO NOT USE OTHER VALUES or you will fall in an intentional bug. (reserved for future use) - recipe - We have three recipes implemeted; 0 = NORMAL. 1 = COSINE. 2 = REVERSED. See http://www.fractalforums.com/theory/summary-of-3d-mandelbrot-set-formulas/ for technical info. (thank you!) Implemented by Luca G.N. 2011 | Escapetime Transformations Only |

_gnarl2D | Description: Gnarl deformation in 2D (from Mark Townsend) - variation with step X & Y and strength Gnarl formula gives strange "smoke-like" shapes. Formula by Luca GN 2011 TIPS Use tiny steps, alpha and beta near to 1, strength = 1 for a "gentle" transformation. The more you go far the more you give power to deformation; standard values are a good base to start. To "learn" how the deform work use it alone at first with a cutting plane then apply it to other formulas. The formula can be hybridated with all formulas including IFS ones. Handle with care. This transform uses massively sin - it is slow and may be fuzzy x' = (x - stepX sin(y + sin( a (y + sin (b y )))) * Strength y' = (y - stepY sin(x + sin( a (x + sin (b x )))) * Strength z unchanged | Escapetime Transformations Only |

_gnarl2D_2 | Townsend) - variation with step X & Y and strength Gnarl formula gives strange "smoke-like" shapes. Formula by Luca GN 2011 TIPS Use tiny steps, alpha and beta near to 1, strength = 1 for a "gentle" transformation. The more you go far the more you give power to deformation; standard values are a good base to start. To "learn" how the deform work use it alone at first with a cutting plane then apply it to other formulas. The formula can be hybridated with all formulas including IFS ones. Handle with care. This transform uses massively sin - it is slow and may be fuzzy x = x + step * (sin( Gamma *(y - xx) + sin( alpha * (y + beta * cos(y) )))) y = y + step * (sin( Gamma *(y + xx) - alpha * sin( xx + beta * cos(xx) ))) z unchanged | Escapetime Transformations Only |

_gnarl2D_2fast | Description: See _gnarl2D_2, this is a polynomial version, faster and accurate (1e-6 MAX error, stopping at x^7) - no visible difference in practice! No sin() functions are used. The numerical coefficients are taken from the tables found here: http://www.geometrictools.com/GTEngine/Include/GteConstants.h | Escapetime Transformations Only |

_gnarl2Dfast | Description: See Gnarl2D, this is a polynomial version, faster and accurate (1e-6 MAX error, stopping at x^7) - no visible difference in practice! No sin() functions are used. The numerical coefficients are taken from the tables found here: http://www.geometrictools.com/GTEngine/Include/GteConstants.h | Escapetime Transformations Only |

_gnarl3D | Description: Gnarl deformation in 3D (2D formula is from Mark Townsend) - variation with step X, Y, Z and strength Gnarl formula gives strange "smoke-like" shapes. Formula by Luca GN 2011 TIPS Use tiny steps, alpha and beta near to 1, strength = 1 for a "gentle" transformation. The more you go far the more you give power to deformation; standard values are a good base to start. To "learn" how the deform work use it alone at first with a cutting plane then apply it to other formulas. The formula can be hybridated with all formulas including IFS ones. Handle with care. This transform uses massively sin - it is slow and may be fuzzy x' = (x - stepX sin(z + sin( a (z + sin (b z )))) * Strength y' = (y - stepY sin(x + sin( a (x + sin (b x )))) * Strength z' = (z - stepZ sin(y + sin( a (y + sin (b y )))) * Strength | Escapetime Transformations Only |

_gnarl3Dfast | Description: See Gnarl3D, this is a polynomial version, faster and accurate (1e-6 MAX error, stopping at x^7) - no visible difference in practice! No sin() functions are used. The numerical coefficients are taken from the tables found here: http://www.geometrictools.com/GTEngine/Include/GteConstants.h | Escapetime Transformations Only |

_helispiral | Description: 1)Rotates the reference axis by selected angles NOTE; this will NOT affect C! 2)Rotates the XY plane on an angle defined as follows: if rbcH=1 { phi = Cz } else { phi = z } if rbcS=1 { rho = sqrt(Cx*Cx+Cy*Cy) } else { rho = sqrt(x*x+y*y) } SinCos(FixRot*degtorad + rho*Spiral + phi*Helix, s, c) x' = x * c + y * s y' = y * c - x * s 3)Rotates the reference axis at the inital position (transposed rot. matrix) NOTE; this will NOT affect C! This gives a helix + spiral deformation (if used as pretransform, or else it gives strange results, you choose). New version, june 21 2011 - Luca GN | Escapetime Transformations Only |

_HexaTransform | Description: Based on Aexions ideas, this performs a hexagonal transform to be used as first formula as pre-transform, and choosing 'repeat from here' on the next formula(s). It is a 3d transform, but the result is 4d, so a combination with 4d formulas would make a better sense (like the 4D ABox). Cx' = abs( Cx ) - Offset Cy' = abs( Cy*k1 + Cx*k2 ) - Offset Cz' = abs( Cz) - Offset Cw' = abs( Cy*k3 + Cx*k2 ) - Offset x' = abs( x ) - Offset y' = abs( y*k1 + x*k2 ) - Offset z' = abs( z ) - Offset w' = abs( y*k3 + x*k2 ) - Offset Where k1 = sqrt(3)/2 , k2 = 1/2, k3 = -k1 | Escapetime Transformations Only |

_hopalm1 | Description: Hopalong (modified) system in 3D - variation with five parameters and strength From UF database, modified version and changed formula Formula by Luca GN 2011 Works very well in combination with many formulas, and gives a nice "rusty" look. t = b x - c z + d if abs(t)>1 if t>0 x' = y - 1/sqrt abs ( t ) else x' = y + 1/sqrt abs ( t ) endif else if t>0 x' = y - sqrt abs ( t ) else x' = y + sqrt abs ( t ) endif endif y' = (a - x) * Strength z' = z + (a y - b x) * e | Escapetime Transformations Only |

_hopalm2 | Description: Hopalong (modified) system in 3D - variation with five parameters and strength From UF database, modified version and changed formula (atan instead of +-sqrt abs) "atan" is a continuous and derivable function so this version is much smoother than the poly counterparts. Too bad, atan is notably slower than sqrt; it's trascendental. Formula by Luca GN 2011 Works very well in combination with many formulas, and gives a nice "rusty" look. t = b x - c z + d x' = y - atan ( t ) y' = (a - x) * Strength z' = z + (a y - b x) * e | Escapetime Transformations Only |

_hopalong | Description: Hopalong system in 3D - variation with five parameters and strength From UF database, modified version Formula by Luca GN 2011 Works very well in combination with many formulas, and gives a nice "rusty" look. t = b x - c z + d if t>0 x' = y - sqrt abs ( t ) else x' = y + sqrt abs ( t ) endif y' = (a - x) * Strength z' = z + (a y - b x) * e | Escapetime Transformations Only |

_HopSqrtX | Description: Sqrt for x as defined in Hopalong attractor + some bells & whistles Formula by Luca GN 2011 t = Mul * x + fixX if t>0 x' = fixSq + sqrt abs ( t )/Div else x' = fixSq - sqrt abs ( t )/Div endif | Escapetime Transformations Only |

_HopSqrtY | Description: Sqrt for y as defined in Hopalong attractor + some bells & whistles Formula by Luca GN 2011 t = Mul * y + fixY if t>0 y' = fixSq + sqrt abs ( t )/Div else y' = fixSq - sqrt abs ( t )/Div endif | Escapetime Transformations Only |

_HopSqrtZ | Description: Sqrt for z as defined in Hopalong attractor + some bells & whistles Formula by Luca GN 2011 t = Mul * z + fixX if t>0 z' = fixSq + sqrt abs ( t )/Div else z' = fixSq - sqrt abs ( t )/Div endif | Escapetime Transformations Only |

_hyc3Dinv | Description: "Hypercomplex 3D inversion" with selectable radius and center. Needs a bit of coordinate adjustment. The effect of this inversion is VERY strong and strange (many singularities), so don't mess around... Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined HyRho = (x'*x'*x'+y'*y'*y'+z'*z'*z'-3*x'*y'*z') (the modulus of a number in this theory), x'' = (x'*x'-y'*z')/HyRho y'' = (y'*y'-x'*z')/HyRho z'' = (y'*y'-y'*x')/HyRho (note! in this metric, points with coordinates (a,a,a) have a modulus = 0, so inverse doesn't exist!) For your convenience, x'',y'',z'' are translated back. Basic formula and explanations can be read here; http://en.wikipedia.org/wiki/Tricomplex_number | Escapetime Transformations Only |

_IntPowRotateC | Upon an idea from Aexion to also rotate the adding constant in addition to a bulb formula. So put this in front or after a bulb formula in an alternating hybrid. The vector length of C is not changed, only complex rotated. Rotation power can be 2..11 (integer). The vector components for the complex rotation types are: 0: x|y 1: x|z 2: y|z 3: Rxy|z 4: Rxz|y 5: Ryz|x 6: y|x 7: z|x 8: z|y 9: z|Rxy 10: y|Rxz 11: x|Ryz Flip Cxy = 1 is exchanging Cx with Cy at the beginning. | Escapetime Transformations Only |

_invbisp | Description: Inverse bi-spherical coords Formula by Luca GN 2013 (experimental) R = (x*x+y*y+z*z) Q = 1/sqrt(sqr(R + A*A) - sqr(2*A*z)) x' = arccos( (R - A*A) * Q) y' = asinh(2*A*z*Q) z' = atan(y/x) | Escapetime Transformations Only |

_invcylindrical | Description: Inverse cylindrical coords, very easy transform Formula by Luca GN 2011 x' = x cos(y) y' = x sin(y) (z coordinate is unchanged) | Escapetime Transformations Only |

_invspherical | Description: Inverse spherical coords. Fast conversion without parameters. Formula by Luca GN 2011 From Wikipedia; x' = x sin(y) cos(z) y' = x sin(y) sin(z) z' = x cos(y) | Escapetime Transformations Only |

_invtorical | Description: Reversed torical (generalized) coords. Formula by Luca GN 2011 Define R = (inner radius + outer radius) / 2. We don't care about two radiuses, we care of the average only. x' = sqrt((R-x)^2/ ( 1 + (tan y)^2)) that can be simplified as follows; x' = abs(R-x)*(abs cos y) (because sin^2+cos^2=1) y' = x' tan y (z coordinate is unchanged. Similar to standard cylindrical reversed coords.) I didn't found much about this metric but a base for information is; http://mathworld.wolfram.com/Torus.html Technical note - function can be optimized more calculating sincos instead of cos and tan. todo. | Escapetime Transformations Only |

_invtorical2 | Description: Inverse torical (generalized) coords. This coordinate system was defined by BradC in FractalForums: http://www.fractalforums.com/theory/toroidal-coordinates/msg9428/#msg9428 Formula by Luca GN 2011 Define R = (inner radius + outer radius) / 2. // calculate sincos of y+z and z for speed t = R + x cos(y+Gamma) z' = x sin(y+Gamma) y' = t sin z x' = t cos z | Escapetime Transformations Only |

_JIT_gnj_AddRecip_01 | SUMMARY: Simple variant a sum of a triplex, and its reciprocal (and c): t(n+1) = Factor_Linear * t(n) + Factor_Reciprocal / t(n) + c Each summand has its real factor. Used a cartesian version of triplex 1/z, where 1/t "=" (x, -y, -z) / R^2 where R = x*x + y*y +z*z + Offset For details see http://www.fractalforums.com/theory/re-triplex-1z/ May be weird as an independent fractal, but as kind of tranform it is ok, and quite fast, specifically if compared with MobiusTpx, and TalisTpx (and with an Offset>0 it has no discontinuities) Can build nice rings from subsequent formulas; and even with discontinuities it's worth to check CHANGES: _JIT_gnj_AddRecip_01.m3f - Moved to Adds section because of the formula's weird DE, and because it's more useful to use it as transformation - Renamed to match some naming rules. Old formula name: JIT_gnj_zduz | Escapetime Transformations Only |

_JIT_gnj_Exp_02 | SUMMARY: Exponential calculation of a triplex General formula: t(n+1) = exp(t(n)) + c where * t:=(x,y,z) in cartesian coordinates * c:=(cx,cy,cz) in cartesian coordinates Used simplified exponential for triplex numbers as described at http://www.fractalforums.com/theory/triplex-algebra/60/ CHANGES: _JIT_gnj_Exp_02.m3f : Moved to Adds section Nevertheless the DE gets worse; therefore use it as one-time formula FORMULA: cx := PIteration3D^.J1; cy := PIteration3D^.J2; cz := PIteration3D^.J3; sq_r := x*x+y*y+z*z; r := sqrt(sq_r); r_xy := sqrt(x*x+y*y); a1 := exp(x - y*z/r_xy)/2; a2 := exp(x + y*z/r_xy)/2; alpha1 := x*z/r_xy + y; alpha2 := x*z/r_xy - y; x := a1*cos(alpha1) + a2*cos(alpha2) + cx; y := a1*cos(alpha1) - a2*cos(alpha2) + cy; z := exp(r_xy)*sin(z) + cz; | Escapetime Transformations Only |

_JIT_gnj_LoziExt1_02 | SUMMARY: Lozi Attractor, extended to 3D. For those who like sharp edges NOTE: This is somehow a test. The extension to 3D makes no mathematical sense Old formula name: JIT_gann_LoziExt1.m3f CHANGES: _JIT_gnj_LoziExt1_02.m3f : Moved to Adds section FORMULA: x_tmp := 1.0+y-a*abs(x); y_tmp := b*x; z_tmp := y+c*abs(z); x := x_tmp + cx; y := y_tmp + cy; z := z_tmp + cz; | Escapetime Transformations Only |

_JIT_gnj_PseuLog_03 | SUMMARY: Pseudo Logarithm "extension" from complex logarithm (as if theta and phi can be handled the same way) HINT: Use this together with bulb type formulas. CHANGES: _JIT_gnj_PseuLog_03.m3f: Added Shift_r variable. Only positive values are somehow useful _JIT_gnj_PseuLog_02.m3f: Moved to Adds section FORMULA: sq_r := x*x + y*y + z*z + Shift_r; r := sqrt(sq_r); phi := ArcSin(z/r) ; theta := ArcTan2(y,x) ; x := LnXP1(r) + cx; y := theta*Factor + cy; z := phi*Factor + cz; | Escapetime Transformations Only |

_JIT_gnj_RiemPow2_03 | SUMMARY: ********************************** * Use this formula careful * * (1, or maybe 2 iterations * * combined with other formulas) * * Then it can have great, * * but not destroying effects. * ********************************** What this formula does is to - map a triplex number as a Riemann sphere (i.e. divide all coordinates by R) - transform it to the complex plane - does some operation in complex plane (in this case classic Mandelbrot calculation z^2+c) - transform the number back to a Rieman sphere - re-apply R NOTE: By standard the radius of the triplex number will not be changed. Therefore this is more a transformation rather than independent formula. CHANGES: _JIT_gnj_RiemPow2_03.m3f: Moved to the Adds tabs which avoids odd effects on DE calculation Old formula name: JIT_gnj_RiemannPower2_03.m3f VARIABLES: - Shift_QuotCForward / Shift_QuotXYZForward / Shift_QuotBackward They are controlling some quotients while transforming Riemann sphere <-> complex plane Shift_QuotCForward / Shift_QuotXYZForward: Especially values between 1 and -1 are interesting. There may be some weird regions (if the quotient gets to close to 0), but there are also the largest effects. Shift_QuotBackward Most interesting values are between 1 and 0. Larger values can become boring (too regular surfaces). Negative values can become mostly weird. - NumComplexOps = Number of operations on complex plane. A larger number generates more details. Currently only values from 1-3 are valid. NOTE that this should be an interger value. However v190 seams not to support integer values in the JIT - SquaredRBackward: 0: Only original R will be re-applied. Meant that is a pure transformation. 1: Squared R gets used. In my current tests it results in more smooth surface. No other values can be used. - AddCAtEnd: <>0: Add the original c after re-applying R. Together with SquaredRBackward=1 there may come up some basic fractal behavior. ------------------------------------------------------------------------------ // calculating helper variables sq_rc := cx*cx + cy*cy + cz*cz; rc := sqrt(sq_rc); sq_r := x*x + y*y + z*z; r := sqrt(sq_r); // normalization x_norm := x/r; y_norm := y/r; z_norm := z/r; cx_norm := cx/r; cy_norm := cy/r; cz_norm := cz/r; // transform to complex quot_xyz := 1/(Shift_QuotXYZForward-z_norm); cmp_x := x_norm*quot_xyz; cmp_y := y_norm*quot_xyz; quot_c := 1/(Shift_QuotCForward-cz_norm); cmp_cx := cx_norm*quot_c; cmp_cy := cy_norm*quot_c; // complex calculation cmp_xtmp := cmp_x*cmp_x - cmp_y*cmp_y + cmp_cx; cmp_ytmp := 2*cmp_x*cmp_y + cmp_cy; cmp_x := cmp_xtmp; cmp_y := cmp_ytmp; If NumComplexOps >= 2 then begin cmp_xtmp := cmp_x*cmp_x - cmp_y*cmp_y + cmp_cx; cmp_ytmp := 2*cmp_x*cmp_y + cmp_cy; | Escapetime Transformations Only |

_JIT_gnj_RiemPow2_04 | SUMMARY: ********************************** * Use this formula careful * * (1, or maybe 2 iterations * * combined with other formulas) * * Then it can have great, * * but not destroying effects. * ********************************** What this formula does is to - map a triplex number as a Riemann sphere (i.e. divide all coordinates by R) - transform it to the complex plane - does some operation in complex plane (in this case classic Mandelbrot calculation z^2+c) - transform the number back to a Rieman sphere - re-apply R NOTE: By standard the radius of the triplex number will not be changed. Therefore this is more a transformation rather than independent formula. CHANGES: _JIT_gnj_RiemPow2_04.m3f Introducing Shift_CalcZBackward for backwards compatibility. OLD: z_norm := (cmp_x*cmp_x + cmp_y*cmp_y -1)*quot_xyz_back; NEW: z_norm := (cmp_x*cmp_x + cmp_y*cmp_y + Shift_CalcZBackward)*quot_xyz_back; _JIT_gnj_RiemPow2_03.m3f: Moved to the Adds tabs which avoids odd effects on DE calculation Old formula name: JIT_gnj_RiemannPower2_03.m3f VARIABLES: - Shift_QuotCForward / Shift_QuotXYZForward / Shift_QuotBackward They are controlling some quotients while transforming Riemann sphere <-> complex plane Shift_QuotCForward / Shift_QuotXYZForward: Especially values between 1 and -1 are interesting. There may be some weird regions (if the quotient gets to close to 0), but there are also the largest effects. Shift_QuotBackward Most interesting values are between 1 and 0. Larger values can become boring (too regular surfaces). Negative values can become mostly weird. - NumComplexOps = Number of operations on complex plane. A larger number generates more details. Currently only values from 1-3 are valid. NOTE that this should be an interger value. However v190 seams not to support integer values in the JIT - SquaredRBackward: 0: Only original R will be re-applied. Meant that is a pure transformation. 1: Squared R gets used. In my current tests it results in more smooth surface. No other values can be used. - AddCAtEnd: <>0: Add the original c after re-applying R. Together with SquaredRBackward=1 there may come up some basic fractal behavior. ------------------------------------------------------------------------------ // calculating helper variables sq_rc := cx*cx + cy*cy + cz*cz; rc := sqrt(sq_rc); sq_r := x*x + y*y + z*z; r := sqrt(sq_r); // normalization x_norm := x/r; y_norm := y/r; z_norm := z/r; cx_norm := cx/r; cy_norm := cy/r; cz_norm := cz/r; // transform to complex quot_xyz := 1/(Shift_QuotXYZForward-z_norm); cmp_x := x_norm*quot_xyz; cmp_y := y_norm*quot_xyz; quot_c := 1/(Shift_QuotCForward-cz_norm); cmp_cx := cx_norm*quot_c; cmp_cy := cy_norm*quot_c; // complex calculation cmp_xtmp := cmp_x*cmp_x - cmp_y*cmp_y + cmp_cx; cmp_ytmp := 2*cmp_x*cmp_y + cmp_cy; cmp_x := cmp_xtmp; cmp_y := cmp_ytmp; If NumComplexOps >= 2 then | Escapetime Transformations Only |

_JIT_gnj_RiemPowRadial_01 | SUMMARY: What this formula does is to 1. map a triplex number as a Riemann sphere (i.e. divide all coordinates by R) 2. transform it to the complex plane (cartesian coordinates) 3. transform cartesian to radial coordinates 4. do some operation in complex plane: z(n+1) := z(n)^Complex_Z_Power, do some rotation of the angle component 5. transform it back to cartesian coordinates add the complex c 6. repeat 4.+5. NumComplexOps times 7. transform the number back to a Riemans sphere 8. re-apply R NOTE: By standard the value of the triplex number will not be changed. Therefore this is a transformation rather than independent formula. This is one of the reasons that I have marked it as _Add (the other one is because it improves the DE calculation) VARIABLES: - Shift_QuotCForward / Shift_QuotXYZForward / Shift_QuotBackward They are controlling some quotients while transforming Riemann sphere <-> complex plane Shift_QuotCForward / Shift_QuotXYZForward: Especially values between 1 and -1 are interesting. There may be some weird regions (if the quotient gets to close to 0), but there are also the largest effects. Shift_QuotBackward Most interesting values are between 1 and 0. Larger values can become boring (too regular surfaces). Negative values can become mostly weird. - Complex_C_Factor/ Complex_C_Rotate / Complex_Z_Power / Complex_Z_Rotate: The *_Rotate params are in degrees. One complex operation looks like: 1. z(n+1) = { r(n+1) = r(n)^Complex_Z_Power phi(n+1) = phi(n) * Complex_Z_Power + Complex_Z_Rotate } 2. z(n+1) = z(n) + c , where c = { r(c) = r(c) * Complex_C_Factor phi(c) = phi(c) + Complex_C_Rotate } applied once. - NumComplexOps = Number of operations on complex plane. A larger number generates more details. Currently only values from 1-3 are valid. NOTE that this should be an interger value. However v190 seams not to support integer values in the JIT - SquaredRBackward: 0: Only original R will be re-applied. Meant that is a pure transformation. 1: Squared R gets used. In my current tests it results in more smooth surface. No other values can be used. - AddCAtEnd: <>0: Add the original c after re-applying R. Together with SquaredRBackward=1 there may come up some basic fractal behavior. ------------------------------------------------------------------------------ FORMULA: // Transform custom rotation params degrees -> radiant rotc_rad := DegToRad(Complex_C_Rotate); rotz_rad := DegToRad(Complex_Z_Rotate); // calculating helper variables sq_rc := cx*cx + cy*cy + cz*cz; rc := sqrt(sq_rc); sq_r := x*x + y*y + z*z; r := sqrt(sq_r); // normalization x_norm := x/r; y_norm := y/r; z_norm := z/r; cx_norm := cx/r; cy_norm := cy/r; cz_norm := cz/r; // transform to complex quot_xyz := 1/(Shift_QuotXYZForward-z_norm); cmp_x := x_norm*quot_xyz; cmp_y := y_norm*quot_xyz; quot_c := 1/(Shift_QuotCForward-cz_norm); | Escapetime Transformations Only |

_JIT_gnj_RiemSimple_01 | SUMMARY: Simple transformations on complex plane via Riemann sphere Moved to the Adds tabs which avoids odd effects on DE calculation What this formula does is to - map a triplex number as a Riemann sphere (i.e. divide all coordinates by R) - transform it to the complex plane - does some simple operation in the complex plane: z(n+1) = Complex_MultAll * (Complex_MultZ * z(n) + Complex_AddC * c + Complex_AddFix) - transform the number back to a Riemann sphere - re-apply R NOTE: By standard the radius of the triplex number will not be changed. Therefore this is more a transformation rather than independent formula. PARAMETER: - Complex_***_x,y: This are the parameters with which you can control the complex operations. Each of the below Complex* variables are (as the name states) complex, and consists of a real (x), and an imaginary (y) part z(n+1) = Complex_MultAll * (Complex_MultZ * z(n) + Complex_AddC * c + Complex_AddFix) - Shift_QuotCForward / Shift_QuotXYZForward / Shift_QuotBackward: They are controlling some quotients while transforming Riemann sphere <-> complex plane Shift_QuotCForward / Shift_QuotXYZForward: Especially values between 1 and -1 are interesting. There may be some weird regions (if the quotient gets to close to 0), but there are also the largest effects. Shift_QuotBackward: Most interesting values are between 1 and 0. Larger values can become boring (too regular surfaces). Negative values can become mostly weird. - SquaredRBackward: 0: Only original R will be re-applied. Meant that is a pure transformation. 1: Squared R gets used. In my current tests it results in more smooth surface. No other values can be used. - AddCAtEnd: <>0: Add the original c after re-applying R. Together with SquaredRBackward=1 there may come up some basic fractal behavior. ------------------------------------------------------------------------------ FORMULA: // calculating helper variables sq_rc := cx*cx + cy*cy + cz*cz; rc := sqrt(sq_rc); sq_r := x*x + y*y + z*z; r := sqrt(sq_r); // normalization x_norm := x/r; y_norm := y/r; z_norm := z/r; cx_norm := cx/r; cy_norm := cy/r; cz_norm := cz/r; // transform to complex quot_xyz := 1/(Shift_QuotXYZForward-z_norm); cmp_x := x_norm*quot_xyz; cmp_y := y_norm*quot_xyz; quot_c := 1/(Shift_QuotCForward-cz_norm); cmp_cx := cx_norm*quot_c; cmp_cy := cy_norm*quot_c; // complex calculation cmp_xtmp := cmp_cx*Complex_AddC_x - cmp_cy*Complex_AddC_y + cmp_x*Complex_MultZ_x - cmp_y*Complex_MultZ_y + Complex_AddFix_x; cmp_ytmp := cmp_cx*Complex_AddC_y + cmp_cy*Complex_AddC_x + cmp_y*Complex_MultZ_x + cmp_x*Complex_MultZ_y + Complex_AddFix_y; cmp_x := cmp_xtmp; cmp_y := cmp_ytmp; cmp_xtmp := cmp_x*Complex_MultAll_x - cmp_y*Complex_MultAll_y; cmp_ytmp := cmp_x*Complex_MultAll_y + cmp_y*Complex_MultAll_x; cmp_x := cmp_xtmp; cmp_y := cmp_ytmp; // transform back to sphere / triplex; quot_xyz_back := 1/(Shift_QuotBackward + cmp_x*cmp_x + cmp_y*cmp_y); x_norm := 2*cmp_x*quot_xyz_back; y_norm := 2*cmp_y*quot_xyz_back; | Escapetime Transformations Only |

_JIT_gnj_TSimp_Newt3_03 | SUMMARY: Second Approach to define a Newton method on z^3+1=0 for a certain (non-trig) type of 3-dimensional numbers Old formula name: JIT_gann_TSimp_Newt3_2.m3f CHANGES: _JIT_gnj_TSimp_Newt3_03.m3f: Moved to Adds section JIT_gnj_TSimp_Newt3_02.m3f: Added a fix for r (fix_r) to avoid r <= 0 (Use positive values) FORMULA: r1 := (x*x + y*y + z*z - 2*y*z); r1 := 1/(3*r1*r1+fix_r); x_tmp := x*x - y*y - z*z + 2*y*z; y_tmp := -2*x*y; z_tmp := -2*x*z; x := 2*x/3 - x_tmp*r1 + x_shift + cx; y := 2*y/3 - y_tmp*r1 + y_shift + cy; z := 2*z/3 - z_tmp*r1 + z_shift + cz; | Escapetime Transformations Only |

_JIT_gnj_VolterraLotka_02 | SUMMARY: Volterra-Lotka attractor CHANGES: _JIT_gnj_VolterraLotka_02.m3f: - Pre-factors are changing through the picture (Julia/Mandel constants used) - For each dimension a fix value (a,b,c) is added PARAMETERS: delta is equivalent to the time step (delta t) as the original equation is a differential equation FORMULA: x_tmp := x + delta*(x - x*y + cz*x*x - cx*z*x*x); y_tmp := y + delta*(-y + x*y); z_tmp := z + delta*(-cy*z + cx*z*x*x); x := x_tmp + a; y := y_tmp + b; z := z_tmp + c; | Escapetime Transformations Only |

_JuliaSets | A pretransform to show juliasets from formulas. rs = 1 / Separation Cx = Round(px * rs) Cy = Round(py * rs) Cz = Round(pz * rs) x = (px * rs - Cx) * Separation y = (py * rs - Cy) * Separation z = (pz * rs - Cz) * Separation Cx = Cx * Julia_factor Cy = Cy * Julia_factor Cz = Cz * Julia_factor | Escapetime Transformations Only |

_juliax2 | Description: Shows a double Julia set, with chosen seeds. Just *don't* turn on Julia mode, and use as a pretransform! | Escapetime Transformations Only |

_kamtor | Description: KAM torus system customizable "dynamic" variation in 3D - variation with 12 parameters + 2 From UF database, modified version. Very odd shape, an interesting "Henon-like" attractor. Instead of sine and cosine (slow functions) I use only poly functions. z is the old angle parameter Each section at z=constant shows a different "KAM torus" 2D variation (well, with standard params and soft1=1,soft2=0). Soft params control the dynamism of the system. You can (almost) fully customize the system to see different shapes. Formula by Luca GN 2011 z' = Soft1*z + Soft2*(sqrt (x^2 + y^2)) if |z'|<1 t1=z' ; t2=sqrt(1 - t1*t1) else t1=1/z' ; t2=sqrt(1 - t1*t1) endif x' = t2 ( A1 x + B1 y + C1 x*x + D1 y*y + E1 x*y + F1 sqrt |x^2 + y^2| ) + t1 ( A2 x + B2 y + C2 x*x + D2 y*y + E2 x*y + F2 sqrt |x^2 + y^2| ) y' = t1 ( A1 x + B1 y + C1 x*x + D1 y*y + E1 x*y + F1 sqrt |x^2 + y^2| ) + t2 ( A2 x + B2 y + C2 x*x + D2 y*y + E2 x*y + F2 sqrt |x^2 + y^2| ) Original uf formula; x' = x cos theta + (x^2-y) sin theta x' = x sin theta + (x^2-y) cos theta But there is no need to compute sin,cos if we call sin theta -> z ... etc... | Escapetime Transformations Only |

_kamtorcut | Description: *** CUTOFF MUST BE GREATER THAN 0 AND LESS THAN 1 (OR EQ.) *** *** BAILOUT SHOULD BE LESS THAN 100; USE GREATER VALUES AT YOUR RISK *** KAM torus system customizable "dynamic" variation in 3D - variation with cutoff Formula by Luca GN 2011 Same as standard version, but less noisy (and faster) because when |z'| > cutoff we discard z' = Soft1*z + Soft2*(sqrt (x^2 + y^2)) if |z'| < .85 t1=z' ; t2=sqrt(1 - t1*t1) else set x=100, y=100 to force bailout goto END endif x' = t2 ( A1 x + B1 y + C1 x*x + D1 y*y + E1 x*y + F1 sqrt |x^2 + y^2| ) + t1 ( A2 x + B2 y + C2 x*x + D2 y*y + E2 x*y + F2 sqrt |x^2 + y^2| ) y' = t1 ( A1 x + B1 y + C1 x*x + D1 y*y + E1 x*y + F1 sqrt |x^2 + y^2| ) + t2 ( A2 x + B2 y + C2 x*x + D2 y*y + E2 x*y + F2 sqrt |x^2 + y^2| ) END: return | Escapetime Transformations Only |

_LinCombineCxyz | Description: A general 3x3 matrix conversion for C: Cx' = CXx*Cx + CXy*Cy + CXz*Cz Cy' = CYx*Cx + CYy*Cy + CYz*Cz Cz' = CZx*Cx + CZy*Cy + CZz*Cz You can use it for example as a pretransform for bulbs or boxes. | Escapetime Transformations Only |

_LinCombineXYZ | Description: A general 3x3 matrix conversion: x' = Xx*x + Xy*y + Xz*z y' = Yx*x + Yy*y + Yz*z z' = Zx*x + Zy*y + Zz*z | Escapetime Transformations Only |

_LogX | Description: Logarithm for x + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*x+fixX s = sign(x') x = ln(x'+fixLg)/ln(Base)*s | Escapetime Transformations Only |

_LogY | Description: Logarithm for y + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*y+fixY s = sign(x') y = ln(x'+fixLg)/ln(Base)*s | Escapetime Transformations Only |

_LogZ | Description: Logarithm for z + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*z+fixZ s = sign(x') z = ln(x'+fixLg)/ln(Base)*s | Escapetime Transformations Only |

_lorenz | Description: Lorenz hyperchaotic system in 4D - variation with four parameters and strength Adapted from an article of Jiang Xu, Guoliang Cai, Song Zheng. Published by "International Journal of Nonlinear Science Vol.8(2009) No.1,pp.117-123". Found in a PDF. Formula by Luca GN 2011 This deformation can be likely used alone ( or plus a _addC ) to show the solutions of the system, that look very odd. The solution changes much for small increments of the given constants. Use strength to get more solid/thin objects. x' = ( a (y - x) + w )* Strength y' = ( c x - y - xz ) * Strength z' = ( xy - b z )* Strength w' = ( r w - yz ) * Strength In the article those parameters are used; a=10, b=2.66667, c=28, r=-1 | Escapetime Transformations Only |

_loresmode | A cool 3D transform suggested by Aexion, to give an illusion of a pixelated mode, use as pretransform to see strange effects on escape-time fractals. Be careful; it will disturb DE at times. LucaGN & Aexion 2016 | Escapetime Transformations Only |

_MapTranslate | Add a constant from a spherical projected Map to the vector components: Mvec = GetRGBfromSphereMap(@x, Map_nr) x = x + (Mvec[0] + X_offset) * X_scale y = y + (Mvec[1] + Y_offset) * Y_scale z = z + (Mvec[2] + Z_offset) * Z_scale On higher Map scale values you might have to decrease the 'Raystep multiplier' to not overstep. If you still get much noise, try to uncheck the 'Normals on DE' option in the Calculation tab. Because the map function is very slow, use this formula only in few iterations or just as a pretransform. The maps output range is 0 to 1 (black to white). The map must be in the 'Lightmap folder' specified by the 'Ini Dirs' button, named only by the map number and stored as png or jpeg image. | Escapetime Transformations Only |

_MaxClipping | No “i” info | Escapetime Transformations Only |

_NeoSqrX | Description: Formula by Luca GN 2011 Let's define a new formula: NeoSqr(A,B) := if A>0 A' = A(B-A) else A' = A(A-B) endif So my transform is here x' = NeoSqr( Mul * x + fixX , fixSq )/Div - fixX This transform is very strange, so use it wisely... | Escapetime Transformations Only |

_NeoSqrY | Description: Formula by Luca GN 2011 Let's define a new formula: NeoSqr(A,B) := if A>0 A' = A(B-A) else A' = A(A-B) endif So my transform is here y' = NeoSqr( Mul * y + fixY , fixSq )/Div - fixY This transform is very strange, so use it wisely... | Escapetime Transformations Only |

_NeoSqrZ | Description: Formula by Luca GN 2011 Let's define a new formula: NeoSqr(A,B) := if A>0 A' = A(B-A) else A' = A(A-B) endif So my transform is here z' = NeoSqr( Mul * z + fixZ , fixSq )/Div - fixZ This transform is very strange, so use it wisely... | Escapetime Transformations Only |

_ngon | Description: Variation of PolyFolding; gets nearly identical results as the Apophysis variation. Beware, it's not conformal! 🙂 Luca GN 2013 | Escapetime Transformations Only |

_ngon2 | Description: Variation of PolyFolding. Beware, not conformal and disturbs DE! But very nice effect as pretransform! Luca GN 2013 | Escapetime Transformations Only |

_PartlyJulia | A pretransform to disable partly the julia mode. if (Px > X_above) or (Px < X_below) then Cx := Px + X_add if (Py > Y_above) or (Py < Y_below) then Cy := Py + Y_add if (Pz > Z_above) or (Pz < Z_below) then Cz := Pz + Z_add P is the actual position and C the adding constant. For example if you want to change the julia mode into the non-julia mode at x=5 towards lower values, set X_below to 5 and X_add to -5 if julia X is zero. If X_add is the difference between the Julia value and X_below (or X_above if you use this), then you get a smooth change towards the non-julia mode. Same for the Y and Z dimensions. | Escapetime Transformations Only |

_PartlyJuliaR | A pretransform to enable partly the julia mode outside (or inside) a solid. The transition is gradual if speed < 1, but acts like a scissor when speed = 1. Gradual transition gives a "lens" effect to the fractal. Recenter; Normally, the Julia and the Mset are inside a "bubble" that has a different center. This allows you to see Mset and Julia as a "continuum"... But too bad, this means often no visibility when Center is too far from the origin for the other set (Mandel or Julia depending from mode). But don't be mad; the formula can automatically adjust this when you set recenter = 1! In this mode, Mandel and Julia are displayed as "separate worlds". Recenter can be any float value though. Shape; You can enable the Julia mode inside a different solid... Not only the sphere but; Shape = -4 -> Single sided pyramid Shape = -2 -> Single sided cone Shape = 1 -> Cube Shape = 2 -> Double cone Shape = 3 -> Cylinder Shape = 4 -> Double Pyramid Any other value -> Sphere *** Formula (x' is x - xCenter etc) R = sqrt(x'*x'+y'*y'+z'*z')/Rmax; // Euclidean metric (sphere) // Cubic metric (not euclidean but funny); // x' = abs(x'); y' = abs(y'); z' = abs(z'); // R = max(x',y',z')/Rmax; // Biconical metric; // R = sqrt((x'*x'+y'*y')/(z'*z'))/Rmax; <- rmax controls the pendence // Cylindrical metric; // R = sqrt(x'*x'+y'*y')/Rmax; // Pyramid metric; // R = (max(x',y')/z')/Rmax; if inside==1 { // simple mode, out Mandel and in Julia. if R < 1 { R -= Speed if R > 0 { // Transition // never get here if R==0 or you get in trouble!... R /= (1-Speed); Cx = (1-R) * Sx + R * Cx; Cy = (1-R) * Sy + R * Cy; Cz = (1-R) * Sz + R * Cz; rc = rec*(1-R); x -= rc*xC; y -= rc*yC; z -= rc*zC; } else { // inside must be Julia rc = rec; Cx = Sx; Cy = Sy; Cz = Sz; x -= rc*xC; y -= rc*yC; z -= rc*zC; // implemented with a GOTO }} // outside is left untouched } else { // alternate mode, out Julia and in Mandel. Longer formula if R < 1 { R -= Speed if R > 0 { // Transition // never get here if R==0 or you get in trouble!... R /= (1-Speed); Cx = (1-R) * (Cx-rec*xC) + R * Sx; Cy = (1-R) * (Cy-rec*yC) + R * Sy; Cz = (1-R) * (Cz-rec*zC) + R * Sz; rc = rec*(1-R); // implemented with a GOTO x -= rc*xC; y -= rc*yC; z -= rc*zC; } else { // inside must be shifted Mset Cx = Cx-rec*xC; Cy = Cy-rec*yC; Cz = Cz-rec*zC; rc = rec; // implemented with a GOTO x -= rc*xC; y -= rc*yC; z -= rc*zC; }} else { // (R>=1 is outside) // outside must be unshifted Julia with given seed! Cx = Sx; Cy = Sy; Cz = Sz; } } // end // like always Cx is the C value and x the spatial coord Hint! Use bigger R values for "box-type" fractals Luca GN 2011 | Escapetime Transformations Only |

_PartlyJuliaRoff | A pretransform to disable the julia mode outside a spheres radius. Julia offsets are kept, so a real non-julia mode will usually not appear. xt = Px - X_sphere yt = Py - Y_sphere zt = Pz - Z_sphere r = Sqrt(Sqr(xt) + Sqr(yt) + Sqr(zt)) if r > Radius_sphere { rt = r - Radius_sphere; if Abs(r) < 1e-10 r = sign(r) * 1e-10 m = rt / r Cx = Cx + xt * m Cy = Cy + yt * m Cz = Cz + zt * m } There will be also some strange boxes if used in non-julia mode. Thanks to Luca for the idea of using a radius. | Escapetime Transformations Only |

_planeFold | Description: A folding on a arbitrary plane with normal N: dd = 2*(x*Nx + y*Ny + z*Nz) x = x - Nx*dd y = y - Ny*dd z = z - Nz*dd The normal must be normalised to not scale the result and disturb the DE. | Escapetime Transformations Only |

_PlusSinApp | Like the _YplusSinZ formula, but with more options and a fast sine approximation. Indices gives the vectorparts: 0: x 1: y 2: z 3: w Don't use index 3 (w) with 3d analytic formulas, because w is used for the distance estimation! The formula: Vec[Index1] = Vec[Index1] + SineApprox((Vec[Index2] - Offset1) * Scale1) * Scale2 + Offset2 | Escapetime Transformations Only |

_poincare | Description: Poincarè metric in 3D with selectable radius and center. Well, it is *like* the Poincarè metric, not exactly... This needs a bit of coordinate adjustment. Remind that this is a VERY strong deformation so use it wisely. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = (x'*x'+y'*y'+z'*z'), x'' = abs(x')/abs(PR-Rho) y'' = abs(y')/abs(PR-Rho) z'' = abs(z')/abs(PR-Rho) For your convenience, x'',y'',z'' are translated back. Basic formula and explanations can be read here; http://en.wikipedia.org/wiki/Poincar%C3%A9_disk_model | Escapetime Transformations Only |

_PolyFolding | Description: Useful to get symmetric poly and star effects. It should be used as pretransform Also known as "kaleidoscope" or whatever you like Don't abuse of this effect, it's kind of cheap. Anyway, it tends to introduce discontinuity so use wisely. It can be good if used with KIFS. An interesting effect: use it with normal fractals, but choose power=1 and use this as "power" instead, on every iter. Nice effects. // Acts like boxtiling: only on angles instead of lengths // find the correct angle theta = -roundint(atan2(x+dx,y+dy)/twopi*order+(shift+skew)*degtorad)/order*twopi theta = theta + shift*degtorad // 2D standard rotation x' = x cos theta - y sin theta y' = x sin theta + y cos theta Where twopi and degtorad are constant values | Escapetime Transformations Only |

_PolyFold-sym | Description: Useful to get symmetric poly and star effects. Sym because on even orders it is a continue symmetrical transform. Also you can use Shift X, Y, and the angular shift without causing discontinuity. Luca GN 2012 | Escapetime Transformations Only |

_QuadrayTransform | Description: Based on Aexions ideas, this performs a quadray transform to be used as first formula as pre-transform, and choosing 'repeat from here' on the next formula(s). It is a 3d transform, but the result is 4d, so a combination with 4d formulas would make a better sense. Cx' = Cx + Cy + Cz Cy' = -Cx - Cy + Cz Cz' = -Cx + Cy - Cz Cw' = Cx - CY - Cz x' = x + y + z y' = -x - y + z z' = -x + y - z w' = x - Y - z | Escapetime Transformations Only |

_rabinovich-f | Description: Rabinovich-Fabrikant chaotic system in 3D - variation with four parameters and strength Adapted and modified from Wikipedia. Formula by Luca GN 2011 This deformation can be likely used alone ( or plus a _addC ) to show the solutions of the system, that look very odd. The solution changes much for small increments of the given constants. Use strength to get more solid/thin objects. x' = ( y (z - a + x^2) + c x )* Strength y' = ( x (b z + a - x^2) + c y ) * Strength z' = ( (a - b) z (d + xy) )* Strength a = 1 and b = 3 is the standard R-F system, but you can also change those parameters and get more effects. | Escapetime Transformations Only |

_recFold | Description: As the name states, this creates many copies of your fractal, arranged in a rectangle shape. Screws up coords a bit, too. | Escapetime Transformations Only |

_reciprocalX | Description: Computes the reciprocal of x: x = 1/x Disturbs the DE, so handle with care. | Escapetime Transformations Only |

_reciprocalX2 | Description: Computes the reciprocal of x: x' = sign(x)/(abs(x)+Limiter) The limiter makes the formula more handsome, bigger values leads to less noise. Disturbs still the DE, so handle with care. | Escapetime Transformations Only |

_reciprocalX3 | Description: Computes the reciprocal of x with a different (continuous) function: x' = sign(x)(1/Lim - 1/(abs(x)+ Lim )) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_reciprocalX3b | Description: Computes a reciprocal-style function of x with a different (continuous) function, fine-tuneable: x' = sign(x)(1/Lim1 + 1/lim2 - 1/(abs(m1 * x)+ Lim ) - 1/(m2 * x*x+ Lim2 ) ) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_reciprocalY2 | Description: Computes the reciprocal of y: y' = sign(y)/(abs(y)+Limiter) The limiter makes the formula more handsome, bigger values leads to less noise. Disturbs still the DE, so handle with care. | Escapetime Transformations Only |

_reciprocalY3 | Description: Computes the reciprocal of y with a different (continuous) function: y' = sign(y)(1/Lim - 1/(abs(y)+ Lim )) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_reciprocalY3b | Description: Computes a reciprocal-style function of y with a different (continuous) function, fine-tuneable: y' = sign(y)(1/Lim1 + 1/lim2 - 1/(abs(y)+ Lim ) - 1/(y*y+ Lim2 ) ) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_reciprocalZ2 | Description: Computes the reciprocal of z: z' = sign(z)/(abs(z)+Limiter) The limiter makes the formula more handsome, bigger values leads to less noise. Disturbs still the DE, so handle with care. | Escapetime Transformations Only |

_reciprocalZ3 | Description: Computes the reciprocal of z with a different (continuous) function: z' = sign(z)(1/Lim - 1/(abs(z) + Lim )) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_reciprocalZ3b | Description: Computes a reciprocal-style function of z with a different (continuous) function, fine-tuneable: z' = sign(z)(1/Lim1 + 1/lim2 - 1/(abs(z)+ Lim ) - 1/(z*z+ Lim2 ) ) The DE is almost untouched, it should work fine also with a Raystep 0.5 ! Just don't go too low with the limiter to avoid noise. | Escapetime Transformations Only |

_rossler | Description: Rossler hyperchaotic system in 4D - variation with four parameters and strength Adapted from an article of Jiang Xu, Guoliang Cai, Song Zheng. Published by "International Journal of Nonlinear Science Vol.8(2009) No.1,pp.117-123". Found in a PDF. Formula by Luca GN 2011 This deformation can be likely used alone ( or plus a _addC ) to show the solutions of the system, that look very odd. The solution changes much for small increments of the given constants. Use strength to get more solid/thin objects. x' = ( -y - z )* Strength y' = ( x + ay + w ) * Strength z' = ( b + xz )* Strength w' = ( d w - c z ) * Strength In the article those parameters are used; a=.25, b=3, c=.5, d=.05 | Escapetime Transformations Only |

_Rotate | No “i” info | Escapetime Transformations Only |

_Rotate4d | No “i” info | Escapetime Transformations Only |

_RotateBack | You generally don't need to use this. This transform is "specialistic"... Un-does a given rotation, putting exactly the things as they were before it. It's not that obvious, because a rotation by (-Rotx,-Roty,-Rotz) in general does NOT!!! work as a RotBack, and I don't know what angles are needed. You have to type the angles without changing the sign (as they are). | Escapetime Transformations Only |

_RotateC | Rotation of the constant on 3 axis, based on a generated rotation matrix: Cx' = Cx*m[0,0] + Cy*m[0,1] + Cz*m[0,2] Cy' = Cx*m[1,0] + Cy*m[1,1] + Cz*m[1,2] Cz' = Cx*m[2,0] + Cy*m[2,1] + Cz*m[2,2] In combination with _Rotate to rotate the whole coordinate system, or just for fun. | Escapetime Transformations Only |

_RotatedAbs | A combination of; - Rotate by the given angles - Add a value to X, AbsX, Subtract a value to X - RotateBack by the given angles It's a generalization of the Abs formula. "X" is purely conventional, because any direction can be used changing the angles! | Escapetime Transformations Only |

_RotatedFolding | A combination of; - Rotate by the given angles - x = abs(x+Fold) - abs(x-Fold) - x - RotateBack by the given angles It's a generalization of Tglad's folding formula (on a single direction). "X" is purely conventional, because any direction can be used changing the angles! | Escapetime Transformations Only |

_RotatePlaneOnIts | Description: 1) Rotates the reference axis by selected angles 2) Rotates the XY plane on an angle multiplied by the iteration count: SinCos(ItCount * Iteration_multiplier * Pid180, s, c) x' = x * c + y * s y' = y * c - x * s With the constant Pid180 as conversion-factor between grad and radians. 3)Rotates the reference axis at the inital position (transposed rot. matrix) Original formula by Jesse - Added functionality LucaGN Jesse: Renamed formula from _RotateXYOnIts to _ RotatePlaneOnIts to make som of my old parameters still work 🙂 | Escapetime Transformations Only |

_RotateRnd | Note 1; This transform may be a bit slow (more fast if you disable some rotations, use values out of range like 3) Note 2; A rotation range of '0' (or '-0') is NOT reccomended because it involves in no rotation; the calculus are way faster if you set a value out of range (and the result is identical). This special transform generates a pseudorandom vector that depends on the iteration count, and a random seed that you can choose for each axis. Then it rotates x,y,z "randomly". The fractals that you will get will not be exactly self similar, that is fun! Try to use this with Menger to see a fractal that changes when you zoom... Luca GN 2012 | Escapetime Transformations Only |

_RotateXYonIts | Description: 1) Rotates the reference axis by selected angles 2) Rotates the XY plane on an angle multiplied by the iteration count: SinCos(ItCount * Iteration_multiplier * Pid180, s, c) x' = x * c + y * s y' = y * c - x * s With the constant Pid180 as conversion-factor between grad and radians. 3)Rotates the reference axis at the inital position (transposed rot. matrix) Original formula by Jesse - Added functionality LucaGN | Escapetime Transformations Only |

_RotateXYonItsP | Description: WARNING don't use an integer positive sub with a negative pow or you get errors!!! (trying to calculate 1/0) - more generalized version of RotXYonIts by Jesse 1) Rotates the reference axis by selected angles 2) Rotates the XY plane on an angle rho: rho = ( abs(ItCount - IterFix) ) ^ IterPow ... that is function of the itercount. (It allows you to get a zero rotation on very high itcounts and other effects normally unobtainable) SinCos(Iteration_multiplier * rho * Pid180, s, c) x' = x * c + y * s y' = y * c - x * s With the constant Pid180 as conversion-factor between grad and radians. 3)Rotates the reference axis at the inital position (transposed rot. matrix) Added functionality LucaGN | Escapetime Transformations Only |

_scaleC | A pretransform to scale C components. | Escapetime Transformations Only |

_Simplex3DShift | Description: This script was only possible thanks to Orwell C++ Compiler, and the work of Knighty & Jesse, Nikita Miropolskiy. The original script can be found at: www.shadertoy.com/view/XsX3zB This modified version adds a pseudorandom full 3D noise to x,y and z components (instead of a 3D -> 1D like in the original), using a slightly different pseudorandom routine. The visual effects are very cool! Be very careful with wavelet coeffs, they can reveal some discontinuity. My pseudorandom routine is; // Sort of hash-randomization using ints, should be fast // very (?) random and portable unlike sin() 😛 // u0, v0, r0 are the simplex's integer-coords. int a=2,b=7,c=11,t; a = (a+15359*u0 + 16069*v0) ^ 0x5A5A; b = (b+16069*u0 + 15359*r0) ^ 0x5A5A; c = (c+15359*v0 + 16069*r0) ^ 0x5A5A; t = c; c = (c - b)*77773; b = (b - a)*77773; a = (a - t)*77773; *v = (rf*((double)(a & 1073741823)))+n_05; *r = (rf*((double)(b & 1073741823)))+n_05; *u = (rf*((double)(c & 1073741823)))+n_05; // fast stuff, even if we lose data 😐 a = a << 4; b = b << 4; c = c << 4; *v2 = (rf*((double)(a & 1073741823)))+n_05; *r2 = (rf*((double)(b & 1073741823)))+n_05; *u2 = (rf*((double)(c & 1073741823)))+n_05; a = a << 4; b = b << 4; c = c << 4; *v3 = (rf*((double)(a & 1073741823)))+n_05; *r3 = (rf*((double)(b & 1073741823)))+n_05; *u3 = (rf*((double)(c & 1073741823)))+n_05; return; | Escapetime Transformations Only |

_SinApprox | A faster sine approximation. Index: Do this function on vectorpart: 0: x 1: y 2: z 3: w The function itself: a = SinApprox((a - offset1) * scale1) * scale2 + offset2 | Escapetime Transformations Only |

_SinhX | Description: Hyp.Sine for x + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*x+fixX x = ln(x' + sqrt(x'*x' + 1))/ln(Base)+fixLg | Escapetime Transformations Only |

_SinhY | Description: Hyp.Sine for y + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*y+fixY y = ln(x' + sqrt(x'*x' + 1))/ln(base)+fixLg | Escapetime Transformations Only |

_SinhZ | Description: Hyp.Sine for z + some bells & whistles k must be nonzero! Formula by Luca GN 2013 x' = Mul*z+fixZ z = ln(x' + sqrt(x'*x' + 1))/ln(Base)+fixLg | Escapetime Transformations Only |

_SinY | New added parameters: Index: Do this function on vectorpart: 0: x 1: y 2: z 3: w The function itself: a = Sin((a - offset1) * scale1) * scale2 + offset2 | Escapetime Transformations Only |

_skew | Description: Use this effect with caution. It gives a nice "curliness" to some IFS formulas: try it before a Menger3 or an Amazing box! The effect must be low to not disturb DE or cause troubles. It is non-conformal. Skew = min ( x*k - lim, y*k - lim, z*k - lim ); Skew = Skew + abs (Skew) ; x' = x - Skew; y' = y - Skew; z' = z - Skew; | Escapetime Transformations Only |

_SphereFolding1 | No “i” info | Escapetime Transformations Only |

_SphereFolding2 | No “i” info | Escapetime Transformations Only |

_sphereXinv | Description: This formula born from a coding error while trying to implement sphere inversion. Gives a fuzzy result but can give very interesting effects. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = (x'*x'+y'*y'+z'*z'), x'' = Rho/x' (instead of x'/Rho ) y'' = y'/Rho z'' = z'/Rho For your convenience, x'',y'',z'' are translated back. Basic formula and explanations can be read here; http://en.wikipedia.org/wiki/Inversive_geometry | Escapetime Transformations Only |

_sphereYinv | Description: This formula born from a coding error while trying to implement sphere inversion. Gives a fuzzy result but can give very interesting effects. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = (x'*x'+y'*y'+z'*z'), x'' = x'/Rho y'' = Rho/y' (instead of y'/Rho ) z'' = z'/Rho For your convenience, x'',y'',z'' are translated back. Basic formula and explanations can be read here; http://en.wikipedia.org/wiki/Inversive_geometry | Escapetime Transformations Only |

_sphereZinv | Description: This formula born from a coding error while trying to implement sphere inversion. Gives a fuzzy result but can give very interesting effects. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = (x'*x'+y'*y'+z'*z'), x'' = x'/Rho y'' = y'/Rho z'' = Rho/z' (instead of z'/Rho ) For your convenience, x'',y'',z'' are translated back. Basic formula and explanations can be read here; http://en.wikipedia.org/wiki/Inversive_geometry | Escapetime Transformations Only |

_sqr_3D | Description: x' = x*x y' = y*y z' = z*z (x',y',z') *= Scale (x',y',z') += fixVec Disable Analytical DE to see the effect correctly. | Escapetime Transformations Only |

_sqr_4D | Description: x' = x*x y' = y*y z' = z*z w' = w*w (x',y',z',w') *= Scale (x',y',z',w') += fixVec Disable Analytical DE to see the effect correctly. | Escapetime Transformations Only |

_tocylindrical | Description: Cylindrical coords Formula by Luca GN 2011 x' = sqrt(x*x+y*y) y' = atan(y/x) (z coordinate is unchanged) | Escapetime Transformations Only |

_toruspinv1 | Description: Torus pseudo-inversion in 3D with selectable radius and center. This needs a bit of coordinate adjustment. Remind that this is a VERY strong deformation so use it wisely. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = abs((R-sqrt(x'*x'+y'*y'))^2+z'*z'), x'' = abs(x')/Rho y'' = abs(y')/Rho z'' = abs(z')/Rho For your convenience, x'',y'',z'' are translated back. This inversion is a conseguence of toric mapping, and Rho is defined as the toric modulus of every point. WARNING. This is not a correct inversion, due to approximations in geometry of torus; so applying it twice will NOT give back the undeformed space. If you know the real toric inversion formula, please send it to me. Thanks! | Escapetime Transformations Only |

_toruspinv2 | Description: Toric pseudo-inversion in 3D with selectable radius and center. This needs a bit of coordinate adjustment. Remind that this is a VERY strong deformation so use it wisely. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = abs((R-sqrt(x'*x'+y'*y'))^2+z'*z'), x'' = abs(x')/Rho y'' = abs(y')/Rho z'' = abs(z')*Rho For your convenience, x'',y'',z'' are translated back. WARNING. This is not an inversion, but only a funny deformation. Not for educational purposes 😛 | Escapetime Transformations Only |

_toruspinv3 | Description: Torus pseudo-inversion in 3D with selectable radius and center. This needs a bit of coordinate adjustment. Remind that this is a VERY strong deformation so use it wisely. Formula by Luca GN 2011 x', y', z' => Translate + scaling (by radius) of x, y, z with given params. Then, defined Rho = ((R-sqrt(x'*x'+y'*y'))^2+z'*z'), x'' = abs(x')/Rho y'' = abs(y')/Rho z'' = abs(z')/Rho For your convenience, x'',y'',z'' are translated back. This inversion is a conseguence of toric mapping, and Rho is defined as the toric modulus of every point. WARNING. This is not a correct inversion, due to approximations in geometry of torus; so applying it twice will NOT give back the undeformed space. If you know the real toric inversion formula, please send it to me. Thanks! | Escapetime Transformations Only |

_tospherical | Description: Spherical coords. Fast conversion without parameters. Formula by Luca GN 2011 From Wikipedia; x' = sqrt(x*x+y*y+z*z) y' = atan(sqrt(x*x+y*y)/z) z' = atan(y/x) | Escapetime Transformations Only |

_totorical | Description: Torical (generalized) coords. Formula by Luca GN 2011 Define R = (inner radius + outer radius) / 2. We don't care about two radiuses, we care of the average only. x' = R - sqrt(x*x+y*y) y' = atan(y/x) (z coordinate is unchanged. Almost identical to standard cylindrical coords.) I didn't found much about this metric but a base for information is; http://mathworld.wolfram.com/Torus.html | Escapetime Transformations Only |

_totorical2 | Description: Torical (generalized) coords. This coordinate system was defined by BradC in FractalForums: http://www.fractalforums.com/theory/toroidal-coordinates/msg9428/#msg9428 Formula by Luca GN 2011 Define R = (inner radius + outer radius) / 2. t = sqrt(x*x+y*y) - R x' = sqrt(t*t+z*z) y' = atan2(z,t) - Gamma - pi/2 z' = atan2(y,x) // NOTE - The addition of -pi/2 rends the transform reversible: // in other words totorical then invtorical returns the pixels // unchanged... Or so it showed up in my tests. | Escapetime Transformations Only |

_Transform | A general transform to shift, scale and rotate Z and C (by option). In DEcombinate mode, use it in the second formula tab (first formula of the hybrid of F2 to F6) as a pretransform and repeat on the next formula tab to adjust the whole object relative to the first object. This transform works with all 3d + 4d bulb and box formulas also in julia mode, just leave the Copy to C option checked. | Escapetime Transformations Only |

_Translate | No “i” info | Escapetime Transformations Only |

_TranslateC4d | Add a constant to the 4d vector and C components: x = x + x_add y = y + y_add z = z + z_add w = w + w_add Cx = Cx + Cx_add Cy = Cy + Cy_add Cz = Cz + Cz_add Cw = Cw + Cw_add Useful if you want to translate the whole coordinate system. | Escapetime Transformations Only |

_TranslateRnd | This special transform generates a pseudorandom vector that depends on the iteration count, and a random seed that you can choose for each axis. Its components can be in the interval; (-r/2 ... +r/2) where r is the range. Then it adds the "randomized vector" to x,y,z. The fractals that you will get will not be exactly self similar, that is fun! Try to use this with Menger to see a fractal that changes when you zoom... Luca GN 2012 | Escapetime Transformations Only |

_updateC | Description: Moves x, y, z values to Cx, Cy, Cz or linear-combines C and xyz values, like this Cx = 1*x + .5*Cx (Spider's variation) Use as an iterated transform to see Spider version of Mandelbulb (if Integer Power is the first formula, or any other you like). Spider works in Julia mode too. Another usage of this is a pretransform. This allows you to calculate any Mandelbrot-like set in warped coordinates. Remember that all transforms MUST be used as pretransforms, put this AFTER all of them, then put the set (or the sets). Check repeat from here in the first M-set. | Escapetime Transformations Only |

_updateC_4d | Description: Moves x, y, z, w values to Cx, Cy, Cz, Cw. This allows you to calculate any 4d Mandelbrot-like set in warped coordinates. IFS are not affected by C. Remember that all transforms MUST be used as pretransforms, put this AFTER all of them, then put the set (or the sets). Check repeat from here in the first M-set. | Escapetime Transformations Only |

_updateC2 | Description: Mixes conditionally x,y,z and C in a strange way; if (x>Cx) swap(x,Cx); if (y>Cy) swap(y,Cy); if (z>Cz) swap(z,Cz); | Escapetime Transformations Only |

_vanderpol | Description: Van der Pol modified chaotic system in 4D - variation with six parameters and strength Formula by Luca GN 2011 This deformation can be likely used alone ( or plus a _addC ) to show the solutions of the system, that look very odd. The solution changes much for small increments of the given constants. Use strength to get more solid/thin objects. Cut this attractor at z=0, x=0 ... to see amazing views. x' = (z + b x) * Strength y' = (w + b y) * Strength z' = c y - d x + (a - r1 x^2) z w' = c x - d y + (f - r2 y^2) w | Escapetime Transformations Only |

_vanderpol2 | Description: Van der Pol modified chaotic system in 4D - variation with seven parameters and strength Formula by Luca GN 2011 This deformation can be likely used alone ( or plus a _addC ) to show the solutions of the system, that look very odd. The solution changes much for small increments of the given constants. Use strength to get more solid/thin objects. Cut this attractor at z=0, x=0 ... to see amazing views. x' = (g x + a y + b z + c w) * Strength y' = d zw - a x + (a - r x^2) y z' = e yw - b x + (b - r x^2) z w' = f zy - c x + (c - r x^2) w Unlike "normal" Van der Pol attractor (two interfering oscillators), this uses three oscillators (y,z,w), and disturbing params are zw for y, etc. | Escapetime Transformations Only |

_YplusSinZ | Description: y' = y + sin(z) | Escapetime Transformations Only |

_YplusSinZ2 | Description: A groovy waveform function that distorts nicely your fractal; y = y + 0.5 ( 2 - k + k cos ( pi h z ) ) sin z h = 0 or h = 0 will revert you to the default yplusSinZ. | Escapetime Transformations Only |

boardIFS | Quick attempt to realize a checkerboard. (Function used; sin(x)*sin(y) ) Variations available; 0. Standard 1. Inverse map - best seen at a big Checker scale 2. Cayley map (Mobius transform) - best seen at a big Checker scale 3. Logarithmic 4. Polar Updated for new release; now supports colors. Luca GN 2012 | dIFS Shapes |

borgIFS | The Borg Cube, a cool variant of the gyroid. Enable "Orbit trap" mode to see a marble coloring. Equation; sin xy + sin yz + sin zx =0 (Intersected with a cube... it's infinite) Luca GN 2012 | dIFS Shapes |

cayleySurfIFS | "Cayley's surface. Added rotation and a customizer... Equation; -abs(x2ymul) * (x*x*y + x*x*z + y*y*x + y*y*z + z*z*y + z*z*x) +2*(x*y + x*z + y*z) = 0 (Intersected with a sphere... it's infinite) Luca GN 2012" | dIFS Shapes |

CommaIFS | Approximate "Yin-Yang" shape. Looked closely it is not perfect but it's nice for some decorations. Inspired from a PovRay shape (but different). Flip and sign changes are useful to 'rotate' around the shape. Luca GN 2012 | dIFS Shapes |

CylinderHMVoid | Luca hack mar 2015: Works exactly as CylinderHeightMap but it's only a very thin "surface", useful for some experiments like putting stuff inside 😉 Use a LOW raystep, or the object will not be shown correctly. Jesse original comment: A displacement map on a cylinder with color option on orbit trap (2nd color choice). You can choose a RGB channel of the Map (0=R,1=G,2=B) for the displacement and another channel for OTrap coloring. | dIFS Shapes |

DevilIFS | Citrus surface (from MathWorld). Very similar to piriform. Added rotation and customizers... Equation; CiMul * (x*x + z*z) +y^3 * ((y - CiSub) ^ 3) = 0 Luca GN 2012 | dIFS Shapes |

diamondIFS | Code taken from Shadertoy site: https://www.shadertoy.com/view/XlyGDm (orginal created by Nrx in 2016-Sep-26) Change Faces slider to get different gems, try integers and ints + 0.5! | dIFS Shapes |

diniIFS | Modified pseudosphere. Generates Dini's helix, a famous surface. Note; this is very slow, due to the complex shape and functions. Luca GN 2012 | dIFS Shapes |

discoballIFS | Plots a "faceted" sphere using the powerful PolyFoldEx. The sphere is empty inside (good for placing something in!) Luca GN 2012 | dIFS Shapes |

dodecatubeIFS | A dodecahedral shape based on a plain cylinder DE, after a folding12 and a rotation on XZ plane. Nice variations can be seen for different angles and values! For example; ICOSIDODECA; SUBY = 1.6125, SUBZ = 1, ROTATIONS = (90, 0) and spherepos = 0.6125 | dIFS Shapes |

ducksIFS | WARNING be sure to execute this ONLY once; it is very math intensive. This is because Ducks fractal needs 50 to 100 iters to be seen clearly, and uses two slow functions per iter per pixel. So please be patient... Heightmap dynamically generated from Sam's 2D Ducks formula. Try to change seed to vary the shapes. Use more iters to get more details (some details will be much extruded though). Be careful with the 'Iters', again, because NO check is done on what you type, and more iters means more time... Updated; now supports colors and a formula variation (angle). Use a negative multiplier for a different color mode (faster variation). Updated 2; Update; Much faster computation due to an optimization suggested by Jesse. It ensures a quality identical as before but 5x faster. | dIFS Shapes |

eiffieCarIFS | Eiffie's "Shiny toy", code taken from Shadertoy site. Note; car glasses are colored wrong here. | dIFS Shapes |

foldcut12-IFS | Based on a Knighty script. Added a sphere, that acts as a limit or a 'decoration' depending on its radius. Disable it putting R = 0 (default value). Negative sphere is very useful to show 'negative polyhedra' too. Normals change the shape; infinite combinations possible! Luca GN 2012 | dIFS Shapes |

foldcut8-IFS | Based on a Knighty script. Added a sphere, that acts as a limit or a 'decoration' depending on its radius. Disable it putting R = 0 (default value). Negative sphere is very useful to show 'negative polyhedra' too. Normals change the shape; infinite combinations possible! Luca GN 2012 | dIFS Shapes |

gear2IFS | Attempt to replicate the Incendia's gear-like baseshape... Luca GN 2012 | dIFS Shapes |

gearIFS | Funny tool that generates "gear" shapes. For mechanical fractals! Luca GN 2012 | dIFS Shapes |

gnarly2IFS | This shows a variety of little spirals, and it's interesting and different from the classic one. Stunning effects can be done with this map, especially with reflections enabled. Try to change Alpha, Beta and steps to vary the shapes. Also Gamma has interesting effects. Use more iters to get more details (some details will be much extruded though). Be careful with the 'Iters', again, because NO check is done on what you type, and more iters means more time... Supports colors. Use a negative multiplier for a different color mode (slower variation). x = x + step * (sin( Gamma *(y - xx) + sin( alpha * (y + beta * cos(y) )))) | dIFS Shapes |

gnarly3IFS | Gnarl and Vine formulas, by Mark Townsend. More variety of the spirals, but less regularity. Stunning effects can be done with this map, especially with reflections enabled. Try to change Alpha, Beta and steps to vary the shapes. Use more iters to get more details (some details will be much extruded though). Be careful with the 'Iters', again, because NO check is done on what you type, and more iters means more time... Supports colors. Use a negative multiplier for a different color mode (slower variation). y' = xx + step * (sin( yy*sqrt(abs(y)) - alpha * sin( (yy + sin(beta * yy))))) x' = yy - step * (sin( xx*sqrt(abs(xx)) + sin( alpha *(xx + sin(beta * xx))))) | dIFS Shapes |

gnarlyIFS | this ONLY once; it is very math intensive. Heightmap dynamically generated from Gnarl 2D formula, by Mark Townsend. Stunning effects can be done with this map, especially with reflections enabled. Try to change Alpha, Beta and steps to vary the shapes. Use more iters to get more details (some details will be much extruded though). Be careful with the 'Iters', again, because NO check is done on what you type, and more iters means more time... Updated; now supports colors. Use a negative multiplier for a different color mode (slower variation). Update; Update; Much faster computation due to an optimization suggested by Jesse. It ensures a quality identical as before but 5x faster. | dIFS Shapes |

greekIFS | Iso-surface made of a grid of tubes arranged in a "greek spiral" pattern. y = y+sign(x)*.5; x = max(abs(x),abs(y)); DE = sqrt(sqr(x- int(x)) + sqr(z)) - tuberad; Luca GN 2012 | dIFS Shapes |

gumdropIFS | Gumdrop torus, a simple but fancy isosurface. As usual uncheck "Vary DEstop" for a more homogen object appearance. a = x^2; b = y^2; c = z^2; i = 4; j = 17; k = 20; DE = i ( a a + (b + c) ^ 2 ) + j a ( b + c ) + j - k ( a + b + c ) // I used a "stabilized" version of this expression good for many values of i,j,k Luca GN 2012 | dIFS Shapes |

gyroidIFS | Approximation of the gyroid minimal surface. Enable "Orbit trap" mode to see a marble coloring. Equation; cos x sin y + cos y sin z + cos z sin x =0 (Intersected with a cube... it's infinite) Luca GN 2012 | dIFS Shapes |

heartKluchIFS | Isosurface invented and shared by Alex Kluchikov (22 Aug 2003). p := abs(y+1.4); p = z*z + 0.25*x*x/(p*p*p*p+0.001); p = abs(y*1.1-0.8*sqrt(sqrt(p))); DE = (sqrt(6.25 *x*x + z*z + p*p ) - 1); | dIFS Shapes |

HeightMap2IFS | Just like HeightMap but with a Riemann projection before. An "infinity bubble" appears in the center. The NoPlane mode does not work always, the result can be a bit weird. LucaGN 2012 Original Jesse's comment; Use a map to generate a terrain out of the amplitude from the map color, use 'Map channel' to choose from r,g,b represented by the values 0,1 and 2. Use the orbit trap coloring mode to colorize the surface. Remember that a value of 1 for "Max. iterations" is enough to generate one dIFS object. | dIFS Shapes |

HeightMapIFS | Use a map to generate a terrain out of the amplitude from the map color, use 'Map channel' to choose from r,g,b represented by the values 0,1 and 2. Use the orbit trap coloring mode to colorize the surface. Remember that a value of 1 for "Max. iterations" is enough to generate one dIFS object. | dIFS Shapes |

helixIFS | A helix shape. Coord defines the direction. High values of Helix stretch and the Diameters makes the distance estimate bad, meaning it needs lowering the Raystep multiplier to not overstep. | dIFS Shapes |

hexgridIFS | Modified version of hextgrid, to show solid shapes instead of toruses. CutByUnrotZ allows you to get different effects if you use it together with non-zero PlaneRot X,Y. Luca GN 2012 | dIFS Shapes |

hextgrid2IFS | Beautiful iso-surface made of a hexagonal grid of tubes. Taken from K3DSurf forum, posted by user abdelhamid belaid. Equation (I optimized it btw); min(max(abs(y-floor(y/2+0.5)*2), abs(x-3/cos(pi/6)*floor(x/3*cos(pi/6)+0.5))*cos(pi/6) +abs(y-floor(y/2+0.5)*2)*sin(pi/6))-1, abs(y-floor(y/2+0.5)*2))^2+z^2-0.0225 Luca GN 2012 | dIFS Shapes |

hextgrid3IFS | Iso-surface made of a hexagonal grid of tubes, styled to show the illusion of a cube pattern. Code by Knighty, a bit modified by me. - Updated, added Rho and Final add modifiers Luca GN 2012 | dIFS Shapes |

hextgrid4IFS | Iso-surface made of a hexagonal grid of tubes, styled to show the illusion of a cube pattern. Code by me, it's much more complicated than Knighty's but also more flexible! Luca GN 2012 | dIFS Shapes |

hextgridIFS | Beautiful iso-surface made of a hexagonal grid of tubes. Taken from K3DSurf forum, posted by user furan. Equation; 1 + 8*z^2 + cos(4*y) +cos(2*sqrt(3)*x-2*y) +cos(2*sqrt(3)*x+2*y) + 0.12*( cos(4*sqrt(3)*x) +cos(6*y -2*sqrt(3)*x) +cos(6*y +2*sqrt(3)*x)) = 0 Luca GN 2012 | dIFS Shapes |

JosKn-KleinIFS | Description: The purpose of this script is to render images of Kleinian groups using a tweak of the escapetime algorithm, it is impossible to do this for any value of KleinR, KleinI without seeing cuts. This script was kindly provided by Jos Leys, and little edits were made by Knighty and me. Nobody achieved this result before. To minimize cuts, remembering that Klein is a complex number, use a number whose modulus is close to BoxSz*2, using similar values for both sizes, and small or very small KleinI for the best effects. BoxSz should be close to 1. But interesting renders are achieved with smaller values (spirals will be less visible). Too small values of KleinI may also lead to cuts. Options are three coded in binary form, try to vary the number to enable/disable. If options is 1, you will enable "four generators mode", you get infinite layers also in the 3rd dimension (slower and DE is less stable). If options is 2, you will enable "Show Balls". If options is 4, you will activate the sphere inversion, that helps to visualize the group as a whole, instead of seeing it as a "pillar infinite room". If options is 8, you enable "hexagon mode", beautiful shapes will appear! (fix 18 january: now every tile is exactly hexagonal when Box values are equal, the results are completely different than before though, and some possible bugs that caused noise to appear were removed, forcing the formula to bailout - a lot - earlier). AexionJ was an experimental feature, later implemented as a fully working one thanks to flawless suggestions by pupukuusikko & Jos (January 7 2016). See this param (by pupukuusikko): Kr = 1.91778 / Ki = 0.06126 / Bsx = 1 / Bsy = 0.707 ClY=.5 / ClDF=.5 / AexionJ = 0.07272 ColorMod is a slider that can be used to generate different coloring, when =1 it will be iter-based (polygons), when = 0 DE-based (smooth). | dIFS Shapes |

JosKn-ModIFS | Description: See JosKn original, but has some advanced options removed in favour of more interesting mods suggested by Aexion, trafassel and pupukuusikko. I must say that to get nice results will NOT be immediate, as you will need to try to activate/disactivate several options at once, summing their corrispondent numbers. JMScale/invRad explanation: Use a value close to zero (max 0.25 in absolute value) to enable it; it will distort the fractal shapes more or less strongly, but very small values are reccomended. When you enable it, the inversion radius is locked to value 1! Thanks to Aexion for the suggestion! If options is 1, you will enable "four generators mode", you get infinite layers also in the 3rd dimension (slower and DE is less stable). If options is 2, you will enable "Show Balls". If options is 4, you will activate the sphere inversion, that helps to visualize the group as a whole, instead of seeing it as a "pillar infinite room". If options is 8, you use boxfold for x & z; suggested by trafassel and pupukuusikko. If options is 16, you disable separation line; suggested by trafassel and pupukuusikko. In reality you will not disable it entirely. The feature seems to not work properly into MB3D so i replaced the separation line with this; // x00 contains the expression of separation line multiplied by a. x00 -= y; x00 += a * 0.25; // shift it a bit reveals more detail sadly // some detail will get lost. if (x00 < 0) break; // bail out if too far from sep. line prevents the fractal to get entirely lost If options is 32, you enable "FoldMod" option but just for x, this option has an effect when KleinI is not zero. Strongly reccomended try different signs. If options is 64, you enable "FoldMod" option but just for z, this option has an effect when AexionJ is not zero. Strongly reccomended try different signs. If options is 128, you enable "Abs2" option but just for x, this option has an effect when KleinI is not zero. Strongly reccomended try different signs. Thanks to Aexion for the suggestion! If options is 256, you enable "Abs2" option but just for z, this option has an effect when AexionJ is not zero. Strongly reccomended try different signs. Thanks to Aexion for the suggestion! | dIFS Shapes |

KleinBagelIFS | Variation of the torus; this is a Klein bottle parametrization, in R3. In cut section it shows a Lemniscate of Gerono, and it has a half Mobius twist. It is NOT a "knot" but a self-intersecting surface. Try to cut it to see interesting figures. Luca GN 2012 | dIFS Shapes |

K-TowerIFS | An enhanced version of the famous Scherk's minimal surface, that is defined, in its classic version, by the simple and elegant implicit equation in terms of cartesian x,y,z; sin(z) = sinh(x)sinh(y) This surface can be seamlessly "tiled" if you replace x with k*sin(x), and y with k*sin(y) with a k > 0.5 for a best effect. (I am pretty sure the surface isn't minimal anymore, but it still looks very elegant). Lots of beautiful variations can be visualized with other coordinate transforms on x,y,z (like toroidal), and you can see some examining the site https://wewanttolearn.wordpress.com/2015/11/11/scherks-minimal-surface/ // ---------------------------------------------------------------- To get a linearized, continuous DE you may try this algorithm; float ScherkDe(float x, float y, float z) // (by Luca GN 2016) { float Ex=exp(x); float Ey=exp(y); float zz=Ex*Ey; float N = Ex*Ex+Ey*Ey; float D = 1+zz*zz; zz = 4.*sin(z)*zz; // can be + or - or change 4 to get elliptic holes if (zz>0) N += zz else D -= zz; // we bring it to the correct eq side 🙂 return .5*(abs(log(N/D))-.05); // give it a little thickness so it renders better | dIFS Shapes |

KleinBotTIFS | A torical Klein Bottle; note that you can "enter inside" it, even if it has not inside or outside. The crossing surfaces are removed, so it looks like a real Klein bottle should look. Cut at z=0 to confirm it. Luca GN 2012 | dIFS Shapes |

Knots2IFS | Tool for plotting customized torus knots. As always, it's best to use it using the real-time Navi preview. This is an "extended version" of my knot routine, kindly shared by Knighty. It allows you to see a big number of knots impossible to obtain with plain "KnotsIFS", for example Figure 8 - the simplest not torical knot. It needs a "Lissajous" style coding. Some complicated knots will not show correctly in automatic, looking like an open string. That's incorrect of course; knot's ends must be connected. When this happens, increase the last integer controller; the "string" (sooner or later) will close. Don't use the last controller mindlessly, or the routine can become very slow. Luca GN 2012 | dIFS Shapes |

KnotsIFS | Tool for plotting customized torus knots. The main controls are "PolyFold Order" and "Mobius". Mobius controls the curliness of the node (add 1 to get a more 'complicated' knot 😀 ) At Y=0 section, the node will show a number of 'circles' controlled by PFOrder. So this will change the style of the knot in another way. To get a 'normal' knot made of n sub-toruses, I reccomend you to set mobius = 1 + 1/PFOrder. Other knots can be obtained setting Mobius = (a + b/PFOrder) // a and b arbitrary integers If you will not respect this rule, the result will be discontinue. Use a negative Mobius to get left-handed knots. For example; PolyOrder = 8 -> Mobius = 1 + 1/8 = 1.125 (Normal r-handed knot) Another possible knot of order 8; Mobius = 1 + 3/8 = 1.375 The radiuses do not change the type of the knot, only its look. | dIFS Shapes |

lidinoidIFS | Here density affects the surface shape too, so it's better use a combination of size and scale to get a more complicated look. Variation of the gyroid minimal surface. Longer formula. Found here; https://secure.msri.org/about/sgp/jim/papers/morphbysymmetry/lidinoid/index.html Enable "Orbit trap" mode to see a marble coloring. Equation; 0.5 ((sin 2z cos x sin y + sin 2x cos y sin z + sin 2y cos z sin x) - (cos 2x sin 2y + cos 2y sin 2z + cos 2z sin 2x)) = - 0.15 (Intersected with a cube... it's infinite) Luca GN 2012 | dIFS Shapes |

LimpetIFS | Limpet torus. An "ufoid"... Note! This surface is cutted off with a big cylinder, so for some critical parameters you won't see it entirely (and in some cases it's impossible to see it "entirely" ... because it degenerates in a sort of gaussian bell). Equation; // Self found by attempts, it seems really identical to the original // sqrt4(k) = sqrt(sqrt(k)) R = sqrt(x*x+y*y) DE = sqrt4(sqr(R1 + z*R + Rmul*R) + z*z) - R2 DE = min (DE, cyl(x,y,z, 3 * R2) ) Luca GN 2012 | dIFS Shapes |

logspIFS | Logarithmic spiral. Probably the most elegant of all. Enable pre-mobius to apply a mobius transform on x-y plane before calculating the spiral; this shows an Escher double-poled spiral. Variations use different funtions of r (not only log). DE version; r0 = sqrt(x*x + y*y) theta = atan2(y,x)/twopi r= ln(r0)-theta // variations; try 1/r0, -sqr(ln(r0)), recip(ln(r0)) r = roundint(r) Luca GN 2013 | dIFS Shapes |

LoHexCIFS | Lo-res cone/cylinder (hexagonal pixels). See LoResIFS for info/credits. NOTES: Some values for ConicAng may create infinitely wide shapes. This formula when iterated can be slower than sphere & torus due to technical reasons. Luca GN 2016 | dIFS Shapes |

LoHexIFS | Lo-res sphere using "hexagonal pixels". Based on an idea by Aexion, but smoothed out to get a perfect DE. The original post by Aexion was; x*=0.6;//scaling.. don't ask.. x*=Resolution; y*=Resolution; z*=Resolution; y=floor(y); //converts (x,z) to (r,q) const double temp = floor(x + z); const double r = floor((floor(z - x) + temp) / 3.0); const double q = floor((floor(2 * x + 1) + temp) / 3.0) - r; x = 3.0/2.0 * r; //turns back, r q to x z z = sqrt(3.0) * (q + r/2.0); x/=Resolution; y/=Resolution; z/=Resolution; Instead of normal floor(), use the function described in LoResIFS, to have a smoothed pixel look and a continuous DE. The formula is complex and approximated but looks nice if resolution is reasonably high. Luca GN 2016 | dIFS Shapes |

LoHexTIFS | Lo-res sphere/torus (hexagonal pixels). See LoResIFS for info/credits. Luca GN 2016 | dIFS Shapes |

LoResCIFS | Lo-res cone/cylinder. See LoResIFS for info/credits. NOTES: Some values for ConicAng may create infinitely wide shapes. This formula when iterated can be slower than sphere & torus due to technical reasons. Luca GN 2016 | dIFS Shapes |

LoResIFS | Lo-res sphere. Based on an idea by Aexion, but smoothed out to get a perfect DE. Used those coordinates, instead of x,y,z to do the calculation of DE = sqrt(x^2+y^2+z^2)-1; x=round2(x) round2(x) { x = Res*x // smooth mode normal: t = roundint(x) return (16*(x-t)^5)/Res // smooth mode old: t = roundint(x) + 0.5 return ((x-t)^8)/Res } Luca GN 2016 | dIFS Shapes |

LoResTIFS | Lo-res sphere/torus. See LoResIFS for info/credits. Luca GN 2016 | dIFS Shapes |

loxodrome2IFS | Mix between "loxodrome" and "quadrics" to get new cool shapes (like the cylinder) in a "loxodromic" fashion. You can still get the "normal" loxodrome playing with the params. Styles are another twist to the appearance. Try -1! Again, inspired by the Incendia baseshapes. Luca GN 2012 | dIFS Shapes |

loxodromeIFS | Modified version of "slice" to get a "loxodrome-like" shape. Note that at the poles the shape is less clear (they are singularities). A series of very similar shapes are illustrated in Escher's woodcuts "Sphere Surface with Fish" and "Sphere Spirals". Also this is an Incendia baseshape. Use a low raystep or it will look crappy! Updated with colors. Luca GN 2012 | dIFS Shapes |

MitreIFS | Simple finite quartic surface. Added rotation and customizers Equation; x2Rmul * x*x * (x*x + y*y + z*z) - y*y *( YZadd - y*y + z*z ) = 0 Luca GN 2012 | dIFS Shapes |

NewFoldCutIFS | Loosely inspired by a Knighty script, and by a sculpture seen in a Flickr album. Generates "cubic spirals" of various kinds. Moving adds/offsets results in different asymmetric shapes of various kinds. You can get a different type of intersection using a pos/negative "iterscale". To apply scale+add, USE 0 on the slider. (Unlike all other DIFS). The shapes generated in further iterations will be simple copies of the base, scaled + rotated. To apply scale+add, applying a complex effect to the iterated shapes, USE 1 on the slider. The shapes generated in further iterations will be more and more intricate. LucaGN 2015 | dIFS Shapes |

NewMenger2IFS | Fractal formula by Twinbee and Knighty, modified by me: d1=min(rag(pp.x,pp.z)-pp.y*offz-pp.y2*offy-offx, (... the same goes for other axis) A Menger with cylindrical holes! It has an unusual form, so it cannot be expressed in a "normal" way, (for hybrids with other IFS / escapetime formulas) but it's possible to implement it as a DIFS shape. Very unique shapes are generated! Luca GN 2012 | dIFS Shapes |

NewMengerIFS | Fractal formula by Twinbee and Knighty. It has an unusual form, so it cannot be expressed in a "normal" way, (for hybrids with other IFS / escapetime formulas) but it's possible to implement it as a DIFS shape. Very unique shapes are generated! Luca GN 2012 | dIFS Shapes |

PenN-gonIFS | Variation of the torus. This can generate shapes that rensemble the famous "Penrose triangle". Set mobius=0 to disable the mobius effect. Luca GN 2012 | dIFS Shapes |

PiriformIFS | A family of simple but very elegant revolution surfaces. The origin is a singularity if r1=r2=0. In normal piriform it is "infinitely sharp". A base algorithm; #define sqrt0(a) ((a<0) ? 0 : sqrt(a)) // flip x,z and x = -x u = IntPow(x,curvetype); // try 2,3,4 DE = sqrt0(u*x + y*y + z*z + r1) - sqrt0(u + r2); // some variants are infinitely extended. To optionally "fix" this, use a limiter for x. if (limit > 0) { DE = min (DE, abs(x) - limit); } Luca GN 2012 | dIFS Shapes |

PolyPyraIFS | Powerful generator of pyramid/polygonal shapes. Using the Navi real-time preview mode is a must with this. * Truncated pyramids; - Set a positive "Cuts fix" value, and the pyramid will be truncated. * Stars; - Set a positive "Star" value, and the pyramid will look like a star in the default view. (click on 'reset' button to see the effect). *** Special modes *** * To get cones (not pyramids); - Use a big value as PolyFold Order. I know it's approximeted... but it's good enough * You can use cylinderIFS with "tip" to get the exact solid. * To get extruded polyhedrons (not pyramids); - Use a xz angle like 90.1 - Not just 90. I know it's approximeted... but it's good enough - Set "Initial z add" to a big negative value (-200 or something) - Go to Navigator and adjust visually other parameters to get a good solid * To get cylinders (not pyramids); - Combine the previous techniques 😉 * You can use cylinderIFS to get the exact solid. ------- UPDATED WITH TRAPCOLORS! ------- Works fine except sides (that should color each side with a different color) buggy for some orders. Definitely not a big issue imho! Luca GN 2012 | dIFS Shapes |

PsphereIFS | Pretty 3D "surface" generated from the implicit expression of the tractrix. Similar to QCylinder. It is infinitely extended but for this purpose I limited it to the most interesting part... x = sqrt ( y*y + x*x ) m = sqrt ( a*a + x*x ) n = sqrt min (( a*a - x*x ) , 0) // avoids math errors DE = z - (a ln (( a + n ) / x) - n) // more or less... + some additional juggling and a defix // I multiplied by ( R+0.5)*0.3 in the end to fix DE // basic formula is copied from; http://it.wikipedia.org/wiki/Trattrice_(geometria) thanks a lot Luca GN 2012 | dIFS Shapes |

pyramIFS | Pyramid based on Quadray coords plus some funny shape mangling. You can get bird-like shapes playing with the twist factor. The pinch can morph the solid into a ninja-star. Luca GN 2012 | dIFS Shapes |

QcylIFS | A quartic curve modified. The pinnacle can cause some DE trouble, decrease raystep/stepwidth or the limiter. Luca GN 2012 | dIFS Shapes |

QuadricsIFS | A tool for the real quadrics of revolution. They are cut with a box scissor. Enable "half cut" for a different cut style. Luca GN 2012 | dIFS Shapes |

RandCubesIFS | Simple DIFS formula that (using pseudorandom numbers) generates an uniform pattern of cubes on XY plane. Vtn values near to zero may be a little noisy on edges due to some simplifications I made. Two different kinds of shapes can be gnerated at the same time! You can choose different shape variations if you change Shape types; 0 = Rectangular prisms 1 = Cones (or cylinders) 2 = Spheres (or cylinders) 3 = Pyramids (in this case you can use Vtn > 1 for less sharp solids) 4 = Solid arcs 5 = Tubey arcs 6 = Rounded square prisms Luca GN 2012 | dIFS Shapes |

RiemSqrtIFS | This plots the solid limited by the "Riemann square root surface" and the unit cube (no z limits though). Idea came from this image; http://en.wikipedia.org/wiki/File:Riemann_surface_sqrt.jpg After some reading, I came up with this implicit expression; z +- sqrt(sqrt(x2 + y2)) * abs(cos(0.5*atan2(y,x))) = 0 Added also three extra modifiers just for fun 🙂 Luca GN 2012 | dIFS Shapes |

roomclrIFS | An empty room, it's interesting because it has three selectable colors for the walls. Pinch/Punch makes the room look "spherical" if desired. Of course it's suitable to be used as a 'scenario' , not for iterations. Enable Color2 on choice to see colored DIFS! | dIFS Shapes |

RoomDoorsIFS | Tried to make a very flexible tool for generating "realistic" rooms, hope it helps. - WofWall; If positive, there will be no roof, else there will be one. This is the thickness of walls / 2, and the thickness of the roof itself. - HofWall; Using z as a fixed reference, this will be the total height of the room. - HofDoor, total height of each door, IF ArcR is left at its default value (positive & near to 0). - Door,Wall pos; Will also modify x and y values if PFOrder > 0. PForder works as normal "Apply scale + add" but also changes room's shape of course. - WofDoor; Make the doors bigger/smaller. - Wall rho; Useful to create pyramids or strange walls. - DS rho; Makes the doors trapezoidal. - Door period; Instead of a door for each wall, you can see a door for each x walls, 0 to disable. Can have odd effects. - ArcR; Has nice effects depending on its value compared to WoD; - if AR < 0, the arc will be acute. Bigger R = more acute = higher arc. - if AR = 0, the arc will be round. - if AR < WoD, the arc will be composite (except if AR <= 0). - if AR = WoD, the arc will be round. - if AR > WoD, the arc will be depressed. Bigger R = higher arc. - OTrapRoof; You can choose a different color for the roof (useful for some effects in OT mode). Disable with neg values. Luca GN 2012 | dIFS Shapes |

RoundedBox | Rounded box shape dIFS with OTrap coloring options: 0: Change with DEstop 1: Change with X 2: Change with Y 3: Change with Z DEstop might vary on distance, choose scale = 0 to switch off. You have to choose the 2nd coloring choice with orbit trap to see these changes. | dIFS Shapes |

ScarabIFS | Revolution surface of the Scarabaeus sextic curve; (x2 + y2) (x2 + y2 + R1 x)^2 - R2^2 (x2 - y2)^2 = 0 Looks more like a bell to me. Source; Shikin, E. V. Handbook and Atlas of Curves Luca GN 2012 | dIFS Shapes |

ScherkFS | Scherk's minimal surface (or at least, looks like it). Due to this odd shape, the normals are not well defined everywhere especially for high multiplier values, so keep them in a reasonable range, or you will be forced to use very low raysteps! I used this parametrization, don't know if it's really correct; With logq = log in a given base DE = z - strength* logq ( cos ( y ) / cos ( x ) ) Luca GN 2012 | dIFS Shapes |

ScherkIFS | An enhanced version of the famous Scherk's minimal surface, that is defined, in its classic version, by the simple and elegant implicit equation in terms of cartesian x,y,z; sin(z) = sinh(x)sinh(y) This surface can be seamlessly "tiled" if you replace x with k*sin(x), and y with k*sin(y) with a k > 0.5 for a best effect. (I am pretty sure the surface isn't minimal anymore, but it still looks very elegant). Lots of beautiful variations can be visualized with other coordinate transforms on x,y,z (like toroidal), and you can see some examining the site https://wewanttolearn.wordpress.com/2015/11/11/scherks-minimal-surface/ // ---------------------------------------------------------------- To get a linearized, continuous DE you may try this algorithm; float ScherkDe(float x, float y, float z) // (by Luca GN 2016) { float Ex=exp(x); float Ey=exp(y); float zz=Ex*Ey; float N = Ex*Ex+Ey*Ey; float D = 1+zz*zz; zz = 4.*sin(z)*zz; // can be + or - or change 4 to get elliptic holes if (zz>0) N += zz else D -= zz; // we bring it to the correct eq side 🙂 return .5*(abs(log(N/D))-.05); // give it a little thickness so it renders better } | dIFS Shapes |

schwartzIFS | Derived from the examples of K3DSurf, "BlobySchwartz" surface. Can generate a variety of blobby shapes. Increase the multiplier will add complexity to the shape... Please note that this formula is enough slow due to cos() functions. DE = -(x*x + y*y + z*z) - D + (cos(m*x) + cos(m*y) + cos(m*z)) Luca GN 2012 | dIFS Shapes |

Seashell | dIFS shape that should look like a seashell. | dIFS Shapes |

sliceExIFS | Funny tool that generates sliced spheres. EX version (with z-Swirl for "linear" spirals, and controls for "spherical checkerboards"). Luca GN 2012 | dIFS Shapes |

sliceIFS | Funny tool that generates sliced spheres. Basic version (with the minimal amount of extra options for more speed). Luca GN 2012 | dIFS Shapes |

SphCageIFS | Draws a cage of toruses, they are of two different styles like in "world maps"; Torus style 1; All equal toruses (meridians) Torus style 2; Different radius toruses (parallels) - forced to stay in interval 2 ... 1000 The effect is very accurate, unfortunately parallels tend to slow down the formula for high orders, so be careful. Meridians are fast for all orders, because I use polyfold to get them. Luca GN 2012 | dIFS Shapes |

SphereHeightMap | A spherical displacement map with color option on orbit trap (2nd color choice). You can choose a RGB channel of the Map (0=R,1=G,2=B) for the radial displacement and another channel for OTrap coloring. | dIFS Shapes |

SphereHMVoid | Luca hack mar 2015: Works exactly as SphereHeightMap but it's only a very thin "surface", useful for some experiments like putting stuff inside 😉 Use a LOW raystep, or the object will not be shown correctly. Jesse original comment: A spherical displacement map with color option on orbit trap (2nd color choice). You can choose a RGB channel of the Map (0=R,1=G,2=B) for the radial displacement and another channel for OTrap coloring. | dIFS Shapes |

SphereIFS | Sphere dIFS with OTrap coloring options: 0: Change with DEstop 1: Change with X 2: Change with Y 3: Change with Z DEstop might vary on distance, choose OTrap_scale = 0 to switch off. Choose Inside radius a little lower than Radius to make a hollow sphere for transparent or inside rendering. | dIFS Shapes |

teapot | An isosurface that resembles a teapot. You can obtain it using this code; // Teapot lame isosurface code is released under CC BY-SA 3.0 // Original release 13-11-2016 by DarkBeam at Fractalforums // all variables must be declared, and set to 0 // (except x,y,z) at the beginning and must be public // but I suggest to merge everything in an unique routine DE { DEt = teabody(); if (DEt >1.8) return DEt; // speedup DEx = min(spout,handle); DEx = max(DEx,-teahole); DEt = min(DEx,DEt); // you might use a smooth min() here return max(DEt,-spouthole); } teabody { // Just some circles stitched together (more or less 😛 ) r = x*x+y*y; r = sqrt(r); cut0=z-1.8; if (cut0>0.0) { xtp=r-.6145898; return sqrt(cut0*cut0+r*r)-.015; } else { cut2=2*r-z-0.1; cut2=max(cut2,-z+.8); if (cut2>0) { xtp=-r+.45; xtp=0.5*(xtp-abs(xtp)); ztp=cut0+1.; xtp=xtp*xtp; ztp=ztp*ztp; w=sqrt(xtp+ztp)-.782623792; }else { xtp=r-0.95;ztp=cut0; xtp=xtp*xtp; ztp=ztp*ztp; w=sqrt(xtp+ztp)-.3354102; } teahole=w; return abs(w)-.015; } } spout { xtp = x-.94; ztp=z-.7; v = .707106 (xtp+ztp); u = .707106 (xtp-ztp); // v*v causes DE trouble but not in this small interval // else modify the v multipliers t = sqrt(u*u+y*y*1.6)-.3+.311*v-.12*(v*v); t = max (t,abs(v-.7)-.7 ); spouthole = t; t = abs(t-.015)-.015); t = max (t,z-1.5 ); return t; } handle { cut0=z-1.21; if (cut0>0.0) { xtp=x+1.11; xtp=xtp*xtp; ztp=cut1*cut1; w=sqrt(xtp+ztp)-.3354102; } else { xtp=x+0.6; xtp=xtp*xtp; ztp=cut1*cut1; w=sqrt(xtp+ztp)-.9454102; } return sqrt(w*w+y*y)-.1; } | dIFS Shapes |

tetratubeIFS | Of course this formula is inspired by the awesome work of Knighty. Those scripts are a lot more customizable, but forgive me... A tetrahedral shape based on a plain cylinder DE, after a foldingTetraFull and a rotation on XZ plane. Nice variations can be seen for different angles and values! | dIFS Shapes |

TorusEllipIFS | Cute variations of the torus. Looks like a moon. Found on italian Wikipedia (thanks!) Be careful with "Elliptic", you may get an infinitely big object! Luca GN 2012 | dIFS Shapes |

TorusHMVoid | Luca hack mar 2015: Works exactly as CylinderHeightMap, but wraps around a torus and for some values of radiuses it's also empty inside! Jesse original comment: A displacement map on a cylinder with color option on orbit trap (2nd color choice). You can choose a RGB channel of the Map (0=R,1=G,2=B) for the displacement and another channel for OTrap coloring. | dIFS Shapes |

TorusIFS | Cute variations of the torus. Added colors! Luca GN 2012 | dIFS Shapes |

toupieIFS | Toupie is an isosurface defined as follows; DE = sqrt4(x*x + y*y) - (zsub - abs(z)) Luca GN 2012 | dIFS Shapes |

trifoliumIFS | 3D solid inspired from the trifolium curve. Negative petal fix will show a "negative flower". Equation; (x^2 + y^2)^2 + abs(b z^3) = a x (x^2 - 3 y^2) Luca GN 2012 | dIFS Shapes |

tritgrid2IFS | Iso-surface made of a triangular grid of tubes. This formula was discovered by accident fiddling with tritgrid, the pattern is pretty so I left it as a bonus formula. Luca GN 2012 | dIFS Shapes |

tritgridIFS | Iso-surface made of a triangular grid of tubes. a = abs(styl-x - int(styl-x)); x = x/2; y = y * sqrt(3)/2; b = abs(x+y - int(x+y)); c = abs(x-y - int(x-y)); DE = sqrt(sqr(min(a,b,c)) + sqr(z)) - tuberad; Luca GN 2012 | dIFS Shapes |

UmbrellaIFS | A cubic curve modified, its basic equation is very simple; y*z*z - x*x = 0 (Whytney's umbrella) The center and the x axis are singularities for that surface. Looks like a modern sculpture. Luca GN 2012 | dIFS Shapes |

waveIFS | No “i” data | dIFS Shapes |

wavespIFS | Generalized "spiral heightfield". You can choose any R exponent to get different spirals; Exponent < 0 -> Whorls (spirals infinitely tight in the center) 0 ... 0.5 -> spirals that fade out in the distance 0.5 -> a "normal" spiral - every spire is at a fixed distance 0.5 + -> Spirals that get tighter when distance grows Enable the last switch to see a logarithmic spiral (visually it is very appealing) Equation; (rho,theta) = tocylindrical(x,y) // actually I don't take square root of rho for speed reasons DE = z - abs(sin(pow(rho,exponent) + N * theta)) Luca GN 2012 | dIFS Shapes |

WeirdCubeIFS | Surface called "Weird cube". Looks nicer with rotation (-60; 210; 0) Similar to Cayley surface but prettier imo. Added rotation and a customizer... Equation (from MathWorld) ; 25*(x^3*(y+z)+y^3*(x+z)+z^3*(x+y))+50*(x^2*y^2+x^2*z^2+ y^2*z^2)-125*(x^2*y*z+y^2*x*z+z^2*x*y)+60*x*y*z-4*(x*y+ x*z+y*z)=0 (Intersected with a sphere... it's infinite) Luca GN 2012 | dIFS Shapes |

YinYangIFS | The symbol of Tao, made with toruses and spheres. Added too rotations. Luca GN 2012 | dIFS Shapes |

amazingIFS | Based on Amazing Box formula (and Kali's tweaks), adapted for dIFS. Seven iters are enough to get very detailed images. EDIT; DE fix + added a replacement for MinR (don't ask me why or how but it seems to work) Luca GN 2012 | dIFS Transformations |

Apollo2D-IFS | INSTRUCTIONS; Flexible and powerful formula for hyperbolic apollonian fractals. Zoom out to see more details! --- Additional info; Changed polyfolding code; now you can use Z rotation WITHOUT adding discontinuity. The effect is 100% perfect for even orders, and has a minimal discontinuity for odd orders. Luca GN 2012 Jesse: some asm optimizations, 11.2.2012 | dIFS Transformations |

Apollo3D-IFS | INSTRUCTIONS; Attempt to extend the Apollonian fractal to 3D; the shapes will generate "volcanos" when they get closer to critical points! Be careful with the coefficients, because only a subset of parameters work with this variant. Also volcanoes can be noisy... And remember to keep scale=1 on all shapes with "apply scale" enabled. Also to make the volcanoes look better use a Z add on the 1st shape with "apply scale" enabled ( like 0.03 ) and adjust zmul (higher decreases the noise). ------------- edit; DE fixed (thanks Jesse) + Formula modified ("volcano" formula and cleanup) Luca GN 2012 | dIFS Transformations |

ApolloTetraIFS | Inspired by Jotero works, and Knighty's folds. | dIFS Transformations |

cayley2IFS | Modified inverse Cayley transformation. Similar to a Julia-Newton transform in 2D. Try to change Rotation Z ( example; -142 with the default parameters). Disable always "apply Scale+add" and adjust sizes on ALL the shapes or the transform will have a bad result! Also try different sizes for each shape if the fractal structure is not well visible. Formula (from an Ultra Fractal transform made by Javier López Peña, August 2002) Translate(x,y,z); Rotate(x,y,z); m = 2*((x*y)^2) + x^4 + y^4; Cayley2_2D(x,y) = (m - 1, 2(y*y - x*x) ) / ( m + 4*x*y + 1); ------------- edit; DE fixed (thanks Jesse) Luca GN 2012 | dIFS Transformations |

FernTransform | Use for example with CylinderIFS [0.03,2,1,0,0,0,0,0,0] as first formula. | dIFS Transformations |

foldinghexIFS | Hexagonal continuous tiling of x,y plane. Code by Knighty, a bit modified by me. Luca GN 2012 | dIFS Transformations |

foldinginfyIFS | Continuous tiling of 3D space. Similar to plain "tiling" but without cuts. Very interesting effects when combined with rotations. When a fold is 0 it is never executed. Do not enable both folds in iterate transforms or the entire space will be densely filled (just two at once is fine) | dIFS Transformations |

foldingoctIFS | Based on _foldingoct. Adapted for dIFS mode. 2015 UPDATE: Added more control; to work as before, set 3 to enable and 2 to disable. Settings 0,1 are more advanced, to disable internal diagonal folds, helps to get interesting effects! Luca GN 2015 | dIFS Transformations |

invcylIFS | Inverse cylindrical coords, very easy transform Formula by Luca GN 2016 x' = x cos(y) y' = x sin(y) (z coordinate is unchanged) | dIFS Transformations |

loresmodeIFS | A cool 3D transform suggested by Aexion, to give an illusion of a pixelated mode, use as pretransform to see strange effects on DIFS shapes. Be careful; it will disturb DE at times. LucaGN & Aexion 2016 | dIFS Transformations |

Menger1-IFS | Description: 'Hack' of MengerIFS, partly rewritten to fit the requirements of DIFS. Disable Apply scale+add on all shapes to make it work just like the 'normal' formula. | dIFS Transformations |

murl | Description: This is an attempt to replicate Zueuk's awesome "murl" Apophyisis plugin. The result is not continuous, if the fractal is not symmetrical! I do not know if it is really so useful, by the way it gives interesting effects in my tests. Use as a pretransform on symmetrical fractals. ONLY as pretransform, do not iterate it. Be warned, murl projects the unit circle into the whole plane. And it is slightly slow because the calculations work for any symmetry order. So use it properly! Zueuk said to me that the formula for second order murl is: Tanh(Asinh(a+ib)/2.) That can be simplified, giving us; murl2(a+ib) = (a+ib)/(1.+(1.+(a+ib)^2)^(1/2)) So to get generalized murl I used the formula; murl(a+ib,N) = (a+ib)/(1.+(1.+(a+ib)^N)^(1/N)) where a and b are the cartesian coords of x,y. It is not the "correct" one but it gives cool effects. | dIFS Transformations |

murl2_fast | Description: This is an attempt to replicate Zueuk's awesome "murl" Apophyisis plugin. The result is not continuous, if the fractal is not symmetrical! I do not know if it is really so useful, by the way it gives interesting effects in my tests. Use as a pretransform on symmetrical fractals. ONLY as pretransform, do not iterate it. Be warned, murl projects the unit circle into the whole plane. This optimized version has no parameters whatsoever, and supposes that order is two. It is a lot faster than the general version So use it properly! | dIFS Transformations |

PolyFoldExIFS | Poly fold Ex is a discontinue function; 3D extension of Poly Folding in 3D, as it affects z too. You can get strange Sierpinski solids with this. Remember; Do not change the fixer or you get a discontinue transform, with branch cuts. | dIFS Transformations |

PolyFoldEx-symIFS | Poly fold Ex is a 3D extension of Poly Folding (sym) in 3D, as it affects z too. You can get strange Sierpinski solids with this. Remember; Do not change the fixers or you get a discontinue transform, with branch cuts. | dIFS Transformations |

PolyFoldIFS | Poly fold is a discontinue function. It reflects objects belonging to a quadrant to all other quadrants. You can get Sierpinski and Barnsley style fractals with this, if you can handle it. Try to put it as 1st transform... | dIFS Transformations |

PolyFold-symIFS | Poly fold reflects objects belonging to a quadrant to all other quadrants. The "sym" means that it is a "symmetrized" version of normal polyfold; You can use "Add Y" without adding discontinuity! This is done using a "reflection cheat" on even/odd quadrants, it works perfectly for even orders and fairly good for odd ones. You can get Sierpinski and Barnsley style fractals with this. Try to put it as 1st transform... | dIFS Transformations |

tilingbrick2IFS | Different style of tiling, with an "inclination" that makes the patterns more interesting. Luca GN 2012 | dIFS Transformations |

tilingbrickIFS | Different style of tiling, that creates rhombic/hexagonal patterns if iterated. ------------- edit; Speedup / cleanup Luca GN 2012 | dIFS Transformations |

TilingIFS | A tiling transform to spread objects along the x and y axis, or along the z and y axis if the last parameter is set to 1. Use the first 3 parameters to shift the objects. Use the size and T parameters to adjust the object in the tile. | dIFS Transformations |

totoricalIFS | Description: Torical (generalized) coords for DIFS. Useful as pretransform! This coordinate system was defined by BradC in FractalForums: http://www.fractalforums.com/theory/toroidal-coordinates/msg9428/#msg9428 Included an useful foldinginfy to angles, makes easy to wrap shapes on the torus. Formula by Luca GN 2011 | dIFS Transformations |

transform2IFS | "Inverse" of transform. Does everything in reversed order, because normal transform adds, rotates, does abs while this does abs at first, then rotates and finally adds. Useful for some shape transforms at low iters. | dIFS Transformations |

transformIFS | No “i” info | dIFS Transformations |

Trans-KochIFS | Poly fold reflects objects belonging to a quadrant to all other quadrants. The "sym" means that it is a "symmetrized" version of normal polyfold; You can use "Add Y" without adding discontinuity! This is done using a "reflection cheat" on even/odd quadrants, it works perfectly for even orders and fairly good for odd ones. You can get Sierpinski and Barnsley style fractals with this. Try to put it as 1st transform... | dIFS Transformations |

transLogSpIFS | INSTRUCTIONS; Transform inspired by a formula by Knighty. Warning! It may deform a lot. Use a lower raystep! | dIFS Transformations |

trans-qIFS | Non-conformal quadratic transformation of x and y (plus z if there is a rotation). Similar to a folding but it's quite different when quadratic term is not = 1! x = 1 - abs(x); y = 1 - abs(y); a1 = quadr_x - 1; b1 = 1 - a1; a2 = quadr_y - 1; b2 = 1 - a2; if (x > 0) { x = a1 * x * x + b1 * x; } // x = 0 -> newx = 0 and x = 1 -> newx = 1 if (y > 0) { y = a2 * y * y + b2 * y; } // y = 0 -> newy = 0 and y = 1 -> newy = 1 | dIFS Transformations |

#### Need a Good Place to Start?

**Over the years I have shared and collected parameters on Deviant Art. If you would like to use some of them as a starting point then click the “My Parameters” button where you will find over 600 hundred of images to choose from. **

**There is also a button to a huge collection of more than 5000 parameters from other artist there also. I just ask that you give the proper credit when tweaking any art!**