Welcome to Fractal Forums

float DE(vec3 z)
{	
	float r;
	float r2=0.;
	int n = 0;
	vec3 rmin=vec3(0.);
	vec3 zoff=vec3(0.);
	vec3 zstore=vec3(0.);
	while (n < Iterations) {
		z*=rot;
		z=abs(z);
		zstore=z;
		 rmin=vec3(100.,100.,100.);
//  x part  
		r=(z.x-OffSet.x);
		r=r*r;	
		if (r<rmin.x) { rmin.x=r;zoff.x= OffSet.x;}
		
		r=(z.x)*z.x;
		if (r<rmin.x) { rmin.x=r;zoff.x= 0.;}
// y part
		r=(z.y-OffSet.y);
		r=r*r;
		if (r<rmin.y) { rmin.y=r;zoff.y= OffSet.y;}
	
		r=(z.y)*z.y;
		if (r<rmin.y) { rmin.y=r;zoff.y= 0.;}
//z part
		r=(z.z-OffSet.z); r=r*r;
		if (r<rmin.z) { rmin.z=r;zoff.z= OffSet.z;}
	
		r=(z.z)*z.z;
		if (r<rmin.z) { rmin.z=r;zoff.z= 0.;}
	
		z=Scale*z-zoff*(Scale-1.0);

		if (!Stellated) {			// you can take out the not Stellated part here
			if (abs(zstore.x)<abs(zstore.y)) {
				if (abs(zstore.x)<abs(zstore.z)) {
					z.x+=zoff.x;
				} else {
					z.z+=zoff.z;
				}
			} else {
				if (abs(zstore.y)<abs(zstore.z)) {
					z.y+=zoff.y;
				} else {
					z.z+=zoff.z;
				}
			}
		} else {					//  and just use the following section
			if (rmin.x<rmin.y) {		// if you do, remove the zstore variable, as it is 
				if (rmin.x<rmin.z) {	// superfluous.  hahah... superfluous....  :D
					z.x+=zoff.x;
				} else {
					z.z+=zoff.z;
				}
			} else {
				if (rmin.y<rmin.z) {
					z.y+=zoff.y;
				} else {
					z.z+=zoff.z;
				}
			}
		}
		if (n<ColorIterations) orbitTrap = min(orbitTrap, (vec4(abs(z),dot(z,z))));
		
		n++;
	}
	
	r2=(max(abs(z.x),max(abs(z.y),abs(z.z)))-1.);

	return r2*pow(Scale,float(-n));
}

vec3 example (vec3 hrmm) {
  if (check==1) { code  }

  some code.....

  if (check==2)  { code }

 some code 

  if (check==3) { code }

  some code ...   etc.

#info Faceted sphere Distance Estimator just like Darkbeam's discoballIFS
#include "DE-Raytracer.frag"
#group discoballIFS

// Number of faces in xy and yz planes.
uniform int Nfaces;  slider[0,9,100]

vec2 fold2D(vec2 p, vec2 fp){//algorithmically this is O(n)... It could be done in O(log(n)). Gess how ;o)
	vec2 ap=p+vec2(1.);
	int i=0;
	while(i++<20 && any(notEqual( p, ap))){
		ap=p;
		p.y=abs(p.y);
		float t=2.*min(0.,dot(p,fp)); p-=t*fp;
	}
	return p;
}

float DE(vec3 p) {
#define PI 3.14159
	float angle = PI/float(Nfaces);
	vec2 foldingPlaneNormal=vec2(sin(angle),-cos(angle));
	p.xy=fold2D(p.xy,foldingPlaneNormal);
	p.xz=fold2D(p.xz,foldingPlaneNormal);
	return p.x-1.;
}

void main() {//first pass - render from light's perspective to get a depth texture
	vec2 pt=(gl_FragCoord.xy/vec2(resolution))*PI;//map screen coords to sphere
	vec3 rayDir = vec3(sin(pt.y)*cos(pt.x),cos(pt.y),sin(pt.y)*sin(pt.x));
	vec3 ray = lightPosition;//place the camera at the light
	float rayLen=0.0,dist=lightFallOff;
	for(int iSteps=0;iSteps<MaxSteps && dist>=HitDistance && rayLen<=lightFallOff;iSteps++){
		rayLen+=dist=DE(ray+rayLen*rayDir);
	}//march until you hit something or the light gets too weak
	rayLen=clamp(rayLen/lightFallOff,0.0,0.99);
	gl_FragColor = Encode(rayLen);//for non-float textures just shove the float into bytes
	gl_FragDepth = rayLen;
}
void main() {//second pass - draw the scene as usual then fill in fog
	... usual rendering code here ...
	... rayLen has depth of scene, ray is position of hit, color has color:)

	for(float rl=0.0;rl<rayLen;rl+=fogStep){//take small steps along the ray checking depth
		vec3 lightCamDir=ray+rayDir*rl-lightPosition;//get the direction FROM light
		float d=length(lightCamDir);
		lightCamDir=normalize(lightCamDir);
		float phi=acos(lightCamDir.y);//map back to screen coords
		vec2 pt=vec2(acos(lightCamDir.x/sin(phi)),phi)/3.1416;
		//add fog light only if the distance to the light is less than that in texture
		if(d<Decode(texture2D(tex,pt))*lightFallOff)color.rgb+=fogColor/(d*d);
	}
}

smap=min(50000,floor(smap1*1000))+fract(smap2/100);

if (lightdir.z>0) smap=floor(smap)/1000; else smap=fract(smap)*100;