Welcome to Fractal Forums

float rand(vec2 co){
	// implementation found at: lumina.sourceforge.net/Tutorials/Noise.html
	return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

bool inside(vec3 z) {
	mat3 rot=rotationMatrix3(normalize(RotVector),RotAngle);	
	int i=0;
	float r;
	while (i<Iterations) {
		z.xy=cMul(z.xy,z.xy);
		z*=rot;
		z+=JuliaC;
		r=length(z);
		i++;
             if ( r>Bailout) {
			return false;
		}
	}
	return true;
}

#define  providesColor
#include "Brute-Raytracer.frag"

vec3 color(vec3 point, vec3 normal) {
  ....
}

Could not create fragment shader: Fragment shader failed to compile with the following errors:
ERROR: 1:315: error(#143) Undeclared identifier hit
ERROR: 1:315: error(#143) Undeclared identifier hitNormal
ERROR: 1:315: error(#202) No matching overloaded function found color
ERROR: 1:315: error(#202) No matching overloaded function found mix
WARNING: 1:315: warning(#402) Implicit truncation of vector from size 1 to size 3. 
ERROR: error(#273) 4 compilation errors.  No code generated

viewCoord.x*= pixelSize.y/pixelSize.x;

void powN2(inout vec3 z, float zr0) {
	float sr23=sqrt(2/3);
	float sr13=sqrt(1/3);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;
	float sx=nx;
	float sr12=sqrt(.5);
	 nx=sx*sr12-z.y*sr12;                 // tried with declaring float again, and not...
	float sy=sx*sr12+z.y*sr12;
	 sx=nx*nx;
	 sy=sy*sy;
	 sz=sz*sz;
	float r=sx+sy+sz;
	while (r>0 || r<0) {                                              //not sure of != syntax ???
		 nx=(sx+r)*(9*sx-sy-sz)/(9*sx+sy+sz)-.5;       
		float ny=(sy+r)*(9*sy-sx-sz)/(9*sy+sx+sz)-.5;
		 sz=(sz+r)*(9*sz-sx-sy)/(9*sz+sx+sy)-.5;
	}
	 sx=nx;
	 sy=ny;
	 nx=sx*sr12+sy*sr12;
	 sy=-sx*sr12+sy*sr12;     // can I start out with a - sign??
	 sx=nx;
	nx=sx*sr23+sz*sr13;
	 sz=-sx*sr13+sz*sr23;
	float sx2=sx*sx;
	float sy2=sy*sy;         //  does variable^2 work instead??
	float sz2=sz*sz;
	 nx=sx2-sy2-sz2;
	float r3=2*|sx|/sqrt(sy2+sz2);     
	 nz=r3*(sy2-sz2);
	 ny=r3*2*sy*sz;
	z= vec3(nx,ny,nz);
	

}


bool inside(vec3 pos) {
	vec3 z=pos;
	float r;
	int i=0;
	r=length(z);
	while(r<Bailout && (i<Iterations)) {
		powN2(z,r);
		if (pos.x>0) {                          // can I do this???
			z+=vec3(pos.x*.5,0,0);
		} else {
			z+=vec3(pos.x,0,0);
		}
		
		r=length(z);
		i++;
	}
	return (r<Bailout);
	
}

#define providesInside
#define providesColor

#include "Brute-Raytracer.frag"
#group Mandelbulb
//#define IterationsBetweenRedraws 5

// Number of fractal iterations.
uniform int Iterations;  slider[0,9,100]
// Bailout radius
uniform float Bailout; slider[0,5,30]


vec3 color(vec3 p) {
	return abs(vec3(p));
}
void powN2(inout vec3 z, float zr0) {
	float sr23=sqrt(2./3.);
	float sr13=sqrt(1./3.);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;
	float sx=nx;
	float sr12=sqrt(.5);
	nx=sx*sr12-z.y*sr12;             
	float sy=sx*sr12+z.y*sr12;
	sx=nx*nx;
	sy=sy*sy;
	sz=sz*sz;
	float r=sx+sy+sz;
	while (r>0. || r<0.) {                                       
		nx=(sx+r)*(9.*sx-sy-sz)/(9.*sx+sy+sz)-.5;
		float ny=(sy+r)*(9.*sy-sx-sz)/(9.*sy+sx+sz)-.5;
		sz=(sz+r)*(9.*sz-sx-sy)/(9.*sz+sx+sy)-.5;
	}
	sx=nx;
	sy=ny;
	nx=sx*sr12+sy*sr12;
	sy=-sx*sr12+sy*sr12; 
	sx=nx;
	nx=sx*sr23+sz*sr13;
	sz=-sx*sr13+sz*sr23;
	float sx2=sx*sx;
	float sy2=sy*sy;       
	float sz2=sz*sz;
	nx=sx2-sy2-sz2;
	float r3=2.*abs(sx)/sqrt(sy2+sz2);
	float nz=r3*(sy2-sz2);
 	float ny=r3*2*sy*sz;
	z= vec3(nx,ny,nz);
}


bool inside(vec3 pos) {
	vec3 z=pos;
	float r;
	int i=0;
	r=length(z);
	while(r<Bailout && (i<Iterations)) {
		powN2(z,r);
		if (pos.x>0.) {                          // can I do this???
			z+=vec3(pos.x*.5,0.,0.);
		} else {
			z+=vec3(pos.x,0.,0.);
		}	
		r=length(z);
		i++;
	}
	return (r<Bailout);
}

#info Mandelbulb without Distance Estimator

#define providesInside

#define providesColor

#include "Brute-Raytracer-color.frag"
#group Mandelbulb
//#define IterationsBetweenRedraws 5      // I really need to clean this code up... LATER though...

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

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

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

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

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

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

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

vec3 color(vec3 p) {
	return abs(vec3(p));				// should this point to z?? 
}
void powN2(inout vec3 z, float zr0) {
	float sr23=sqrt(2./3.);
	float sr13=sqrt(1./3.);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;
	float sx=nx;
	float sr12=sqrt(.5);
	nx=sx*sr12-z.y*sr12;             
	float sy=sx*sr12+z.y*sr12;
	sx=nx*nx;
	sy=sy*sy;
	float ny=sy;
	sz=sz*sz;
	float r2=sx+sy+sz;
	if (r2!=0.) {                                       
		nx=(sx+r2)*(9.*sx-sy-sz)/(9.*sx+sy+sz)-.5;
		ny=(sy+r2)*(9.*sy-sx-sz)/(9.*sy+sx+sz)-.5;
		sz=(sz+r2)*(9.*sz-sx-sy)/(9.*sz+sx+sy)-.5;
		
	}
	sx=nx;
	sy=ny;
	nx=sx*sr12+sy*sr12;
	sy=-sx*sr12+sy*sr12; 
	sx=nx;
	nx=sx*sr23+sz*sr13;
	sz=-sx*sr13+sz*sr23;				//some things can be cleaned up
	sx=nx;
	float sx2=sx*sx;
	float sy2=sy*sy;				// will be switching code around later       
	float sz2=sz*sz;
	nx=sx2-sy2-sz2;
	float r3=2.*abs(sx)/sqrt(sy2+sz2);
	float nz=r3*(sy2-sz2);
 	ny=r3*2.*sy*sz;
	z= vec3(nx,ny,nz);
}


bool inside(vec3 pos) {
	vec3 z=pos;
	float r;
	vec4 colortime=vec4(0.,0.,0.,0.);
	int i=0;
	r=length(z);
	orbitTrap=colortime;
	while(r<Bailout && (i<Iterations)) {
		powN2(z,r);
		if (i<ColorIterations) {
			orbitTrap=orbitTrap+vec4(z.x*(z.x),z.y*(z.y),z.z*(z.z),length(z));
		}
		if (pos.x>0.) {                          // can I do this???
			z+=vec3(pos.x*.5,0.,0.);
		} else {
			z+=vec3(pos.x,0.,0.);
		}	
		r=length(z);
		
		i++;
	}
	return (r<Bailout);
}


#preset Default
FOV = 0.62536
Eye = 0.633014,-0.13205,-1.83663
Target = -3.07766,0.866233,6.14854
Up = -0.87195,0.22693,-0.433562
EquiRectangular = false
Gamma = 2.5
ToneMapping = 3
Exposure = 1.34694
Brightness = 1
Contrast = 0.9901
Saturation = 1
GaussianWeight = 1
AntiAliasScale = 0
CamLight = 1,1,1,0.38462
CamLightMin = 0
Fog = 0
BaseColor = 1,1,1
OrbitStrength = 0
X = 1,1,1,1
Y = 0.345098,0.666667,0,0.02912
Z = 1,0.666667,0,1
R = 0.0784314,1,0.941176,-0.0194
BackgroundColor = 0.607843,0.866667,0.560784
GradientBackground = 0.86955
CycleColors = false
Cycles = 1.1
NormalScale = 0.00024
AOScale = 0.00631
Glow = 0.34167
AOStrength = 0.86047
Specular = 0
SpecularExp = 5.455
SpotLight = 1,0.678431,0.494118,0.78431
SpotLightDir = 1,0.78126
Iterations = 4
ColorIterations = 3
Power = 8
Bailout = 12
AlternateVersion = false
RotVector = 1,1,1
RotAngle = 0
Julia = false
JuliaC = 0,0,0
ShowDepth = true
Samples = 100
Near = 0.7368
Far = 2.45904
#endpreset

#define providesColor

vec3 cycle(vec3 c, float s) {
	return vec3(0.5)+0.5*vec3(cos(s*Cycles+c.x),cos(s*Cycles+c.y),cos(s*Cycles+c.z));
}

vec3 color(vec3 p) {
        // We need to call 'inside' again.
	orbitTrap = vec4(10000.0);
	inside(p);
	orbitTrap.w = sqrt(orbitTrap.w);

	vec3 orbitColor;
	if (CycleColors) {
		orbitColor = cycle(X.xyz,orbitTrap.x)*X.w*orbitTrap.x +
		cycle(Y.xyz,orbitTrap.y)*Y.w*orbitTrap.y +
		cycle(Z.xyz,orbitTrap.z)*Z.w*orbitTrap.z +
		cycle(R.xyz,orbitTrap.w)*R.w*orbitTrap.w;
	} else {
		orbitColor = X.xyz*X.w*orbitTrap.x +
		Y.xyz*Y.w*orbitTrap.y +
		Z.xyz*Z.w*orbitTrap.z +
		R.xyz*R.w*orbitTrap.w;
	}
	return orbitColor;	
}

/// inside loop
if (i>ColorIterationsMin && i<ColorIterations) {
	orbitTrap=min(orbitTrap,vec4(z.x*z.x,z.y*z.y,z.z*z.z,dot(z,z)));
}

// Output generated from file: Unnamed
// Created: ti 13. nov 21:32:37 2012

#info Mandelbulb without Distance Estimator

#define providesInside

#define providesColor

#include "Brute-Raytracer.frag"
#group Mandelbulb
//#define IterationsBetweenRedraws 5      // I really need to clean this code up... LATER though...

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

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

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

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

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

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

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

vec3 cycle(vec3 c, float s) {
	return vec3(0.5)+0.5*vec3(cos(s*Cycles+c.x),cos(s*Cycles+c.y),cos(s*Cycles+c.z));
}

vec3 color(vec3 p) {
	orbitTrap = vec4(10000.0);
	inside(p);

	orbitTrap.w = sqrt(orbitTrap.w);
	vec3 orbitColor;
	if (CycleColors) {
		orbitColor = cycle(X.xyz,orbitTrap.x)*X.w*orbitTrap.x +
		cycle(Y.xyz,orbitTrap.y)*Y.w*orbitTrap.y +
		cycle(Z.xyz,orbitTrap.z)*Z.w*orbitTrap.z +
		cycle(R.xyz,orbitTrap.w)*R.w*orbitTrap.w;
	} else {
		orbitColor = X.xyz*X.w*orbitTrap.x +
		Y.xyz*Y.w*orbitTrap.y +
		Z.xyz*Z.w*orbitTrap.z +
		R.xyz*R.w*orbitTrap.w;
	}
	
	//vec3 color = mix(BaseColor, 3.0*orbitColor,  OrbitStrength);
	return orbitColor;
	
}
void powN2(inout vec3 z, float zr0) {
	float sr23=sqrt(2./3.);
	float sr13=sqrt(1./3.);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;
	float sx=nx;
	float sr12=sqrt(.5);
	nx=sx*sr12-z.y*sr12;             
	float sy=sx*sr12+z.y*sr12;
	sx=nx*nx;
	sy=sy*sy;
	float ny=sy;
	sz=sz*sz;
	float r2=sx+sy+sz;
	if (r2!=0.) {                                       
		nx=(sx+r2)*(9.*sx-sy-sz)/(9.*sx+sy+sz)-.5;
		ny=(sy+r2)*(9.*sy-sx-sz)/(9.*sy+sx+sz)-.5;
		sz=(sz+r2)*(9.*sz-sx-sy)/(9.*sz+sx+sy)-.5;
		
	}
	sx=nx;
	sy=ny;
	nx=sx*sr12+sy*sr12;
	sy=-sx*sr12+sy*sr12; 
	sx=nx;
	nx=sx*sr23+sz*sr13;
	sz=-sx*sr13+sz*sr23;				//some things can be cleaned up
	sx=nx;
	float sx2=sx*sx;
	float sy2=sy*sy;				// will be switching code around later       
	float sz2=sz*sz;
	nx=sx2-sy2-sz2;
	float r3=2.*abs(sx)/sqrt(sy2+sz2);
	float nz=r3*(sy2-sz2);
 	ny=r3*2.*sy*sz;
	z= vec3(nx,ny,nz);
}


bool inside(vec3 pos) {
	vec3 z=pos;
	float r;
	int i=0;
	r=length(z);
	while(r<Bailout && (i<Iterations)) {
		powN2(z,r);
		if (i>ColorIterationsMin && i<ColorIterations) {
			orbitTrap=min(orbitTrap,vec4(z.x*z.x,z.y*z.y,z.z*z.z,dot(z,z)));

		}
		if (pos.x>0.) {                          // can I do this???
			z+=vec3(pos.x*.5,0.,0.);
		} else {
			z+=vec3(pos.x,0.,0.);
		}	
		r=length(z);
		
		i++;
	}
	return (r<Bailout);
}




#preset default
FOV = 0.62536
Eye = -2.06349,0.0288363,0.0261386
Target = 6.7978,-0.0399766,-0.0109628
Up = -0.0063931,-0.829538,0.0116395
EquiRectangular = false
Gamma = 2.5
Exposure = 1.34694
Brightness = 1
Contrast = 0.9901
Saturation = 1
SpecularExp = 5.455
SpotLightDir = 0.87654,0.78126
CamLight = 1,1,1,1.13044
CamLightMin = 0
BackgroundColor = 0.666667,0.666667,0.498039
ToneMapping = 3
Near = 0.12372
Far = 2.45904
NormalScale = 0.00024
AOScale = 0.00631
Glow = 0.34167
AOStrength = 0.86047
Samples = 100
Stratify = true
DebugInside = false
SampleNeighbors = true
Specular = 10
SpotLight = 1,0.678431,0.494118,0.78431
Fog = 1.84
ShowDepth = false
DebugNormals = false
BaseColor = 1,1,1
OrbitStrength = 1
X = 1,1,1,0.86408
Y = 0.345098,0.666667,0,1
Z = 1,0.666667,0,1
R = 0.0784314,1,0.941176,0.54902
GradientBackground = 0.76085
CycleColors = false
Cycles = 6.47914
Iterations = 10
ColorIterations = 3
Bailout = 12
Julia = false
JuliaC = 0,0,0
ColorIterationsMin = 1
#endpreset

// Copied and modified from Syntopia's code   
// Created: ~ 10:30 pm 11-13-2012

#info Mandelbulb without Distance Estimator

#define providesInside

#define providesColor

#include "Brute-Raytracer.frag"
#group Mandelbulb
//#define IterationsBetweenRedraws 5      // I really need to clean this code up... LATER though...

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

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

// Mandelbulb exponent (2 is standard)
uniform float manPower; slider[-10,2,10]

//mag exponent  (2 is standard)
uniform float magPower; slider[-10,2,10]

//  Spokes number 
uniform float Spokes; slider[-4,3,20]

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

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

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

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

vec3 cycle(vec3 c, float s) {
	return vec3(0.5)+0.5*vec3(cos(s*Cycles+c.x),cos(s*Cycles+c.y),cos(s*Cycles+c.z));
}

vec3 color(vec3 p) {
	orbitTrap = vec4(1.0);
	inside(p);

	orbitTrap.w = sqrt(orbitTrap.w);
	vec3 orbitColor;
	if (CycleColors) {
		orbitColor = cycle(X.xyz,orbitTrap.x)*X.w*orbitTrap.x +
		cycle(Y.xyz,orbitTrap.y)*Y.w*orbitTrap.y +
		cycle(Z.xyz,orbitTrap.z)*Z.w*orbitTrap.z +
		cycle(R.xyz,orbitTrap.w)*R.w*orbitTrap.w;
	} else {
		orbitColor = X.xyz*X.w*orbitTrap.x +
		Y.xyz*Y.w*orbitTrap.y +
		Z.xyz*Z.w*orbitTrap.z +
		R.xyz*R.w*orbitTrap.w;
	}
	
	//vec3 color = mix(BaseColor, 3.0*orbitColor,  OrbitStrength);
	return orbitColor;
	
}
void powN2(inout vec3 z, in float d) {
	float sr23=sqrt(2./3.);
	float sr13=sqrt(1./3.);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;   // sz rotated
	float sx=nx;
	float sr12=sqrt(.5);
	nx=sx*sr12-z.y*sr12;               //nx
	float sy=sx*sr12+z.y*sr12;  //sy rotated
	sx=nx;

	float rxyz=pow((sx*sx+sy*sy+sz*sz),magPower*.5);

	float r1=sqrt(sy*sy+sz*sz);	
	float victor=atan(r1,abs(sx*d))*magPower;		// Is it faster to use
	nx=(sx*sx+rxyz)*cos(victor)-.5;				// multiple variables 

	r1=sqrt(sx*sx+sz*sz);						// for these to split
	victor=atan(r1,abs(sy*d))*magPower;		// processes???
	float ny=(sy*sy+rxyz)*cos(victor)-.5;

	r1=sqrt(sx*sx+sy*sy);
	victor=atan(r1,abs(sz*d))*magPower;
	sz=(sz*sz+rxyz)*cos(victor)-.5;

	sx=nx;
	sy=ny;

	nx=sx*sr12+sy*sr12;
	sy=-sx*sr12+sy*sr12; 
	sx=nx;
	nx=sx*sr23+sz*sr13;
	sz=-sx*sr13+sz*sr23;				//some things can be cleaned up
	sx=nx;

	rxyz=pow((sx*sx+sy*sy+sz*sz),manPower/2.);
	r1=sqrt(sy*sy+sz*sz);
	victor=atan(r1,sx)*manPower;
	float phi=atan(sz,sy)*manPower;
	sx=rxyz*cos(victor);
	r1=rxyz*sin(victor);
	sz=r1*cos(phi);
	sy=r1*sin(phi);
	z= vec3(sx,sy,sz);
	
}


bool inside(vec3 pos) {
	
		float ryz=sqrt(pos.y*pos.y+pos.z*pos.z);
		float theta=(Spokes)*atan(pos.z,pos.y)/3.;
		vec3 z=vec3(pos.x,ryz*cos(theta),ryz*sin(theta));
	 
	float r;
	int i=0;
	r=length(z);
	float d=magPower*1.5;						// sometimes I make d= magPower +1
	while(r<Bailout && (i<Iterations)) {			//  for a sharper fractal.. we can add a switch
		powN2(z,d);
		if (i>ColorIterationsMin && i<ColorIterations) {
			orbitTrap=min(orbitTrap,vec4(z.x*z.x,z.y*z.y,z.z*z.z,dot(z,z)));

		}
		if (pos.x>0.) {                          // can I do this???
			z+=vec3(pos.x*.5,0.,0.);
		} else {
			z+=vec3(pos.x,0.,0.);
		}	
		r=length(z);
		
		i++;
	}
	return (r<Bailout);
}




#preset default
FOV = 0.62536
Eye = 2.02493,-0.000258894,0.00365772
Target = -0.498369,0.00627817,-0.0886997
Up = -0.0024414,-0.999997,0
EquiRectangular = false
Gamma = 2.5
ToneMapping = 3
Exposure = 1.34694
Brightness = 1
Contrast = 0.9901
Saturation = 1
Near = 0.48984
Far = 2.71704
NormalScale = 0.00024
AOScale = 0.00291
Glow = 0.34167
AOStrength = 0.86047
Samples = 254
Stratify = true
DebugInside = false
SampleNeighbors = true
Specular = 1
SpecularExp = 5.455
SpotLight = 0.027451,0.196078,0.658824,0.89706
SpotLightDir = 0.80246,0.78126
CamLight = 1,1,1,1.44928
CamLightMin = 0.54217
Fog = 1.84
ShowDepth = false
DebugNormals = false
BaseColor = 0.388235,0.388235,0.388235
OrbitStrength = 0.78
X = 0.329412,0.321569,0.364706,0.08738
Y = 0.262745,0.333333,0.282353,0.02912
Z = 0.054902,0.0431373,0.439216,0.1068
R = 0.317647,0.670588,0.690196,0.64706
BackgroundColor = 0.0196078,0.0117647,0.192157
GradientBackground = 1.73915
CycleColors = false
Cycles = 23.1868
Iterations = 6
ColorIterations = 4
Bailout = 12
Julia = false
JuliaC = 0,0,0
ColorIterationsMin = 2
#endpreset

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

// Use Spokes as float
float f = float(Spokes)*2.0;

// Output generated from file: Unnamed
// Created: ti 13. nov 21:32:37 2012

#info Mandelbulb without Distance Estimator

#define providesInside

#define providesColor
#include "MathUtils.frag"
#include "Brute-Raytracer.frag"
#group Fractal
//#define IterationsBetweenRedraws 5      // I really need to clean this code up... LATER though...

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

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

// Mandelbulb exponent (2 is standard)
uniform float manPower; slider[-10,2,10]

//mag exponent  (2 is standard)
uniform float magPower; slider[-10,2,10]

//mag seed  (-.5 is standard)
uniform float magSeed; slider[-6,-.5,6]
//mag Softness
uniform float magSoft; slider[-10,1,100]

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

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

#group Rotation
//  Spokes number 
uniform float Spokes; slider[-4,3,20]

uniform vec3 RotVector1; slider[(0,0,0),(1,1,1),(1,1,1)]
uniform float RotAngle1; slider[-180.00,0,180]

mat3 rot1= rotationMatrix3(normalize(RotVector1), RotAngle1);

uniform vec3 RotVector2; slider[(0,0,0),(1,1,1),(1,1,1)]
uniform float RotAngle2; slider[-180.00,0,180]

mat3 rot2= rotationMatrix3(normalize(RotVector2), RotAngle2);

uniform vec3 RotVector3; slider[(0,0,0),(1,1,1),(1,1,1)]
uniform float RotAngle3; slider[-180.00,0,180]

mat3 rot3= rotationMatrix3(normalize(RotVector3), RotAngle3);


vec3 cycle(vec3 c, float s) {
	return vec3(0.5)+0.5*vec3(cos(s*Cycles+c.x),cos(s*Cycles+c.y),cos(s*Cycles+c.z));
}

vec3 color(vec3 p) {
	orbitTrap = vec4(1.0);
	inside(p);

	orbitTrap.w = sqrt(orbitTrap.w);
	vec3 orbitColor;
	if (CycleColors) {
		orbitColor = cycle(X.xyz,orbitTrap.x)*X.w*orbitTrap.x +
		cycle(Y.xyz,orbitTrap.y)*Y.w*orbitTrap.y +
		cycle(Z.xyz,orbitTrap.z)*Z.w*orbitTrap.z +
		cycle(R.xyz,orbitTrap.w)*R.w*orbitTrap.w;
	} else {
		orbitColor = X.xyz*X.w*orbitTrap.x +
		Y.xyz*Y.w*orbitTrap.y +
		Z.xyz*Z.w*orbitTrap.z +
		R.xyz*R.w*orbitTrap.w;
	}
	
	//vec3 color = mix(BaseColor, 3.0*orbitColor,  OrbitStrength);
	return orbitColor;
	
}
void magpart(inout vec3 z, in float d) {
					// from here until the next section break is the section that can
				 // be blended with other rotation based fractals- and maybe KIFS!

	float sr23=sqrt(2./3.);				
	float sr13=sqrt(1./3.);
	float nx=z.x*sr23-z.z*sr13;
	float sz=z.x*sr13 + z.z*sr23;   // sz rotated
	float sx=nx;
	float sr12=sqrt(.5);
	nx=sx*sr12-z.y*sr12;               //nx
	float sy=sx*sr12+z.y*sr12;  //sy rotated
	sx=nx;
	float ny=sy;
	float r1=0.;
	float rxyz=0.;
	float victor=0.;
	if ((magPower==2.)) {
		sx=nx*nx;
		sy=sy*sy;
	
		sz=sz*sz;
		r1=sx+sy+sz;
		if (r1!=0.) {                                       
			nx=(sx+r1)*(9.*sx-sy-sz)/(9.*sx+sy+sz)+magSeed;	
			ny=(sy+r1)*(9.*sy-sx-sz)/(9.*sy+sx+sz)+magSeed;	
			sz=(sz+r1)*(9.*sz-sx-sy)/(9.*sz+sx+sy)+magSeed;	
		}
	} else if ((magPower==0.)) {
		nx=(abs(sx)+magSeed)*2.;
		ny=(abs(sy)+magSeed)*2.;
		sz=(abs(sz)+magSeed)*2.;
	} else {
		rxyz=pow((sx*sx+sy*sy+sz*sz),(magPower)*.5);

		r1=sqrt(sy*sy+sz*sz);	
		victor=atan(r1,abs(sx*d))*magPower;		
		nx=(sx*sx+rxyz)*cos(victor)+magSeed;				//  The -.5 value is a seed value

		r1=sqrt(sx*sx+sz*sz);						//  you can use different ones
		victor=atan(r1,abs(sy*d))*magPower;		//  but ~ -.5 is the best, and keeping it the same for
		ny=(sy*sy+rxyz)*cos(victor)+magSeed;	//  all 3 variables works the best- but you can vary it between them

		r1=sqrt(sx*sx+sy*sy);
		victor=atan(r1,abs(sz*d))*magPower;
		sz=(sz*sz+rxyz)*cos(victor)+magSeed;	
	}
	vec3 z2=vec3(nx,ny,sz);
	z2*=rot2;
	
	sx=z2.x;
	sy=z2.y;
	sz=z2.z;
	nx=sx*sr12+sy*sr12;
	sy=-sx*sr12+sy*sr12; 
	sx=nx;
	nx=sx*sr23+sz*sr13;
	sz=-sx*sr13+sz*sr23;				//some things can be cleaned up
	sx=nx;
	
							//  Here is the end of the section
							//  the above code can be used with other fractal types

	if ((manPower==2.)) {
		float sx2=sx*sx;
		float sy2=sy*sy;				// will be switching code around later       
		float sz2=sz*sz;
		nx=sx2-sy2-sz2;   //
		r1=2.*(sx)/sqrt(sy2+sz2);  //  you can switch ny and nz... I'll add a boolean later
		float nz=r1*(sy2-sz2);
 		ny=r1*2.*sy*sz;   //
		z= vec3(nx,ny,nz);  
	} else {
		rxyz=pow((sx*sx+sy*sy+sz*sz),abs(manPower)/2.);
		r1=sqrt(sy*sy+sz*sz);
		victor=atan(r1,sx)*manPower;
		float phi=atan(sz,sy)*manPower;
		sx=rxyz*cos(victor);
		r1=rxyz*sin(victor);
		sz=r1*cos(phi);
		sy=r1*sin(phi);
		z= vec3(sx,sy,sz);
	}
}


bool inside(vec3 pos) {
	
	//vec3 z=pos;
		float ryz=sqrt(pos.y*pos.y+pos.z*pos.z);
		float theta=(Spokes)*atan(pos.z,pos.y)/3.;
		vec3 z=vec3(pos.x,ryz*cos(theta),ryz*sin(theta));
	 
	float r;
	int i=0;
	r=length(z);
	float d=magPower+magSoft;
	while(r<Bailout && (i<Iterations)) {
		
			magpart(z,d);
			z*=rot1;
			
		if (i>ColorIterationsMin && i<ColorIterations) {
			orbitTrap=min(orbitTrap,vec4(z.x*z.x,z.y*z.y,z.z*z.z,dot(z,z)));

		}
		if (Julia) {
			z+=JuliaC;	
		} else {
			if (pos.x>0.) {                          // can I do this???
				z+=vec3(pos.x*.5,0.,0.);
			} else {
				z+=vec3(pos.x,0.,0.);
			}
		}	
		r=length(z);
		z*=rot3;
		i++;
	}
	return (r<Bailout);
}




#preset default
FOV = 0.62536
Eye = 2.02493,-0.000258894,0.00365772
Target = -0.498369,0.00627817,-0.0886997
Up = -0.0024414,-0.999997,0
EquiRectangular = false
Gamma = 2.5
ToneMapping = 3
Exposure = 1.34694
Brightness = 1
Contrast = 0.9901
Saturation = 1
Near = 0.48984
Far = 2.71704
NormalScale = 0.00024
AOScale = 0.00291
Glow = 0.34167
AOStrength = 0.86047
Samples = 254
Stratify = true
DebugInside = false
SampleNeighbors = true
Specular = 1
SpecularExp = 5.455
SpotLight = 0.027451,0.196078,0.658824,0.89706
SpotLightDir = 0.80246,0.78126
CamLight = 1,1,1,1.44928
CamLightMin = 0.54217
Fog = 1.84
ShowDepth = false
DebugNormals = false
BaseColor = 0.388235,0.388235,0.388235
OrbitStrength = 0.78
X = 0.329412,0.321569,0.364706,0.08738
Y = 0.262745,0.333333,0.282353,0.02912
Z = 0.054902,0.0431373,0.439216,0.1068
R = 0.317647,0.670588,0.690196,0.64706
BackgroundColor = 0.0196078,0.0117647,0.192157
GradientBackground = 1.73915
CycleColors = false
Cycles = 23.1868
Iterations = 6
ColorIterations = 4
Bailout = 12
Julia = false
JuliaC = 0,0,0
ColorIterationsMin = 2
#endpreset

// Output generated from file: C:/Fractales/Fragmentarium Windows Binary v0.9.12b/Examples/rotajulia3d.frag
// Created: lun 1. oct 01:36:29 2012
#info Mandelbulb without Distance Estimator

#define providesColor
#define providesInside
#include "Brute-Raytracer.frag"

#include "MathUtils.frag"
#include "Complex.frag"

#group Mandelbulb

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

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

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

// Bailout radius
uniform float Bailout; slider[0,5,3000]
uniform float Scale; slider[0,1,2]


// 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),(0,1,0),(1,1,1)]

uniform float RotAngle; slider[0.00,0,180]
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.

mat3 rot;

vec3 cycle(vec3 c, float s) {
	return vec3(0.5)+0.5*vec3(cos(s*Cycles+c.x),cos(s*Cycles+c.y),cos(s*Cycles+c.z));
}

vec3 color(vec3 p) {
	orbitTrap = vec4(10000.0);
	inside(p);

	orbitTrap.w = sqrt(orbitTrap.w);
	vec3 orbitColor;
	if (CycleColors) {
		orbitColor = cycle(X.xyz,orbitTrap.x)*X.w*orbitTrap.x +
		cycle(Y.xyz,orbitTrap.y)*Y.w*orbitTrap.y +
		cycle(Z.xyz,orbitTrap.z)*Z.w*orbitTrap.z +
		cycle(R.xyz,orbitTrap.w)*R.w*orbitTrap.w;
	} else {
		orbitColor = X.xyz*X.w*orbitTrap.x +
		Y.xyz*Y.w*orbitTrap.y +
		Z.xyz*Z.w*orbitTrap.z +
		R.xyz*R.w*orbitTrap.w;
	}
	
	//vec3 color = mix(BaseColor, 3.0*orbitColor,  OrbitStrength);
	return orbitColor;
	
}

bool inside(vec3 pos) {
	vec3 f;
	vec3 z=pos, p,m=vec3(1,1,1);
	vec2 z1,z2;
	float r;
	float dr=1.0;
	int i=0;
	r=length(z);
	//z*=rot;
	rot=rotationMatrix3(normalize(RotVector),RotAngle);	
	vec3 J=JuliaC;
	while (i<Iterations) {
		if (i>ColorIterationsMin && i<ColorIterations) {
			orbitTrap=min(orbitTrap,vec4(z.x*z.x,z.y*z.y,z.z*z.z,dot(z,z)));

		}
		z=vec3(cMul(z.xy,z.xy),z.z);
		z*=rot;
		z*=Scale;
		z+=J;
		r=length(z);
		i++;
             if ( r>Bailout) {
			return false;
		}
	}
	return true;
}

#info Mandelbulb without Distance Estimator

#define providesInside

#include "Brute-Raytracer.frag"
#include "MathUtils.frag"
#include "Complex.frag"

#group RotaBulb

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

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

// Mandelbulb exponent (8 is standard)
uniform float Power; slider[-10,3,10]

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

uniform float theta; slider[0.0,0,180]
uniform float phi; slider[0.0,0,360]

/*
vec3 color(vec3 p) {
	return abs(vec3(p));
}
*/

#define D2R 0.01745329251994329576923690768489

// return what I call the "pole vector"
vec3 PVec()
{
    return vec3(cos(D2R*phi)*sin(D2R*theta), sin(D2R*phi)*sin(D2R*theta), cos(D2R*theta));
}

vec3 QVec()
{
    return vec3(1.0, 0.0, 0.0);
}

vec3 RVec()
{
    return vec3(0.0, 0.0, 1.0);
}

// create quaternion from rotation axis v and the given angle
vec4 describe_rotation(in vec3 v, in float angle)
{
    float sina_2 = sin(angle/2.0);
    float cosa_2 = cos(angle/2.0);
    return vec4(cosa_2, sina_2*v.x, sina_2*v.y, sina_2*v.z);
}

// perform a rotation of vector v using the given quaternion q
vec3 rotate(in vec3 v, in vec4 q)
{
    float t2 =   q.x*q.y;
    float t3 =   q.x*q.z;
    float t4 =   q.x*q.w;
    float t5 =  -q.y*q.y;
    float t6 =   q.y*q.z;
    float t7 =   q.y*q.w;
    float t8 =  -q.z*q.z;
    float t9 =   q.z*q.w;
    float t10 = -q.w*q.w;
    return vec3(2.0*( (t8 + t10)*v.x + (t6 -  t4)*v.y + (t3 + t7)*v.z ) + v.x,
                           2.0*( (t4 +  t6)*v.x + (t5 + t10)*v.y + (t9 - t2)*v.z ) + v.y,
                           2.0*( (t7 -  t3)*v.x + (t2 +  t9)*v.y + (t5 + t8)*v.z ) + v.z);
}

vec3 powN(in vec3 z, float magnitude, vec3 P) {

    orbitTrap=10000;
    vec3 z_power = z;

    float costheta = dot(z, P) / magnitude;
    float costheta2 = costheta * costheta;
    float sintheta2 = 1.0 - costheta2;
    float sintheta = sqrt(sintheta2);

    vec3 N = cross(P, z) / (magnitude * sintheta);

    // Step 1
    // generate a vector that is situated in the plane spanned by
    // origin, the pole and z and has an resulting angle of power*theta
    // with respect to the pole.
    float theta = acos(costheta);
    vec4 rot = describe_rotation( N, (Power-1.0)*theta );
    z_power = rotate(z_power, rot) * pow(magnitude, Power-1.0);

    // Step 2: Perform rotation around pole axis by an angle of (power-1)*phi
    vec3 z_normal = z_power -  RVec() * dot(z_power, RVec());
    float cosphi = dot(z_normal, QVec()) / length(z_normal);
    float phi = acos(cosphi);
    if ( dot(cross(QVec(), z_normal), RVec()) < 0.0 )
        phi = 6.2831853071 - phi;  // 2*PI - phi

    vec4 rot2 = describe_rotation( RVec(), Power*phi - phi );
    z_power = rotate(z_power, rot2);

    return z_power;
}

bool inside(vec3 z) {

    vec3 P = PVec();
    vec3 c=z;
    float r=length(z);

    int i=0;
    while(r<Bailout && (i<Iterations)) {
        z = powN(z,r,P) + c;
        i++;
        r=length(z);
        if (i<ColorIterations) orbitTrap = min(orbitTrap, abs(vec4(z.x,z.y,z.z,r*r)));
    }

    return (r<Bailout);
}


#preset Default
FOV = 0.77
Eye = 0,0,2
Target = 0,0,0
Up = 0,1,0
EquiRectangular = false
Gamma = 1
ToneMapping = 1
Exposure = 1
Brightness = 1
Contrast = 1
Saturation = 1
NormalScale = 1
AOScale = 1
Glow = 0
AOStrength = 1
Samples = 50
Stratify = true
DebugInside = false
CentralDifferences = true
SampleNeighbors = true
Near = 0
Far = 5
ShowDepth = false
DebugNormals = false
Specular = 0.5208
SpecularExp = 20
SpotLight = 1,1,1,0.23529
SpotLightDir = -0.18518,-0.18518
CamLight = 1,1,1,0
CamLightMin = 0
Fog = 0
BaseColor = 1,1,1
OrbitStrength = 1
X = 0.333333,0,0,1
Y = 0.333333,0.333333,0,1
Z = 0.666667,0.333333,0,1
R = 1,1,1,0
BackgroundColor = 1,1,1
GradientBackground = 0.97825
CycleColors = false
Cycles = 14.0735
Iterations = 4
ColorIterations = 100
Power = 3
Bailout = 2
theta = 80
phi = 90
#endpreset

#preset Parrot
FOV = 0.5
Eye = 0.153051,0.144426,0.599367
Target = -0.758841,-1.3586,-2.21299
Up = 0.274098,0.953879,0.12241
EquiRectangular = false
Gamma = 1
ToneMapping = 1
Exposure = 1
Brightness = 1
Contrast = 1
Saturation = 1
NormalScale = 1
AOScale = 1
Glow = 0
AOStrength = 1
Samples = 50
Stratify = true
DebugInside = false
CentralDifferences = true
SampleNeighbors = true
Near = 0
Far = 5
ShowDepth = false
DebugNormals = false
Specular = 1
SpecularExp = 18
SpotLight = 1,1,1,0.25
SpotLightDir = 0.35802,0.50618
CamLight = 1,1,1,0
CamLightMin = 0
Fog = 0
BaseColor = 1,1,1
OrbitStrength = 0.8
X = 0.333333,0.666667,0.498039,1
Y = 1,0.666667,0,1
Z = 1,0,0,1
R = 1,1,1,0
BackgroundColor = 1,1,1
GradientBackground = 1.08695
CycleColors = false
Cycles = 1
Iterations = 60
ColorIterations = 99
Power = 1.1
Bailout = 2
theta = 40
phi = 250
#endpreset

#preset Fossil
FOV = 0.5
Eye = 0.907837,0.501134,1.85441
Target = -0.35304,-1.11791,-0.751134
Up = 0.76982,0.637907,0.0212406
EquiRectangular = false
Gamma = 1
ToneMapping = 1
Exposure = 1
Brightness = 1
Contrast = 1
Saturation = 1
NormalScale = 1
AOScale = 1
Glow = 0
AOStrength = 1
Samples = 50
Stratify = true
DebugInside = false
CentralDifferences = true
SampleNeighbors = true
Near = 0
Far = 5
ShowDepth = false
DebugNormals = false
Specular = 1
SpecularExp = 18
SpotLight = 1,1,1,0.25
SpotLightDir = 0.35802,0.50618
CamLight = 1,1,1,0
CamLightMin = 0
Fog = 0
BaseColor = 1,1,1
OrbitStrength = 0.8
X = 0.666667,0,0,1
Y = 0,0.666667,1,1
Z = 1,1,0.498039,1
R = 1,1,1,0
BackgroundColor = 1,1,1
GradientBackground = 1.08695
CycleColors = false
Cycles = 1
Iterations = 11
ColorIterations = 99
Power = 1.35
Bailout = 2
theta = 51.4278
phi = 129.229
#endpreset