#info Mandelbulb Distance Estimator
#define providesInit
#include "DE-Raytracer-v0.9.1.frag"
#include "MathUtils.frag"
#group Mandelbulb

// Number of fractal iterations.
uniform int Iterations;  slider[0,9,100]

// Number of color iterations.
uniform int ColorIterations;  slider[0,9,100]

// Mandelbulb exponent (8 is standard)
uniform float Power; slider[0,8,16]

// Bailout radius
uniform float Bailout; slider[0,5,30]

// Alternate is slightly different, but looks more like a Mandelbrot for Power=2
uniform bool AlternateVersion; checkbox[false]

uniform vec3 RotVector; slider[(0,0,0),(1,1,1),(1,1,1)]

uniform float RotAngle; slider[0.00,0,180]

mat3 rot;
uniform float time;
void init() {
   rot = rotationMatrix3(normalize(RotVector), RotAngle);
        float dummy = time*10.0;
}

// This is my power function, based on the standard spherical coordinates as defined here:
// http://en.wikipedia.org/wiki/Spherical_coordinate_system
//
// It seems to be similar to the one Quilez uses:
// http://www.iquilezles.org/www/articles/mandelbulb/mandelbulb.htm
//
// Notice the north and south poles are different here.
void powN1(inout vec3 z, float r, inout float dr) {
  // extract polar coordinates
  float theta = acos(z.z/r);
  float phi = atan(z.y,z.x);
  dr =  pow( r, Power-1.0)*Power*dr + 1.0;
   
  // scale and rotate the point
  float zr = pow( r,Power);
  theta = theta*Power;
  phi = phi*Power;
   
  // convert back to cartesian coordinates
  z = zr*vec3(sin(theta)*cos(phi), sin(phi)*sin(theta), cos(theta));
}

// This is a power function taken from the implementation by Enforcer:
// http://www.fractalforums.com/mandelbulb-implementation/realtime-renderingoptimisations/
//
// I cannot follow its derivation from spherical coordinates,
// but it does give a nice mandelbrot like object for Power=2
void powN2(inout vec3 z, float zr0, inout float dr) {
  float zo0 = asin( z.z/zr0 );
  float zi0 = atan( z.y,z.x );
  float zr = pow( zr0, Power-1.0 );
  float zo = zo0 * Power;
  float zi = zi0 * Power;
  dr = zr*dr*Power + 1.0;
  zr *= zr0;
  z  = zr*vec3( cos(zo)*cos(zi), cos(zo)*sin(zi), sin(zo) );
}

uniform bool Julia; checkbox[false]
uniform vec3 JuliaC; slider[(-2,-2,-2),(0,0,0),(2,2,2)]

// Compute the distance from `pos` to the Mandelbox.
float DE(vec3 pos) {
  vec3 z=pos;
  float r;
  float dr=1.0;
  int i=0;
  r=length(z);
  while(r<Bailout && (i<Iterations)) {
   if (AlternateVersion) {
    powN2(z,r,dr);
   } else {
    powN1(z,r,dr);
   }
   z+=(Julia ? JuliaC : pos);
   r=length(z);
   z*=rot;
   if (i<ColorIterations) orbitTrap = min(orbitTrap, abs(vec4(z.x,z.y,z.z,r*r)));
   i++;
  }
//    if ((type==1) && r<Bailout) return 0.0;
  return 0.5*log(r)*r/dr;
  /*
  Use this code for some nice intersections (Power=2)
  float a =  max(0.5*log(r)*r/dr, abs(pos.y));
  float b = 1000;
  if (pos.y>0)  b = 0.5*log(r)*r/dr;
  return min(min(a, b),
   max(0.5*log(r)*r/dr, abs(pos.z)));
  */
}

#preset default
FOV = 0.68488
Eye = -0.0108381,0.497412,0.994005
Target = 5.94307,-3.64808,-4.09466
Detail = -2.95414
DetailAO = -1.6092
FudgeFactor = 1
MaxRaySteps = 747
Dither = 1
NormalBackStep = 1
AO = 0,0,0,0.85185
SpecularExp = 1.887
SpotLight = 1,0,0.917647,1
SpotLightDir = -0.09678,0.58064
CamLight = 0,1,0.74902,2
CamLightMin = 0.75
Glow = 0.537255,0.00392157,1,1
GlowMax = 84
Fog = 0
HardShadow = 0
ShadowSoft = 0
Reflection = 1
BaseColor = 1,0,0
OrbitStrength = 1
X = 0.952941,1,0,0.61616
Y = 0.345098,0.666667,0,0.02912
Z = 0,0.0666667,1,0.67676
R = 0.0784314,1,0.941176,-0.2449
BackgroundColor = 0,0.823529,0.866667
GradientBackground = 1.1905
CycleColors = true
Cycles = 10.2021
EnableFloor = false
FloorNormal = 0,0,0
FloorHeight = 0
FloorColor = 1,1,1
Iterations = 2
ColorIterations = 2
Power = 14.136
Bailout = 5.3466
AlternateVersion = true
RotVector = -0.8,1,1
RotAngle = 127.951
Julia = true
JuliaC = 0.95328,-0.28036,0
AntiAlias = 1
BoundingSphere = 12
Specular = 10
Up = 0.379655,0.170153,0.305594
#endpreset

#info Mandelbulb Distance Estimator
#define providesInit
#include "ColorPalette.frag"
#include "DE-Raytracer.frag"
#include "MathUtils.frag"
#group Mandelbulb

