Welcome to Fractal Forums

#info duals of uniform (regular and quasi-regular -and inbetween-) polyhedra
#info also called catalan solids
#info Distance Estimator using fold and cut technique (knighty 2012)
#define providesInit
#define providesColor
#include "DE-Raytracer.frag"
#include "MathUtils.frag"

#group polyhedra

// Symmetry group type.
uniform int Type;  slider[3,5,5]

// U "barycentric" coordinate for the normal of the face plane
uniform float U; slider[0,1,1]

// V 
uniform float V; slider[0,0,1]

// W 
uniform float W; slider[0,0,1]

//vertex radius 
uniform float VRadius; slider[0,0.05,0.5]

//segments radius 
uniform float SRadius; slider[0,0.01,0.1]

uniform bool displayFaces; checkbox[true]
uniform bool displaySegments; checkbox[true]
uniform bool displayVertices; checkbox[true]

#group polyhedraColor
uniform vec3 facesColor; color[0.0,0.0,0.0]
uniform vec3 verticesColor; color[0.0,0.0,0.0]
uniform vec3 segmentsColor; color[0.0,0.0,0.0]

#define PI 3.14159
float dissolveFn(float dott, float mu, float su){
	//return 0.9-pow(1.-abs(dott),20.);
	return clamp(abs(dott)*mu-su,0.,1.);
}
vec3 nc,pab,pbc,pca,nor;
float sva,svb,svc;
void init() {
	float cospin=cos(PI/float(Type)), scospin=sqrt(0.75-cospin*cospin);
	nc=vec3(-0.5,-cospin,scospin);
	pab=vec3(0.,0.,1.);
	pbc=vec3(scospin,0.,0.5);
	pca=vec3(0.,scospin,cospin);
	nor=normalize(U*pab+V*pbc+W*pca);
	pab=pab/dot(nor,pab);
	pbc=pbc/dot(nor,pbc);
	pca=pca/dot(nor,pca);

	//segment visibility: if facet plane is perpendicular to folding plane corresponding to our segment it should not be displayed
#define MU 10.
#define SU 0.01
	sva=dissolveFn(nor.x,MU,SU);
	svb=dissolveFn(nor.y,MU,SU);
	svc=dissolveFn(dot(nor,nc),MU,SU);
	// For vertices, a vertex is visible if one of the corresponding segments is visible with one exception: 
	// Folding planes at PAB (na and nb which are implicit here because their componenets are 
	//respectively (1,0,0) and (0,1,0)) are perpendicular to each other. This imply that the vertex PAB is visible when both
	//corresponding segments are. 
}

vec3 fold(vec3 pos) {
	for(int i=0;i<Type;i++){
		pos.xy=abs(pos.xy);
		float t=-2.*min(0.,dot(pos,nc));
		pos+=t*nc;
	}
	return pos;
}

float D2Planes(vec3 pos) {
	return dot(pos,nor)-1.;
}

float D2Segment(vec3 pos, vec3 pa, vec3 pb) {//gives distance from pos to the sgment (pa,pb).
	return length((pos-pa)-(pb-pa)*clamp(dot(pos-pa,pb-pa)/dot(pb-pa,pb-pa),0.,1.));
}

float D2Segments(vec3 pos) {
	float d=10000.;
	if(sva>0.) d=min(d,D2Segment(pos, pab, pca)-SRadius*sva);
	if(svb>0.) d=min(d,D2Segment(pos, pbc, pab)-SRadius*svb);
	if(svc>0.) d=min(d,D2Segment(pos, pca, pbc)-SRadius*svc);
	return d;
}

float D2Vertices(vec3 pos) {
	float d=10000.;
	if(min(sva,svb)>0.) d=min(d,length(pos-pab)-VRadius*min(sva,svb));
	if(max(svb,svc)>0.) d=min(d,length(pos-pbc)-VRadius*max(svb,svc));
	if(max(svc,sva)>0.) d=min(d,length(pos-pca)-VRadius*max(svc,sva));
	return d;
}

float DE(vec3 pos) {
	pos=fold(pos);
	float d=10000.;
	if(displayFaces) d=min(d,D2Planes(pos));
	if(displaySegments) d=min(d,D2Segments(pos));
	if(displayVertices) d=min(d,D2Vertices(pos));
	return d;
}

