/*
	
	tileFinder-PRNG.pov
	
	2020 Sam Benge
	
	+fn -f -a0.3 +am2 +r2

*/

#version 3.7;

// Runes's(?) Z_Align macro
#macro Z_Align( Normal_vector, Z_vector )
	#local ObjectZ = vnormalize( Z_vector );
	#local ObjectY = VPerp_Adjust( Normal_vector, Z_vector );
	#local ObjectX = vcross( ObjectY, ObjectZ );
	transform{ Shear_Trans( ObjectX, ObjectY, ObjectZ ) }
#end

#macro Shear_Trans(A, B, C)
   transform {
      matrix < A.x, A.y, A.z,
             B.x, B.y, B.z,
             C.x, C.y, C.z,
             0, 0, 0>
   }
#end

#macro VPerp_Adjust(V, Axis) vnormalize(vcross(vcross(Axis, V), Axis)) #end

#macro VPerp_To_Vector(v0)
   #if (vlength(v0) = 0)
      #local vN = <0, 0, 0>;
   #else
      #local Dm = min(abs(v0.x), abs(v0.y), abs(v0.z));
      #if (abs(v0.z) = Dm)
         #local vN = vnormalize(vcross(v0, z));
      #else
         #if (abs(v0.y) = Dm)
            #local vN = vnormalize(vcross(v0, y));
         #else
            #local vN = vnormalize(vcross(v0, x));
         #end
      #end
   #end
   vN
#end

// Prox2D stuff
#declare Prox2D_Blur_Distance_Fade = false;

// pigment blur
#macro Prox2D_Blur(Pgmt, BlurRad, NPts)
  
  #local NPts = floor(max(1, min(256, NPts)));
  
	pigment_pattern{
		average
		pigment_map{
			#for(N, 1, NPts)
				
				#local C = 1/NPts*N;
				#local R = pow(C*sqrt(N)/pow(NPts,.5),1/3);
				#local Angle = N*137.508;
				
				[1-R*Prox2D_Blur_Distance_Fade
					Pgmt
					translate BlurRad*vrotate(y*R, z*Angle)
				]
			
			#end
		}
	}
	
#end

// proximity pigment for 2D pigments (useful for height maps)
#macro Prox2D(Pgmt, BlurRad, NPts)
	#local FPlane = function{select(z,0,1)}
	#local FImage = function{pattern{pigment_pattern{Pgmt}}}
	#local FBlurredHeight =
		function{
			pattern{
				pigment_pattern{
					Prox2D_Blur(
						pigment{
							function{
								max(0,min(1,FPlane(x,y,z-FImage(x,y,0))))
							}
						},
						BlurRad,
						NPts
					)
				}
			}
		}
	pigment_pattern{
		function{ max(0,min(1,FBlurredHeight(x,y,z+FImage(x,y,0)))) }
		warp{planar}
	}
#end


global_settings{
	assumed_gamma 1.0
	max_trace_level 5
}

#default{ finish{ambient 0} }

#declare SunDir = <-1, .25, .25>;
#declare RGBSun = srgb 1.974*<2, 1.95, 1.8>;
#declare RGBSky = rgb <.1, .2, .4>;

#declare CamPos = <5, 10, -10>;

camera{
	right x*1.77 up y
	location CamPos
	look_at 0
	angle 60/2
	aperture .75 focal_point -z+.25*y blur_samples 50 variance 0
}

#if(1)
	sky_sphere{
		pigment{
			//Sky_Pigment
			spherical scale 2 translate z
			poly_wave 4
			Z_Align(-y, SunDir)
			color_map{
				[0 RGBSky]
				[1 RGBSun]
			}
		}
	}
#end

// height_field resolution
#declare HFRes = 512;

// pattern for height_field
#declare Pattern =
	pigment{
		// fractalline pattern
		spherical translate (x+z)/2 warp{planar}
		//scale 1/3
		
		#for(I, 0, 7)
			warp{repeat x flip x}
			warp{repeat y flip y}
			rotate z*17
			translate <.2, 0, 0>
			scale .8
		#end
		
		scale <.75, 1, 1>
		
		warp{repeat y flip y}
		translate y/2 - 2*z
		
	}

// height for height_field
#declare HeightPgmt =
	pigment{
		pigment_pattern{
			planar
			rotate z*270
		}
		#if(0)
			pigment_map{
				[0 rgb 0]
				[.5 Pattern]
				[1 rgb 1]
			}
		#else
			pigment_map{
				[0 Pattern color_map{[0 rgb 0][1 rgb .1]}]
				[.5 Pattern]
				[1 Pattern color_map{[0 rgb .9][1 rgb 1]}]
			}
		#end
	}

