//  Mesh sphere by expanding a dodecahedron
//  Bald Eagle 2016



#version 3.7;

global_settings {assumed_gamma 1.0}

#include "colors.inc"
#include "textures.inc"

camera {
	location <0, 5, -20>
	look_at  <0, 5, 0>
	right     x*image_width/image_height
	up y
}

light_source {<20, 50, -100> White shadowless}
light_source {<0, 5, -1> White shadowless}


#macro Subdivision (BasisArray, Iterations)

//-----------------------------------------------------------------
//		Subdivision of triangles
//-----------------------------------------------------------------
#for (Subdivide, 1, Iterations)
#local BasisNumber = dimension_size (BasisArray, 1);
#local ExpandedArray = array [4 * BasisNumber][3];
//#debug "------------\n"
    #for (BasisTriangle, 0, BasisNumber-1)

//  Subdivision scheme for triangles   
//           1
//          / \
//         A___B
//        / \ / \
//       0___C___2

        #local Vertex_A = vnormalize( (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][1])/2 );
        #local Vertex_B = vnormalize( (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][2])/2 );
        #local Vertex_C = vnormalize( (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][0])/2 );
        
        #local ExpandedArray [(4*BasisTriangle)+0][0] = vnormalize(BasisArray[BasisTriangle][0]);
        //#local ExpandedArray [(4*BasisTriangle)+0][1] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][1])/2;
        #local ExpandedArray [(4*BasisTriangle)+0][1] = Vertex_A;
        //#local ExpandedArray [(4*BasisTriangle)+0][2] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][2])/2;
        #local ExpandedArray [(4*BasisTriangle)+0][2] = Vertex_C;
        
        #local ExpandedArray [(4*BasisTriangle)+1][0] = vnormalize(BasisArray[BasisTriangle][1]);
        //#local ExpandedArray [(4*BasisTriangle)+1][1] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][0])/2;
        #local ExpandedArray [(4*BasisTriangle)+1][1] = Vertex_B;
        //#local ExpandedArray [(4*BasisTriangle)+1][2] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][2])/2;
        #local ExpandedArray [(4*BasisTriangle)+1][2] = Vertex_A;
        
        #local ExpandedArray [(4*BasisTriangle)+2][0] = vnormalize(BasisArray[BasisTriangle][2]);
        //#local ExpandedArray [(4*BasisTriangle)+2][1] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][0])/2;
        #local ExpandedArray [(4*BasisTriangle)+2][1] = Vertex_C;
        //#local ExpandedArray [(4*BasisTriangle)+2][2] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][1])/2;
        #local ExpandedArray [(4*BasisTriangle)+2][2] = Vertex_B;
        
        //#local ExpandedArray [(4*BasisTriangle)+3][0] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][1])/2;
        #local ExpandedArray [(4*BasisTriangle)+3][0] = Vertex_A;
        //#local ExpandedArray [(4*BasisTriangle)+3][1] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][2])/2;
        #local ExpandedArray [(4*BasisTriangle)+3][1] = Vertex_B;
        //#local ExpandedArray [(4*BasisTriangle)+3][2] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][0])/2;
        #local ExpandedArray [(4*BasisTriangle)+3][2] = Vertex_C;

		/*
		#debug concat( "Vertex 0 = ", vstr(3, BasisArray[BasisTriangle][0], ", ", 3, 3), " \n")
		#debug concat( "Vertex 1 = ", vstr(3, BasisArray[BasisTriangle][1], ", ", 3, 3), " \n")
		#debug concat( "Vertex 2 = ", vstr(3, BasisArray[BasisTriangle][2], ", ", 3, 3), " \n")
		#debug concat( "Vertex A = ", vstr(3, Vertex_A, ", ", 3, 3), " \n")
		#debug concat( "Vertex B = ", vstr(3, Vertex_B, ", ", 3, 3), " \n")
		#debug concat( "Vertex C = ", vstr(3, Vertex_C, ", ", 3, 3), " \n")
		#debug "------------\n\n"
		*/

    #end // end for BasisTriangle
	#local BasisArray = ExpandedArray;