vec3 baseColor(vec3 pos, vec3 normal){//corrected. Not optimized.
	pos=fold(pos);
	float df=1000.,dv=1000.,ds=1000.;
	if(displayFaces)	df=D2Planes(pos);
	if(displaySegments) ds=D2Segments(pos);
	if(displayVertices) dv=D2Vertices(pos);
	float d=min(df,min(ds,dv));
	vec3 col=facesColor;
	if(d==ds) col=segmentsColor;
	if(d==dv) col=verticesColor;
	return col;
}

#preset default
FOV = 0.62536
Eye = -3.20087,-2.1931,1.08181
Target = 3.70097,2.60688,-1.72051
Up = 0.253289,0.177444,0.927765
AntiAlias = 1
Detail = -3
DetailAO = -1.57143
FudgeFactor = 1
MaxRaySteps = 100
BoundingSphere = 3
Dither = 0.4386
NormalBackStep = 1
AO = 0,0,0,0.90123
Specular = 4
SpecularExp = 40
SpotLight = 1,1,1,0.51923
SpotLightDir = 0.6923,0.78462
CamLight = 1,0.827451,0.768627,0.49056
CamLightMin = 0
Glow = 1,1,1,0
GlowMax = 20
Fog = 0
HardShadow = 0
ShadowSoft = 8.254
Reflection = 0.
BaseColor = 0.721569,0.721569,0.721569
OrbitStrength = 0.42857
X = 0.411765,0.6,0.560784,0.41748
Y = 0.666667,0.666667,0.498039,-0.16504
Z = 1,0.258824,0.207843,1
R = 0.0823529,0.278431,1,0.82352
BackgroundColor = 0.501961,0.737255,0.956863
GradientBackground = 0.86955
CycleColors = true
Cycles = 4.04901
EnableFloor = false
FloorNormal = 0,0,1
FloorHeight = -0.9335
FloorColor = 1,1,1
Type = 5
U = 1
V = 0
W = 0
VRadius = 0.05
SRadius = 0.025
displayFaces = true
displaySegments = true
displayVertices = true
facesColor = 0.243137,0.211765,0.694118
verticesColor = 1,0,0
segmentsColor = 0.74902,0.756863,0.172549
#endpreset

#include "Soc.frag"

vec2 rotate(vec2 v, float angle) {return cos(angle)*v+sin(angle)*vec2(v.y,-v.x);}
vec2 Kaleido(vec2 v){float w=floor(.5+3.5015*atan(v.x,-v.y))*0.28559;return rotate(v,w);}
float Cone(in vec4 z, float radius, float height){return (max(abs(z.y)-height,length(z.xz))-radius*clamp(height-abs(z.y),0.0,height))/z.w;}


float DESnow(vec3 p) {	  
p+=vec3(1.35,1.54,1.23);
	p*=0.3;
	for (int i=0; i<10; i++) {
	p.xyz=abs(p.xyz);
		p=p/dot(p,p);
		p=p*0.7-vec3(0.8);
}
	return pow(length(p),1.2)*0.08;
}

float DEFir(vec3 z0){
	vec4 z=vec4(z0,1.0);
	z.xy=rotate(z.xy,z.z*0.4);
	z.xy=clamp(z.xy,-1.25,1.25)*2.0-z.xy;
	float r=length(z.xy);
	z.xy=rotate(z.xy,r*0.4);
	z.z=abs(mod(z.z,0.5)-0.25)-0.125;
	z.xy=Kaleido(z.xy);
	z.yz=rotate(z.yz,(0.5-r)*0.15);	
      float dSnow=DESnow(z0); 
      float d=min(r-0.025,Cone(z,0.025,1.0));	  
       float dB1=length(z0+vec3(-1.0,-1.0,-0.47))-0.6;
	float dB2=length(z0+vec3(1.18,-1.24,0.3))-0.6+cos(z0.y*31.5)*0.02;
	vec3 p=z0+vec3(-1.08,0.72,0.46);
	float dB3=length(p)-0.5;
	p.xy=mat2(0.913,-0.4078,0.4078,0.913)*p.xy;
	float dB4=max(abs(p.y-0.55)-0.05,length(p.xz)-0.1+sin(atan(p.x,p.z)*8.0)*0.01);
	float dB5=length(z0+vec3(-0.4,0.1,-2.4))-0.7+sin(z0.y*50)*0.01-sin(z0.z*50)*0.01+sin(z0.x*50)*0.01;
      float dB6=length(z0+vec3(-2.3,0.07,-1.4))-0.2;
       p.y-=0.69;
      dB4=min(dB4,max(abs(p.y)-0.25,length(p.xz+vec2(p.y*p.y))-0.0025));
       float dB=min(dSnow, min(dB1,min(dB2,min(dB3, min(dB4,min(dB5,dB6))))));
             if(dB<d){
             if(bColoring && dB==dB1){mcol+=vec4(2.4,0.0,2.3,0.3);}		
		else if(bColoring && dB==dB2){mcol+=vec4(2.3,2.3,2.3,0.3);}
		else if(bColoring && dB==dB3){mcol+=vec4(0.0,2.4,2.6,0.3);}		
		else if(bColoring && dB==dB4){mcol+=vec4(2.0,2.0,2.0,0.3);}
             else if(bColoring && dB==dB5){mcol+=vec4(3.0,2.0,0.0,0.3);}
             else if(bColoring && dB==dB6){mcol+=vec4(3.0,0.0,0.0,0.3);}
             else if(bColoring && dB==dSnow)mcol+=vec4(3.0,3.0,3.0,0.05);
	      }else{
	      if(bColoring && dB-d){mcol+=vec4(0.6,1.4,0.6,0.0)*r;}
 }	
return max(min(d,dB),-z0.z-4.0);
}

