// Create a mesh sphere by subdividing the faces of an octahedron
// Bald Eagle 2016
// based on code by Jon Leech (1999)
// http://archive.gamedev.net/archive/reference/articles/article427.html

// TO DO
// fix wrong surface normals


#version 3.7;

global_settings {assumed_gamma 1.0}

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

camera {
	location <0, 5, -15>
	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}

#declare P = true;      //  true - icosahedron, false - octahedron

//----------------------------------------------------------------

#declare EightHedron = array [6] {
<1, 0, 0>, <-1, 0, 0>, <0, 1, 0>, <0, -1, 0>, <0, 0, 1>, <0, 0, -1>
}

#declare Phi = (1+sqrt(5))/2;

#declare TwentyHedron = array [12] {
<0, 1, -Phi>, 	// Top front    0
<0, 1, Phi>, 	// Top Rear     1

<-1, Phi, 0>, 	// Left Top     2
<-1, -Phi, 0>,	// Left bottom  3

<1, Phi, 0>, 	// Right top    4
<1, -Phi, 0>, 	// right bottom 5
        
<-Phi, 0, -1>,	// left front   6
<Phi, 0, -1>, 	// right front  7

<-Phi, 0, 1>, 	// left rear    8
<Phi, 0, 1>, 	// right rear   9

<0, -1, -Phi>,  // bottom front 10
<0, -1, Phi>, 	// bottom rear  11
}

#if (P = true)
	#declare BasisArray = array [20][3] {
	//front top cap
    {TwentyHedron[ 0], TwentyHedron[ 1], TwentyHedron[ 4]},     //          1
    {TwentyHedron[ 0], TwentyHedron[ 4], TwentyHedron[ 7]},     //        /   \
    {TwentyHedron[ 0], TwentyHedron[ 7], TwentyHedron[ 6]},     //       2  0  4
    {TwentyHedron[ 0], TwentyHedron[ 6], TwentyHedron[ 2]},     //       \     /
    {TwentyHedron[ 0], TwentyHedron[ 2], TwentyHedron[ 1]},     //        6---7
    // middle belt
    {TwentyHedron[ 1], TwentyHedron[ 9], TwentyHedron[ 8]},
    {TwentyHedron[ 1], TwentyHedron[ 4], TwentyHedron[ 9]},
    {TwentyHedron[ 4], TwentyHedron[ 5], TwentyHedron[ 9]},
    {TwentyHedron[ 4], TwentyHedron[ 7], TwentyHedron[ 5]},     //      1---4---7---6---2---1
    {TwentyHedron[ 7], TwentyHedron[10], TwentyHedron[ 5]},     //     / \ / \ / \ / \ / \ /
    {TwentyHedron[ 7], TwentyHedron[ 6], TwentyHedron[10]},     //    8---9---5---10--3---8
    {TwentyHedron[ 6], TwentyHedron[ 3], TwentyHedron[10]},
    {TwentyHedron[ 6], TwentyHedron[ 2], TwentyHedron[ 3]},
    {TwentyHedron[ 2], TwentyHedron[ 8], TwentyHedron[ 3]},
    {TwentyHedron[ 2], TwentyHedron[ 1], TwentyHedron[ 8]},
    //rear bottom cap
    {TwentyHedron[11], TwentyHedron[ 8], TwentyHedron[ 9]},     //        8---9
    {TwentyHedron[11], TwentyHedron[ 9], TwentyHedron[ 5]},     //       /     \
    {TwentyHedron[11], TwentyHedron[ 5], TwentyHedron[10]},     //      3   11  5
    {TwentyHedron[11], TwentyHedron[10], TwentyHedron[ 3]},     //       \     /
    {TwentyHedron[11], TwentyHedron[ 3], TwentyHedron[ 8]}      //          10
}


#else 
	#declare BasisArray = array [8][3] {
	{EightHedron [5], EightHedron [1], EightHedron [2]},	// Top Left Front
	{EightHedron [5], EightHedron [2], EightHedron [0]},	// Top Right Front
	{EightHedron [5], EightHedron [3], EightHedron [1]},	// Bottom Left Front
	{EightHedron [5], EightHedron [0], EightHedron [3]},	// Bottom Right Front
	{EightHedron [4], EightHedron [2], EightHedron [1]},	// Top Left Rear
	{EightHedron [4], EightHedron [0], EightHedron [2]},	// Top Right Rear
	{EightHedron [4], EightHedron [1], EightHedron [3]},	// Bottom Left Rear
	{EightHedron [4], EightHedron [3], EightHedron [0]}	    // Bottom Right Rear
	} //end BasisArray
	
	
	#declare Octahedron = union {
	#for (Side, 0, 7)
	    triangle {
	    #for (Vertex, 0, 2)
	        BasisArray[Side][Vertex]
	    #end
	    }
	#end // end for Side
	texture {pigment {Red} finish {specular 0.6 reflection 0.25}}
	interior_texture {pigment {Green} finish {specular 0.6 reflection 0.25}}
	}
	
	
	#declare OriginalVertices = union {
	#for (Side, 0, 7)
		#for (Vertex, 0, 2)
			cylinder {0, BasisArray[Side][Vertex]*1.5, 0.025}
		#end
	#end // end for Side
	pigment {Red*0.4}
	}
	
	#declare Text = union {
	#for (Vertex, 0, 5)
		cylinder {0, EightHedron[Vertex]*1.5, 0.025}
		text {ttf "arial.ttf", str(Vertex, 1, 0), 0.02, 0.0 scale 0.5 translate EightHedron[Vertex]*1.5 pigment {White}}	
	#end
	sphere {<0, 0, 0>, 0.75 pigment {Blue filter 0.95}}
	}