#end // end for Subdivide

ExpandedArray

#end // end macro subdivision
// ##########################################################################################################################



#declare Phi = (1+sqrt(5))/2;
#declare TwelveHedron = array [20] {
// cube
<-1, -1, -1>		// 0 Left Bottom Front
<-1,  1, -1>		// 1 Left Top Front
<-1,  1,  1>		// 2 Left Top Rear
<-1, -1,  1>		// 3 Left Bottom Rear

< 1, -1, -1>		// 4 Right Bottom Front
< 1,  1, -1>		// 5 Right Top Front
< 1,  1,  1>		// 6 Right Top Rear
< 1, -1,  1>		// 7 Right Bottom Rear
// yz rectangle - green
<0,  (1/Phi), -Phi>	// 8
<0,  (1/Phi),  Phi>	// 9
<0, -(1/Phi),  Phi>	// 10
<0, -(1/Phi), -Phi>	// 11
// xy rectangle - blue
<-(1/Phi),  Phi, 0>	// 12
< (1/Phi),  Phi, 0>	// 13
< (1/Phi), -Phi, 0>	// 14
<-(1/Phi), -Phi, 0>	// 15
// xz rectangle - red
<-Phi, 0, -(1/Phi)>	// 16
<-Phi, 0,  (1/Phi)>	// 17
< Phi, 0,  (1/Phi)>	// 18
< Phi, 0, -(1/Phi)>	// 19
}

// divided into 6 pairs of pentagonal wing-flaps centered on the cubic faces
#declare PentFaces = array [12][5] {
{TwelveHedron [12], TwelveHedron [13], TwelveHedron [ 5], TwelveHedron [ 8], TwelveHedron [ 1]},	// "Top Front"
{TwelveHedron [13], TwelveHedron [12], TwelveHedron [ 2], TwelveHedron [ 9], TwelveHedron [ 6]},	// "Top Rear"
{TwelveHedron [11], TwelveHedron [ 4], TwelveHedron [14], TwelveHedron [15], TwelveHedron [ 0]},	// "Bottom Front"
{TwelveHedron [10], TwelveHedron [ 3], TwelveHedron [15], TwelveHedron [14], TwelveHedron [ 7]},	// "Bottom Rear"
{TwelveHedron [12], TwelveHedron [ 1], TwelveHedron [16], TwelveHedron [17], TwelveHedron [ 2]},	// "Left Top"
{TwelveHedron [17], TwelveHedron [16], TwelveHedron [ 0], TwelveHedron [15], TwelveHedron [ 3]},	// "Left Bottom"
{TwelveHedron [13], TwelveHedron [ 6], TwelveHedron [18], TwelveHedron [19], TwelveHedron [ 5]},	// "Right Top"
{TwelveHedron [19], TwelveHedron [18], TwelveHedron [ 7], TwelveHedron [14], TwelveHedron [ 4]},	// "Right Bottom"
{TwelveHedron [16], TwelveHedron [ 1], TwelveHedron [ 8], TwelveHedron [11], TwelveHedron [ 0]},	// "Front Left"
{TwelveHedron [11], TwelveHedron [ 8], TwelveHedron [ 5], TwelveHedron [19], TwelveHedron [ 4]},	// "Front Right"
{TwelveHedron [10], TwelveHedron [ 9], TwelveHedron [ 2], TwelveHedron [16], TwelveHedron [ 3]},	// "Rear Left"
{TwelveHedron [19], TwelveHedron [ 6], TwelveHedron [ 9], TwelveHedron [10], TwelveHedron [ 7]},	// "Rear Right"
}