uniform int Iterations;  slider[0,9,100]

uniform float MinRad2;  slider[0,0.25,2.0]
uniform float Scale;  slider[-3.0,1.3,3.0]
uniform vec3 Trans; slider[(-5,-5,-5),(0.5,0.5,0.5),(5,5,5)]

uniform int ColorIterations;  slider[0,9,100]
uniform float Power; slider[0,8,16]
uniform float Bailout; slider[0,5,30]

uniform bool AlternateVersion; checkbox

[false]uniform vec3 RotVector; slider[(0,0,0),(1,1,1),(1,1,1)]

uniform float RotAngle; slider[0.00,0,180]

mat3 rot;
uniform float time;
void init() {
    rot = rotationMatrix3(normalize(RotVector), RotAngle);
         float dummy = time*10.0;
}

void powN1(inout vec3 z, float r, inout float dr) {
   // extract polar coordinates
   float theta = acos(z.z/r);
   float phi = atan(z.y,z.x);
   dr =  pow( r, Power-1.0)*Power*dr + 1.0;
     
   // scale and rotate the point
   float zr = pow( r,Power);
   theta = theta*Power;
   phi = phi*Power;
     
   // convert back to cartesian coordinates
   z = zr*vec3(sin(theta)*cos(phi), sin(phi)*sin(theta), cos(theta));
}

void powN2(inout vec3 z, float zr0, inout float dr) {
   float zo0 = asin( z.z/zr0 );
   float zi0 = atan( z.y,z.x );
   float zr = pow( zr0, Power-1.0 );
   float zo = zo0 * Power;
   float zi = zi0 * Power;
   dr = zr*dr*Power + 1.0;
   zr *= zr0;
   z  = zr*vec3( cos(zo)*cos(zi), cos(zo)*sin(zi), sin(zo) );
}

uniform bool Julia; checkbox
[false]uniform vec3 JuliaC; slider[(-2,-2,-2),(0,0,0),(2,2,2)]

// Compute the distance from `pos` to the Mandelbox.
float DE(vec3 pos) {
   vec3 z=pos;
   float r;
   float dr=1.0;
   int i=0;
   r=length(z);
   while(r<Bailout && (i<Iterations)) {
    if (AlternateVersion) {
     powN2(z,r,dr);
    } else {
     powN1(z,r,dr);
    }
    z+=(Julia ? JuliaC : pos);
    r=length(z);
    z*=rot;
    if (i<ColorIterations) orbitTrap = min(orbitTrap, abs(vec4(z.x,z.y,z.z,r*r)));
    i++;
   }

   return 0.5*log(r)*r/dr;
     
}

float Coloring(vec3 p) {
   float expsmooth=0.0;
   float r1 = 0.0, r2 = 0.0;
   for (int i=0; i<ColorIterations; i++) {
    p*=rot;
    p=abs(p)+Trans;
    r1 = r2;
    r2 = dot(p, p);
    p *= clamp(max(MinRad2/r2, MinRad2), 0.0, 1.0);    
    p = p* Scale/MinRad2 + Julia;
    expsmooth+=exp(-1.0/abs(r1-r2));   
   }
   return expsmooth;
}

#preset New Color
FOV = 0.76422
Eye = -0.00136391,0.411925,-1.1499
Target = -0.0271628,-1.78969,3.81274
EquiRectangular = false
FocalPlane = 0.7065
Aperture = 0.00364
Gamma = 1
ToneMapping = 1
Exposure = 1
Brightness = 1
Contrast = 1
Saturation = 1
GaussianWeight = 1
AntiAliasScale = 2
Detail = -3.40711
DetailAO = -1.7857
FudgeFactor = 0.68224
MaxRaySteps = 522
Dither = 0.51754
NormalBackStep = 1
AO = 0,0,0,0.81481
Specular = 0.02353
SpecularExp = 20
SpecularMax = 10
SpotLight = 1,1,1,0.58824
SpotLightDir = -0.46874,-0.1875
CamLight = 1,1,1,0.26924
CamLightMin = 0
Glow = 1,1,1,0.26027
GlowMax = 151
Fog = 1.25
HardShadow = 0
ShadowSoft = 2
Reflection = 0
DebugSun = false
BaseColor = 1,1,1
OrbitStrength = 0.64384
X = 0.5,0.6,0.6,-0.13132
Y = 1,0.6,0,-0.0707
Z = 0.8,0.78,1,-0.33334
R = 0.4,0.7,1,0.04092
BackgroundColor = 0.266667,0.447059,0.529412
GradientBackground = 0
CycleColors = true
Cycles = 4.20389
EnableFloor = false
FloorNormal = 0,0,1
FloorHeight = 0
FloorColor = 1,1,1
Color1 = 0,0.666667,0
Color2 = 0,0,1
Color3 = 1,0,0
ColorDensity = 0.67949
ColorOffset = 8.961
Iterations = 21
ColorIterations = 81
Power = 11.5349
Bailout = 3.2142
AlternateVersion = true
RotVector = 0.92,1,0.34667
RotAngle = 171.819
Julia = true
JuliaC = 0.93332,0.04444,-0.35556
MinRad2 = 0.93828
Scale = -1.25808
Up = -0.00550623,-0.977125,0.212596
Trans = 1.5217,0.1087,-2.5
#endpreset