// the height_field
#declare HF =
	height_field{
		function HFRes, HFRes{
			pigment{
				HeightPgmt
				scale <1, -1, 1>
				translate y
			}
		}
		
		smooth
		
		pigment{
			Prox2D(HeightPgmt, .1, 8)
			rotate x*90
			color_map{[0 rgb 0][1 rgb <.8, .498039, .196078>]}
		}
		finish{
			diffuse 0 brilliance 4
			specular 1 metallic 1
			reflection{1 metallic 1}
		}
		normal{granite .25 scale .01 accuracy .001}
		
		translate -(x+z)/2
		scale <1, .5, 1>
	}

// tile definitions
#declare TileEdge = HF;

// for TileOutCorner
#declare TileClip1 =
	object{
		object{HF
			clipped_by{plane{-x+z, 0}}
		}
	}

#declare TileOutCorner =
	union{
		object{TileClip1}
		object{TileClip1 scale <-1, 1, 1> rotate y*90}
	}

#declare TileInCorner =
	union{
		object{HF}
		object{HF rotate y*270}
	}

#declare TileBridge =
	union{
		object{TileOutCorner}
		object{TileOutCorner rotate y*180}
	}

// used for TileEmpty
#declare TileClip2 =
	object{
		object{HF
			clipped_by{plane{-x-z, 0}}
			clipped_by{plane{-x+z, 0}}
		}
	}

#declare TileEmpty =
	union{
		object{TileClip2}
		object{TileClip2 rotate y*90}
		object{TileClip2 rotate y*180}
		object{TileClip2 rotate y*270}
	}

#declare TileSolid =
	union{
		object{TileEdge}
		object{TileEdge rotate y*90}
		object{TileEdge rotate y*180}
		object{TileEdge rotate y*270}
	}

// cells pattern for tile evaluation
#declare BinLand =
	function{
		pattern{
			pigment_pattern{
				cells
				translate y
				color_map{[.5 rgb 0][.5 rgb 1]}
			}
		}
	}

// adding objects
union{
	#local XSize = 8;
	#local ZSize = 8;
	#for(Z, -ZSize, ZSize)
		#for(X, -XSize, XSize)
			
			// decimal from four 2 bit cells
			#declare bit4 =
				1 * BinLand(X-.5, 0, Z-.5) +
				2 * BinLand(X+.5, 0, Z-.5) +
				4 * BinLand(X-.5, 0, Z+.5) +
				8 * BinLand(X+.5, 0, Z+.5);
			
			// ideally this would be nested #if statements
			#switch(bit4)
				#case(0)
					object{
						TileEmpty
						translate <X, 0, Z>
					}
				#break
				#case(1)
					object{
						TileOutCorner
						translate <X, 0, Z>
					}
				#break
				#case(2)
					object{
						TileOutCorner
						rotate y*270
						translate <X, 0, Z>
					}
				#break
				#case(3)
					object{
						TileEdge
						rotate y*270
						translate <X, 0, Z>
					}
				#break
				#case(4)
					object{
						TileOutCorner
						rotate y*90
						translate <X, 0, Z>
					}
				#break
				#case(5)
					object{
						TileEdge
						translate <X, 0, Z>
					}
				#break
				#case(6)
					object{
						TileBridge
						rotate y*90
						translate <X, 0, Z>
					}
				#break
				#case(7)
					object{
						TileInCorner
						translate <X, 0, Z>
					}
				#break
				#case(8)
					object{
						TileOutCorner
						rotate y*180
						translate <X, 0, Z>
					}
				#break
				#case(9)
					object{
						TileBridge
						translate <X, 0, Z>
					}
				#break
				#case(10)
					object{
						TileEdge
						rotate y*180
						translate <X, 0, Z>
					}
				#break
				#case(11)
					object{
						TileInCorner
						rotate y*270
						translate <X, 0, Z>
					}
				#break
				#case(12)
					object{
						TileEdge
						rotate y*90
						translate <X, 0, Z>
					}
				#break
				#case(13)
					object{
						TileInCorner
						rotate y*90
						translate <X, 0, Z>
					}
				#break
				#case(14)
					object{
						TileInCorner
						rotate y*180
						translate <X, 0, Z>
					}
				#break
				#case(15)
					object{
						TileSolid
						translate <X, 0, Z>
					}
				#break
			#end
			
		#end
	#end
}