#declare FaceCenters = array [12] {
(TwelveHedron [12] + TwelveHedron [13] + TwelveHedron [ 5] + TwelveHedron [ 8] + TwelveHedron [ 1]) / 5,
(TwelveHedron [13] + TwelveHedron [12] + TwelveHedron [ 2] + TwelveHedron [ 9] + TwelveHedron [ 6]) / 5,
(TwelveHedron [11] + TwelveHedron [ 4] + TwelveHedron [14] + TwelveHedron [15] + TwelveHedron [ 0]) / 5,
(TwelveHedron [10] + TwelveHedron [ 3] + TwelveHedron [15] + TwelveHedron [14] + TwelveHedron [ 7]) / 5,
(TwelveHedron [12] + TwelveHedron [ 1] + TwelveHedron [16] + TwelveHedron [17] + TwelveHedron [ 2]) / 5,
(TwelveHedron [17] + TwelveHedron [16] + TwelveHedron [ 0] + TwelveHedron [15] + TwelveHedron [ 3]) / 5,
(TwelveHedron [13] + TwelveHedron [ 6] + TwelveHedron [18] + TwelveHedron [19] + TwelveHedron [ 5]) / 5,
(TwelveHedron [19] + TwelveHedron [18] + TwelveHedron [ 7] + TwelveHedron [14] + TwelveHedron [ 4]) / 5,
(TwelveHedron [16] + TwelveHedron [ 1] + TwelveHedron [ 8] + TwelveHedron [11] + TwelveHedron [ 0]) / 5,
(TwelveHedron [11] + TwelveHedron [ 8] + TwelveHedron [ 5] + TwelveHedron [19] + TwelveHedron [ 4]) / 5,
(TwelveHedron [10] + TwelveHedron [ 9] + TwelveHedron [ 2] + TwelveHedron [16] + TwelveHedron [ 3]) / 5,
(TwelveHedron [19] + TwelveHedron [ 6] + TwelveHedron [ 9] + TwelveHedron [10] + TwelveHedron [ 7]) / 5
}

#declare DodecahedralArray = array [60][3] {
{TwelveHedron [12], TwelveHedron [13], FaceCenters [ 0]},
{TwelveHedron [13], TwelveHedron [ 5], FaceCenters [ 0]},
{TwelveHedron [ 5], TwelveHedron [ 8], FaceCenters [ 0]},
{TwelveHedron [ 8], TwelveHedron [ 1], FaceCenters [ 0]},
{TwelveHedron [ 1], TwelveHedron [12], FaceCenters [ 0]},

{TwelveHedron [13], TwelveHedron [12], FaceCenters [ 1]},
{TwelveHedron [12], TwelveHedron [ 2], FaceCenters [ 1]},
{TwelveHedron [ 2], TwelveHedron [ 9], FaceCenters [ 1]},
{TwelveHedron [ 9], TwelveHedron [ 6], FaceCenters [ 1]},
{TwelveHedron [ 6], TwelveHedron [13], FaceCenters [ 1]},

{TwelveHedron [11], TwelveHedron [ 4], FaceCenters [ 2]},
{TwelveHedron [ 4], TwelveHedron [14], FaceCenters [ 2]},
{TwelveHedron [14], TwelveHedron [15], FaceCenters [ 2]},
{TwelveHedron [15], TwelveHedron [ 0], FaceCenters [ 2]},
{TwelveHedron [ 0], TwelveHedron [11], FaceCenters [ 2]},

{TwelveHedron [10], TwelveHedron [ 3], FaceCenters [ 3]},
{TwelveHedron [ 3], TwelveHedron [15], FaceCenters [ 3]},
{TwelveHedron [15], TwelveHedron [14], FaceCenters [ 3]},
{TwelveHedron [14], TwelveHedron [ 7], FaceCenters [ 3]},
{TwelveHedron [ 7], TwelveHedron [10], FaceCenters [ 3]},

{TwelveHedron [12], TwelveHedron [ 1], FaceCenters [ 4]},
{TwelveHedron [ 1], TwelveHedron [16], FaceCenters [ 4]},
{TwelveHedron [16], TwelveHedron [17], FaceCenters [ 4]},
{TwelveHedron [17], TwelveHedron [ 2], FaceCenters [ 4]},
{TwelveHedron [ 2], TwelveHedron [12], FaceCenters [ 4]},