float DE(vec3 z){
return min(DESnow(z),DEFir(z));
}






#preset default
FOV = 0.47058
Eye = 2.44185,-0.380486,3.12248
Target = -1.579,1.85944,-4.45011
FocalPlane = 2.8409
Aperture = 0.01
FudgeFactor = 0.68354
MaxRaySteps = 200
MaxShadowSteps = 200
MaxDistance = 89.5001
ForwardStep = 0.12987
Specular = 1.6456
SpecularExp = 16.364
DiffuseContrast = 0.76087
ShadowContrast = 0.7
ShadowCone = 0.05
LightColor = 1,0.666667,0
LightDir = 0.5,0.5,-0.5
BGColor = 0,0,0.494118
ReflectionBlur = 2
Up = 0,1,0
#endpreset



#include "SoC.frag"


const float r = 1.0 * 2.0 * 1.414214 / 1.732051;
const vec2 h = vec2( r, 0.01 );
const vec2 h2 = h * vec2( 0.73, 4.0 );

const vec3 cc0 = vec3( 0.333333, -0.333333, -0.333333 );
const vec3 cx0 = vec3( 0.707107, 0.000000, 0.707107 );
const vec3 cy0 = vec3( 0.408248, 0.816496, -0.408248 );
const vec3 cz0 = vec3( -0.577350, 0.577350, 0.577350 );
		
const vec3 cc1 = vec3( -0.333333, -0.333333, 0.333333 );
const vec3 cx1 = vec3( 0.707107, 0.000000, 0.707107 );
const vec3 cy1 = vec3( -0.408248, 0.816496, 0.408248 );
const vec3 cz1 = vec3( -0.577350, -0.577350, 0.577350 );
		
const vec3 cc2 = vec3( -0.333333, 0.333333, -0.333333 );
const vec3 cx2 = vec3( 0.707107, 0.707107, 0.000000 );
const vec3 cy2 = vec3( -0.408248, 0.408248, 0.816496 );
const vec3 cz2 = vec3( 0.577350, -0.577350, 0.577350 );
		
const vec3 cc3 = vec3( 0.333333, 0.333333, 0.333333 );
const vec3 cx3 = vec3( 0.000000, 0.707107, -0.707107 );
const vec3 cy3 = vec3( -0.816496, 0.408248, 0.408248 );
const vec3 cz3 = vec3( 0.577350, 0.577350, 0.577350 );

const vec3 c0 = vec3( 0.333333, 0.333333, -0.333333 );
const vec3 x0 = vec3( 0.572061, 0.218508, 0.790569 );
const vec3 y0 = vec3( -0.582591, 0.786715, 0.204124 );
const vec3 z0 = vec3( -0.577350, -0.577350, 0.577350 );

const vec3 c1 = vec3( 0.206011, -0.539344, 0.000000 );
const vec3 x1 = vec3( 0.572061, 0.218508, 0.790569 );
const vec3 y1 = vec3( -0.738528, -0.282093, 0.612372 );
const vec3 z1 = vec3( 0.356822, -0.934172, 0.000000 );

const vec3 c2 = vec3( -0.539344, 0.000000, -0.206011 );
const vec3 x2 = vec3( -0.218508, 0.790569, 0.572061 );
const vec3 y2 = vec3( -0.282093, -0.612372, 0.738528 );
const vec3 z2 = vec3( 0.934172, 0.000000, 0.356822 );