#end // end if 

//-----------------------------------------------------------------
//		Subdivision of triangles
//-----------------------------------------------------------------
#for (Subdivide, 1, 3)
#declare BasisNumber = dimension_size (BasisArray, 1);
#declare 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 );
        
        #declare ExpandedArray [(4*BasisTriangle)+0][0] = vnormalize(BasisArray[BasisTriangle][0]);
        //#declare ExpandedArray [(4*BasisTriangle)+0][1] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][1])/2;
        #declare ExpandedArray [(4*BasisTriangle)+0][1] = Vertex_A;
        //#declare ExpandedArray [(4*BasisTriangle)+0][2] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][2])/2;
        #declare ExpandedArray [(4*BasisTriangle)+0][2] = Vertex_C;
        
        #declare ExpandedArray [(4*BasisTriangle)+1][0] = vnormalize(BasisArray[BasisTriangle][1]);
        //#declare ExpandedArray [(4*BasisTriangle)+1][1] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][0])/2;
        #declare ExpandedArray [(4*BasisTriangle)+1][1] = Vertex_B;
        //#declare ExpandedArray [(4*BasisTriangle)+1][2] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][2])/2;
        #declare ExpandedArray [(4*BasisTriangle)+1][2] = Vertex_A;
        
        #declare ExpandedArray [(4*BasisTriangle)+2][0] = vnormalize(BasisArray[BasisTriangle][2]);
        //#declare ExpandedArray [(4*BasisTriangle)+2][1] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][0])/2;
        #declare ExpandedArray [(4*BasisTriangle)+2][1] = Vertex_C;
        //#declare ExpandedArray [(4*BasisTriangle)+2][2] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][1])/2;
        #declare ExpandedArray [(4*BasisTriangle)+2][2] = Vertex_B;
        
        //#declare ExpandedArray [(4*BasisTriangle)+3][0] = (BasisArray[BasisTriangle][0]+BasisArray[BasisTriangle][1])/2;
        #declare ExpandedArray [(4*BasisTriangle)+3][0] = Vertex_A;
        //#declare ExpandedArray [(4*BasisTriangle)+3][1] = (BasisArray[BasisTriangle][1]+BasisArray[BasisTriangle][2])/2;
        #declare ExpandedArray [(4*BasisTriangle)+3][1] = Vertex_B;
        //#declare ExpandedArray [(4*BasisTriangle)+3][2] = (BasisArray[BasisTriangle][2]+BasisArray[BasisTriangle][0])/2;
        #declare 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
	#declare BasisArray = ExpandedArray;
#end // end for Subdivide


#declare ExpandedNumber = dimension_size (ExpandedArray, 1);

#declare ExpandedPolyhedron = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    triangle {
	    #for (Vertex, 0, 2)
			ExpandedArray[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 Vertices = 
union {
	#for (Side, 0, ExpandedNumber-1)
	    #for (Vertex, 0, 2)
			//ExpandedArray[Side][Vertex]
			//#debug concat( "Vertex = ", vstr(3, ExpandedArray[Side][Vertex], ", ", 3, 3), " \n")
			sphere {ExpandedArray[Side][Vertex], 0.025}
	    #end
	#end // end for Side
pigment {Green}
}

#declare MeshSphere = 
union {
	#declare LastVertex = <0, 0, 0>;
	#for (Side, 0, ExpandedNumber-1)
	    #for (Vertex, 0, 2)
			#declare ThisVertex = ExpandedArray[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 SmoothSphere = union {
	//#debug "------------\n"
	#for (Side, 0, ExpandedNumber-1)
	    smooth_triangle {
	    #for (Vertex, 0, 2)
			ExpandedArray[Side][Vertex],
			ExpandedArray[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}}
}

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

#if (P = true)

    object {MeshSphere scale 2 rotate y*2.5 translate y*5}
    sphere {<0, 0, 0>, 0.99 scale 2 translate y*5 pigment {White*0.3 filter 0.95} }
    object {SmoothSphere translate y*10}

    object {ExpandedPolyhedron translate x*5}
    object {Vertices translate x*5}
    
    object {ExpandedPolyhedron rotate y*90 translate x*5 translate y*5}
    object {ExpandedPolyhedron rotate y*180 translate x*5 translate y*10}

#else
    object {Text}
    object {MeshSphere scale 2 rotate y*2.5 translate y*5}
    sphere {<0, 0, 0>, 0.99 scale 2 translate y*5 pigment {White*0.3 filter 0.95} }
    object {SmoothSphere translate y*10}
    
    object {Octahedron translate -x*5}
    object {OriginalVertices translate -x*5}
    object {Octahedron rotate y*90 translate -x*5 translate y*5}
    object {Octahedron rotate y*180 translate -x*5 translate y*10}
    
    object {ExpandedPolyhedron translate x*5}
    object {OriginalVertices translate x*5}
    object {Vertices translate x*5}
    
    object {ExpandedPolyhedron rotate y*90 translate x*5 translate y*5}
    object {ExpandedPolyhedron rotate y*180 translate x*5 translate y*10}
    
#end