{TwelveHedron [17], TwelveHedron [16], FaceCenters [ 5]},
{TwelveHedron [16], TwelveHedron [ 0], FaceCenters [ 5]},
{TwelveHedron [ 0], TwelveHedron [15], FaceCenters [ 5]},
{TwelveHedron [15], TwelveHedron [ 3], FaceCenters [ 5]},
{TwelveHedron [ 3], TwelveHedron [17], FaceCenters [ 5]},

{TwelveHedron [13], TwelveHedron [ 6], FaceCenters [ 6]},
{TwelveHedron [ 6], TwelveHedron [18], FaceCenters [ 6]},
{TwelveHedron [18], TwelveHedron [19], FaceCenters [ 6]},
{TwelveHedron [19], TwelveHedron [ 5], FaceCenters [ 6]},
{TwelveHedron [ 5], TwelveHedron [13], FaceCenters [ 6]},

{TwelveHedron [19], TwelveHedron [18], FaceCenters [ 7]},
{TwelveHedron [18], TwelveHedron [ 7], FaceCenters [ 7]},
{TwelveHedron [ 7], TwelveHedron [14], FaceCenters [ 7]},
{TwelveHedron [14], TwelveHedron [ 4], FaceCenters [ 7]},
{TwelveHedron [ 4], TwelveHedron [19], FaceCenters [ 7]},

{TwelveHedron [16], TwelveHedron [ 1], FaceCenters [ 8]},
{TwelveHedron [ 1], TwelveHedron [ 8], FaceCenters [ 8]},
{TwelveHedron [ 8], TwelveHedron [11], FaceCenters [ 8]},
{TwelveHedron [11], TwelveHedron [ 0], FaceCenters [ 8]},
{TwelveHedron [ 0], TwelveHedron [16], FaceCenters [ 8]},

{TwelveHedron [11], TwelveHedron [ 8], FaceCenters [ 9]},
{TwelveHedron [ 8], TwelveHedron [ 5], FaceCenters [ 9]},
{TwelveHedron [ 5], TwelveHedron [19], FaceCenters [ 9]},
{TwelveHedron [19], TwelveHedron [ 4], FaceCenters [ 9]},
{TwelveHedron [ 4], TwelveHedron [11], FaceCenters [ 9]},

{TwelveHedron [10], TwelveHedron [ 9], FaceCenters [10]},
{TwelveHedron [ 9], TwelveHedron [ 2], FaceCenters [10]},
{TwelveHedron [ 2], TwelveHedron [16], FaceCenters [10]},
{TwelveHedron [16], TwelveHedron [ 3], FaceCenters [10]},
{TwelveHedron [ 3], TwelveHedron [10], FaceCenters [10]},

{TwelveHedron [19], TwelveHedron [ 6], FaceCenters [11]},
{TwelveHedron [ 6], TwelveHedron [ 9], FaceCenters [11]},
{TwelveHedron [ 9], TwelveHedron [10], FaceCenters [11]},
{TwelveHedron [10], TwelveHedron [ 7], FaceCenters [11]},
{TwelveHedron [ 7], TwelveHedron [19], FaceCenters [11]}

}

// orange
#declare CubeFaces = array [6][4] {
{TwelveHedron [ 0], TwelveHedron [ 1], TwelveHedron [ 2], TwelveHedron [ 3]},	// Left
{TwelveHedron [ 4], TwelveHedron [ 5], TwelveHedron [ 6], TwelveHedron [ 7]},	// Right
{TwelveHedron [ 1], TwelveHedron [ 5], TwelveHedron [ 6], TwelveHedron [ 2]},	// Top
{TwelveHedron [ 0], TwelveHedron [ 4], TwelveHedron [ 7], TwelveHedron [ 3]},	// Bottom
{TwelveHedron [ 1], TwelveHedron [ 5], TwelveHedron [ 4], TwelveHedron [ 0]},	// Front
{TwelveHedron [ 2], TwelveHedron [ 6], TwelveHedron [ 7], TwelveHedron [ 3]}	// Rear
}