const vec3 c3 = vec3( 0.000000, 0.206011, 0.539344 );
const vec3 x3 = vec3( -0.790569, 0.572061, -0.218508 );
const vec3 y3 = vec3( -0.612372, -0.738528, 0.282093 );
const vec3 z3 = vec3( -0.000000, 0.356822, 0.934172 );

// distance function

// iq's Signed Triangular Prism distance function
float dist_triXY( vec3 p, vec2 h ) {
    vec3 q = abs(p);
    return max(q.z-h.y,max(q.x*0.866025+p.y*0.5,-p.y)-h.x*0.5);
}

float dist_tri( vec3 v, vec3 c, vec3 x, vec3 y, vec3 z ) {
	v -= c;	
	v = vec3( dot( v, x ), dot( v, y ), dot( v, z ) );
	return max( dist_triXY( v, h  ), -dist_triXY( v, h2 ) );
}

float DE( vec3 v ) {
	float b0, b1, b2, b3, b4;
	
	// cube
	{
		float d0 = dist_tri( v, cc0, cx0, cy0, cz0 );
		float d1 = dist_tri( v, cc1, cx1, cy1, cz1 );
		float d2 = dist_tri( v, cc2, cx2, cy2, cz2 );
		float d3 = dist_tri( v, cc3, cx3, cy3, cz3 );
		b0 = min( min( d0, d1 ), min( d2, d3 ) );

}
	
	// xyz
	{
		float d0 = dist_tri( v, c0, x0, y0, z0 );
		float d1 = dist_tri( v, c1, x1, y1, z1 );
		float d2 = dist_tri( v, c2, x2, y2, z2 );
		float d3 = dist_tri( v, c3, x3, y3, z3 );
		b1 = min( min( d0, d1 ), min( d2, d3 ) );

}
	
	// zx
	{
		v.zx = -v.zx;		
		float d0 = dist_tri( v, c0, x0, y0, z0 );
		float d1 = dist_tri( v, c1, x1, y1, z1 );
		float d2 = dist_tri( v, c2, x2, y2, z2 );
		float d3 = dist_tri( v, c3, x3, y3, z3 );
		v.zx = -v.zx;		
		b2 = min( min( d0, d1 ), min( d2, d3 ) );
	
}
	
	// yz
	{
		v.yz = -v.yz;
		float d0 = dist_tri( v, c0, x0, y0, z0 );
		float d1 = dist_tri( v, c1, x1, y1, z1 );
		float d2 = dist_tri( v, c2, x2, y2, z2 );
		float d3 = dist_tri( v, c3, x3, y3, z3 );	
		v.yz = -v.yz;		
		b3 = min( min( d0, d1 ), min( d2, d3 ) );
	}

	// xy
	{
		v.xy = -v.xy;
		float d0 = dist_tri( v, c0, x0, y0, z0 );
		float d1 = dist_tri( v, c1, x1, y1, z1 );
		float d2 = dist_tri( v, c2, x2, y2, z2 );
		float d3 = dist_tri( v, c3, x3, y3, z3 );
		v.xy = -v.xy;		
		b4 = min( min( d0, d1 ), min( d2, d3 ) );
//SoC color
 float b=min(b0, min(b1,min(b2,min(b3,b4))));	

 if(bColoring && b==b0){mcol+=vec4(0.0,0.0,1.0,0.0);}
else if(bColoring && b==b1){mcol+=vec4(1.0,0.0,0.0,0.0);}
else if(bColoring && b==b2){mcol+=vec4(0.0,1.0,0.0,0.0);}
else if(bColoring && b==b3){mcol+=vec4(1.0,1.0,0.0,0.0);}
else if(bColoring && b==b4){mcol+=vec4(0.0,1.0,1.0,0.0);}
}	
return min( b0, min( min( b1, b2 ), min( b3, b4 ) ));
}

#preset Default
FOV = 0.62536
Eye = 3.42782,0.131122,-1.33808
Target = -4.83875,-0.410056,1.80828
FudgeFactor = 0.77215
Specular = 1.6456
SpecularExp = 16.364
FocalPlane = 1
Aperture = 0.01
MaxRaySteps = 200
MaxShadowSteps = 95
MaxDistance = 32.4998
ForwardStep = 0.5
DiffuseContrast = 0.7
ShadowContrast = 0.7
ShadowCone = 0.12712
LightColor = 1,0.9,0.4
LightDir = 0.12196,0.5,-0.5122
BGColor = 0.631373,0.631373,0.631373
ReflectionBlur = 0.5
Up = 0,1,0
#endpreset