// green
#declare YZRectangle = array [4] {
TwelveHedron [ 8], TwelveHedron [ 9], TwelveHedron [10], TwelveHedron [11]
}

// blue
#declare XYRectangle = array [4] {
TwelveHedron [12], TwelveHedron [13], TwelveHedron [14], TwelveHedron [15]
}

// red
#declare XZRectangle = array [4] {
TwelveHedron [16], TwelveHedron [17], TwelveHedron [18], TwelveHedron [19]
}

// for triangle direction
#declare D1 = 2;
#declare D2 = 0;
#declare Step = (D2-D1)/2;

#declare Dodecahedron = union {
	#for (Side, 0, 59)
	    triangle {
	    #for (Vertex, D1, D2, Step)
			DodecahedralArray[Side][Vertex]
			//vnormalize(DodecahedralArray[Side][Vertex])
	    #end
	    }
	#end // end for Side
}

#declare Centers = union {
#for (F, 0, dimension_size (FaceCenters, 1)-1)
	sphere {FaceCenters[F] 0.1 pigment {Red} }
#end
}



#declare Dodec_1_Array = Subdivision (DodecahedralArray, 1)
#declare ExpandedNumber = dimension_size (Dodec_1_Array, 1);

#declare DodecahedralExpansion1 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_1_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

//  Cylinder Mesh instead of flat triangles
#declare MeshSphere1 = 
union {
	#declare LastVertex = <0, 0, 0>;
	#for (Side, 0, ExpandedNumber-1)
	    #for (Vertex, D1, D2, Step)
			#declare ThisVertex = Dodec_1_Array[Side][Vertex];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (Vertex > 0)
				cylinder {LastVertex, ThisVertex, 0.01 texture {pigment {White} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	    #end
	#end // end for Side
pigment {Green}
}

#declare SmoothSphere1 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    smooth_triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_1_Array[Side][Vertex],
			Dodec_1_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

//--------

#declare Dodec_2_Array = Subdivision (DodecahedralArray, 2)
#declare ExpandedNumber = dimension_size (Dodec_2_Array, 1);

#declare DodecahedralExpansion2 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_2_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

//  Cylinder Mesh instead of flat triangles
#declare MeshSphere2 = 
union {
	#declare LastVertex = <0, 0, 0>;
	#for (Side, 0, ExpandedNumber-1)
	    #for (Vertex, D1, D2, Step)
			#declare ThisVertex = Dodec_2_Array[Side][Vertex];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (Vertex > 0)
				cylinder {LastVertex, ThisVertex, 0.01 texture {pigment {White} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	    #end
	#end // end for Side
pigment {Green}
}

#declare SmoothSphere2 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    smooth_triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_2_Array[Side][Vertex],
			Dodec_2_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

//--------

#declare Dodec_3_Array = Subdivision (DodecahedralArray, 3)
#declare ExpandedNumber = dimension_size (Dodec_3_Array, 1);

#declare DodecahedralExpansion3 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_3_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

//  Cylinder Mesh instead of flat triangles
#declare MeshSphere3 = 
union {
	#declare LastVertex = <0, 0, 0>;
	#for (Side, 0, ExpandedNumber-1)
	    #for (Vertex, D1, D2, Step)
			#declare ThisVertex = Dodec_3_Array[Side][Vertex];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (Vertex > 0)
				cylinder {LastVertex, ThisVertex, 0.01 texture {pigment {White} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	    #end
	#end // end for Side
pigment {Green}
}

#declare SmoothSphere3 = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    smooth_triangle {
	    #for (Vertex, D1, D2, Step)
			Dodec_3_Array[Side][Vertex],
			Dodec_3_Array[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
	    #end
	    }
		//#debug "------------\n\n"
	#end // end for Side
texture {pigment {Red} finish {specular 0.6}}
interior_texture {pigment {Green} finish {specular 0.6}}
}

// ########################################################################################################

    object {Dodecahedron translate -x*10 translate y*10
	texture {pigment {Red} finish {specular 0.6 reflection 0.25}}
	interior_texture {pigment {Green} finish {specular 0.6 reflection 0.25}}
	}

    object {DodecahedralExpansion1 translate -x*5 translate y*10}
    object {MeshSphere1 scale 1 rotate y*2.5 translate y*10}
    sphere {<0, 0, 0>, 0.99 scale 1 pigment {White*0.3 filter 0.95} translate y*10}
    object {SmoothSphere1 translate x*5 translate y*10}

    object {DodecahedralExpansion2 translate -x*5 translate y*5}
    object {MeshSphere2 scale 1 rotate y*2.5 translate y*5}
    sphere {<0, 0, 0>, 0.99 scale 1 pigment {White*0.3 filter 0.95} translate y*5}
    object {SmoothSphere2 translate x*5 translate y*5}

    object {DodecahedralExpansion3 translate -x*5 translate y*0}
    object {MeshSphere3 scale 1 rotate y*2.5 translate y*0}
    sphere {<0, 0, 0>, 0.99 scale 1 pigment {White*0.3 filter 0.95} translate y*0}
    object {SmoothSphere3 translate x*5 translate y*0}

    object {Dodecahedron 
	pigment {rgbt <1, 1, 1, 0.98>}
	translate -x*10 translate y*5
	}
#declare Line = 0.02;

	#declare LastVertex = <0, 0, 0>;
	union {
	#for (S, 0, 11)
		#for (V, 0, 4)
				#declare ThisVertex = PentFaces[S][V];
				//ExpandedArray[Side][Vertex]
				//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
				#if (V > 0)
					cylinder {LastVertex, ThisVertex, Line texture {pigment {White} finish {specular 0.8}} }
				#end
				#declare LastVertex = ThisVertex;
		#end
		cylinder {LastVertex, PentFaces[S][0], Line texture {pigment {White} finish {specular 0.8}} }
	#end
	translate -x*10 translate y*5
	}

	#declare LastVertex = <0, 0, 0>;
	union {
	#for (S, 0, 5)
		#for (V, 0, 3)
				#declare ThisVertex = CubeFaces[S][V];
				//ExpandedArray[Side][Vertex]
				//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
				#if (V > 0)
					cylinder {LastVertex, ThisVertex, Line texture {pigment {Orange*0.4} finish {specular 0.8}} }
				#end
				#declare LastVertex = ThisVertex;
		#end
		cylinder {LastVertex, CubeFaces[S][0], Line texture {pigment {Orange*0.4} finish {specular 0.8}} }
	#end
	translate -x*10 translate y*5
	}


	#declare LastVertex = <0, 0, 0>;
	union {
	#for (V, 0, 3)
			#declare ThisVertex = YZRectangle[V];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (V > 0)
				cylinder {LastVertex, ThisVertex, Line texture {pigment {Blue} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	#end
	cylinder {LastVertex, YZRectangle[0], Line texture {pigment {Blue} finish {specular 0.8}} }
	translate -x*10 translate y*5
	}

	#declare LastVertex = <0, 0, 0>;
	union {
	#for (V, 0, 3)
			#declare ThisVertex = XZRectangle[V];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (V > 0)
				cylinder {LastVertex, ThisVertex, Line texture {pigment {Red} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	#end
	cylinder {LastVertex, XZRectangle[0], Line texture {pigment {Red} finish {specular 0.8}} }
	translate -x*10 translate y*5
	}

	#declare LastVertex = <0, 0, 0>;
	union {
	#for (V, 0, 3)
			#declare ThisVertex = XYRectangle[V];
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			#if (V > 0)
				cylinder {LastVertex, ThisVertex, Line texture {pigment {Green} finish {specular 0.8}} }
			#end
			#declare LastVertex = ThisVertex;
	#end
	cylinder {LastVertex, XYRectangle[0], Line texture {pigment {Green} finish {specular 0.8}} }
	translate -x*10 translate y*5
	}