/* this file sets the coords for the object triangles, not
   the UV triangles */

#include "environment.pov"
#declare rseed = seed(56269687);
#declare main_hue = <0, 0.5, 1>;
#declare pic_name = "devo_control_room.tga"
#declare trendy_crap_on = true;


global_settings {
  assumed_gamma 2
}


#macro lazy_map(lm_filename)
  #local lz_sl = strlen(lm_filename);
  #local lz_ext = strlwr(substr(lm_filename, lz_sl - 2, 3)) // get file type
  #debug concat("file extension is ", lz_ext, "\n")
  #if (strcmp(lz_ext, "tga") = 0)
    tga lm_filename
  #else
    #if (strcmp(lz_ext, "png") = 0)
      png lm_filename
    #else
      #if (strcmp(lz_ext, "gif") = 0)
        gif lm_filename
      #else
        #if (strcmp(lz_ext, "iff") = 0)
          iff lm_filename
        #else
          #if (strcmp(lz_ext, "jpg") = 0)
            jpeg lm_filename
          #else
            sys lm_filename
          #end
        #end
      #end
    #end
  #end
#end


#macro camera_transforms()
  rotate x*32
  rotate y*20
  translate <-3.5, 7, -7.2>
#end


camera {
  location 0
  direction <0, 0, 1.4>
  right <image_width / image_height, 0, 0>
  up <0, 1, 0>
  camera_transforms()
}


#if (trendy_crap_on = true)
union {
  prism {
    linear_sweep
    linear_spline
    0,
    0.001,
    7,
    <4/3 * -0.5,  0.5>,
    <4/3 * 0.5,   0.5>,
    <4/3 * 0.5,   0.37>,
    <-0.25,        0.37>,
    <-0.25 - 0.05, 0.37 - 0.05>,
    <4/3 * -0.5,  0.37 - 0.05>,
    <4/3 * -0.5,  0.5>
    no_shadow
    rotate x*-90
    pigment { color rgbt <0, 0, 0, 0.65> }
    finish { ambient 1 diffuse 0 }
  }
  prism {
    linear_sweep
    linear_spline
    0,
    0.001,
    7,
    <4/3 * -0.5,  0.5>,
    <4/3 * 0.5,   0.5>,
    <4/3 * 0.5,   0.37>,
    <-0.25,        0.37>,
    <-0.25 - 0.05, 0.37 - 0.05>,
    <4/3 * -0.5,  0.37 - 0.05>,
    <4/3 * -0.5,  0.5>
    no_shadow
    rotate x*-90
    rotate z*180
    pigment { color rgbt <0, 0, 0, 0.65> }
    finish { ambient 1 diffuse 0 }
  }
  text {
    ttf "crystal.ttf" "UV-Mapping test", 0.01, 0
    scale 0.021
    translate <0.33, -0.367, -0.005>
    pigment { color rgb 1 }
    finish { ambient 1 diffuse 0 }
    no_shadow
  }
  scale 0.77
  translate <0, 0, 1>
  camera_transforms()
}
#end


#declare pic_pig1_a = pigment {
  image_map {
    lazy_map(pic_name)
    interpolate 2
  }
}


#declare pic_line_pig = pigment { color rgb 1 }


#declare pic_pig1_b = pigment {
  gradient <1, 0, 0>
  frequency 48
  pigment_map {
    [ 0.05 pic_line_pig ]
    [ 0.05 pic_pig1_a ]
  }
}


#declare pic_pig1 = pigment {
  gradient <0, 1, 0>
  frequency int(48 * 0.75)
  pigment_map {
    [ 0.05 pic_line_pig ]
    [ 0.05 pic_pig1_b ]
  }
}


plane { // floor
  <0, 1, 0>, 0
  pigment {
    pic_pig1
    translate <-0.5, 0, 0>
    scale <4/3, 1, 1>
    scale 5
    rotate x*90
  }
  finish { ambient 0.2 diffuse 0.3 }
}


// stuff for uv mapped octohedron
#declare s3 = sqrt(3) * (1/8);


#declare octo = mesh { // octhedron
  triangle { // back upper left
    <0, 0, 1>, <0, 1, 0>, <-1, 0, 0>
    uv_vectors <0, 0.5>, <1/8, 0.5 + s3>, <1/4, 0.5>
  }
  triangle { // front upper left
    <-1, 0, 0>, <0, 1, 0>, <0, 0, -1>
    uv_vectors <1/4, 0.5>, <(1/4) + (1/8), 0.5 + s3>, <2/4, 0.5>
  }
  triangle { // front upper right
    <0, 0, -1>, <0, 1, 0>, <1, 0, 0>
    uv_vectors <2/4, 0.5>, <(2/4) + (1/8), 0.5 + s3>, <3/4, 0.5>
  }
  triangle { // rear upper right
    <1, 0, 0>, <0, 1, 0>, <0, 0, 1>
    uv_vectors <3/4, 0.5>, <(3/4) + (1/8), 0.5 + s3>, <1, 0.5>
  }
  triangle { // rear lower left
    <0, 0, 1>, <0, -1, 0>, <-1, 0, 0>
    uv_vectors <0, 0.5>, <(1/8), 0.5 - s3>, <1/4, 0.5>
  }
  triangle { // front lower left
    <-1, 0, 0>, <0, -1, 0>, <0, 0, -1>
    uv_vectors <1/4, 0.5>, <(1/4) + (1/8), 0.5 - s3>, <2/4, 0.5>
  }
  triangle { // front lower right
    <0, 0, -1>, <0, -1, 0>, <1, 0, 0>
    uv_vectors <2/4, 0.5>, <(2/4) + (1/8), 0.5 - s3>, <3/4, 0.5>
  }
  triangle { // rear lower right
    <1, 0, 0>, <0, -1, 0>, <0, 0, 1>
    uv_vectors <3/4, 0.5>, <(3/4) + (1/8), 0.5 - s3>, <1, 0.5>
  }
}


object {
  octo
  pigment {
    uv_mapping
    pic_pig1
    translate <0, -0.5, 0>
    scale <1, 3/4, 1>
    translate <0, 0.5, 0>
  }
  finish { ambient 0.5 diffuse 0.5 }
  translate <0, 1, 0>
  scale 1.3
  translate <3.0, 0, 0.2>
}


// stuff for 14-site shape, like in smaller space stations in Frontier
#declare sqrt2 = sqrt(2); // pre-calculate to speed things up a hair
#declare sqrt3 = sqrt(3);
#declare off2 = sqrt2 + 1;
#declare off3 = sqrt2 * 2 + 2;
#declare off4 = sqrt2 * 3 + 3;
#declare ft = 0.01; // frame thickness


#declare s14 = mesh {
  // gotta do the triangles in the same order as the UV, or else
  // it will get even more confusing.
  // left most square of UV will correspond to the left square facet ...
  triangle {
    <-sqrt2, 0,         sqrt2 / 2>,
    <-sqrt2, sqrt2 / 2, 0>,
    <-sqrt2, 0,         -sqrt2 / 2>
    uv_vectors <0, 0>, <sqrt2 / 2, sqrt2 / 2>, <sqrt2, 0>
  }
  triangle {
    <-sqrt2, 0,         sqrt2 / 2>,
    <-sqrt2, 0,        -sqrt2 / 2>,
    <-sqrt2, -sqrt2 / 2, 0>
    uv_vectors <0, 0>, <sqrt2, 0>, <sqrt2 / 2, -sqrt2 / 2>
  }
  // upper left near hexagon
  triangle {
    <-sqrt2, sqrt2 / 2, 0>, <-sqrt2 / 2, sqrt2, 0>, <0, sqrt2, -sqrt2 / 2>
    uv_vectors
    <sqrt2 - 0.5, sqrt3 / 2>, <sqrt2, sqrt3>, <sqrt2 + 1, sqrt3>
  }
  triangle {
    <-sqrt2, sqrt2 / 2, 0>, <0, sqrt2, -sqrt2 / 2>, <0, sqrt2 / 2, -sqrt2>
    uv_vectors
    <sqrt2 - 0.5, sqrt3 / 2>, <sqrt2 + 1, sqrt3>, <sqrt2 + 1.5, sqrt3/2>
  }
  triangle {
    <-sqrt2, sqrt2 / 2, 0>, <0, sqrt2 / 2, -sqrt2>, <-sqrt2 / 2, 0, -sqrt2>
    uv_vectors
    <sqrt2 - 0.5, sqrt3 / 2>, <sqrt2 + 1.5, sqrt3/2>, <sqrt2 + 1, 0>
  }
  triangle {
    <-sqrt2, sqrt2 / 2, 0>, <-sqrt2 / 2, 0, -sqrt2>, <-sqrt2, 0, -sqrt2 / 2>
    uv_vectors
    <sqrt2 - 0.5, sqrt3 / 2>, <sqrt2 + 1, 0>, <sqrt2, 0>
  }
  // lower near left hexagon
  triangle {
    <-sqrt2, -sqrt2 / 2, 0>, <-sqrt2, 0, -sqrt2 / 2>, <-sqrt2 / 2, 0, -sqrt2>
    uv_vectors <sqrt2 - 0.5, -sqrt3 / 2>, <sqrt2, 0>, <sqrt2 + 1, 0>
  }
  triangle {
    <-sqrt2, -sqrt2 / 2, 0>, <-sqrt2 / 2, 0, -sqrt2>, <0, -sqrt2 / 2, -sqrt2>
    uv_vectors
    <sqrt2 - 0.5, -sqrt3 / 2>, <sqrt2 + 1, 0>, <sqrt2 + 1.5, -sqrt3/2>
  }
  triangle {
    <-sqrt2, -sqrt2 / 2, 0>, <0, -sqrt2 / 2, -sqrt2>,  <0, -sqrt2, -sqrt2 / 2>
    uv_vectors
    <sqrt2 - 0.5, -sqrt3 / 2>, <sqrt2 + 1.5, -sqrt3/2>, <sqrt2 + 1, -sqrt3>
  }
  triangle {
    <-sqrt2, -sqrt2 / 2, 0>, <0, -sqrt2, -sqrt2 / 2>, <-sqrt2 / 2, -sqrt2, 0>
    uv_vectors
    <sqrt2 - 0.5, -sqrt3 / 2>, <sqrt2 + 1, -sqrt3>, <sqrt2, -sqrt3>
  }
  // front square
  triangle {
    <-sqrt2 / 2, 0, -sqrt2>, <0, sqrt2 / 2, -sqrt2>, <sqrt2 / 2, 0, -sqrt2>
    uv_vectors
    <off2, 0>, <off2 + sqrt2 / 2, sqrt2 / 2>, <off2 + sqrt2, 0>
  }
  triangle {
    <-sqrt2 / 2, 0, -sqrt2>, <sqrt2 / 2, 0, -sqrt2>, <0, -sqrt2 / 2, -sqrt2>
    uv_vectors
    <off2, 0>, <off2 + sqrt2, 0>, <off2 + sqrt2 / 2, -sqrt2 / 2>
  }
  // upper near right hexagon
  triangle {
    <0, sqrt2 / 2, -sqrt2>, <0, sqrt2, -sqrt2 / 2>, <sqrt2 / 2, sqrt2, 0>
    uv_vectors
    <off2 + sqrt2 - 0.5, sqrt3 / 2>, <off2 + sqrt2, sqrt3>, <off2 + sqrt2 + 1, sqrt3>
  }
  triangle {
    <0, sqrt2 / 2, -sqrt2>, <sqrt2 / 2, sqrt2, 0>, <sqrt2, sqrt2 / 2, 0>
    uv_vectors
    <off2 + sqrt2 - 0.5, sqrt3 / 2>, <off2 + sqrt2 + 1, sqrt3>, <off2 + sqrt2 + 1.5, sqrt3/2>
  }
  triangle {
    <0, sqrt2 / 2, -sqrt2>, <sqrt2, sqrt2 / 2, 0>, <sqrt2, 0, -sqrt2 / 2>
    uv_vectors
    <off2 + sqrt2 - 0.5, sqrt3 / 2>, <off2 + sqrt2 + 1.5, sqrt3/2>, <off2 + sqrt2 + 1, 0>
  }
  triangle {
    <0, sqrt2 / 2, -sqrt2>, <sqrt2, 0, -sqrt2 / 2>, <sqrt2 / 2, 0, -sqrt2>
    uv_vectors
    <off2 + sqrt2 - 0.5, sqrt3 / 2>, <off2 + sqrt2 + 1, 0>, <off2 + sqrt2, 0>
  }
  // lower near right hexagon  
  triangle {
    <0, -sqrt2 / 2, -sqrt2>, <sqrt2 / 2, 0, -sqrt2>, <sqrt2, 0, -sqrt2 / 2>
    uv_vectors
    <off2 + sqrt2 - 0.5, -sqrt3 / 2>, <off2 + sqrt2, 0>, <off2 + sqrt2 + 1, 0>
  }
  triangle {
    <0, -sqrt2 / 2, -sqrt2>, <sqrt2, 0, -sqrt2 / 2>, <sqrt2, -sqrt2 / 2, 0>
    uv_vectors
    <off2 + sqrt2 - 0.5, -sqrt3 / 2>, <off2 + sqrt2 + 1, 0>, <off2 + sqrt2 + 1.5, -sqrt3/2>
  }
  triangle {
    <0, -sqrt2 / 2, -sqrt2>, <sqrt2, -sqrt2 / 2, 0>, <sqrt2 / 2, -sqrt2, 0>
    uv_vectors
    <off2 + sqrt2 - 0.5, -sqrt3 / 2>, <off2 + sqrt2 + 1.5, -sqrt3/2>, <off2 + sqrt2 + 1, -sqrt3>
  }
  triangle {
    <0, -sqrt2 / 2, -sqrt2>, <sqrt2 / 2, -sqrt2, 0>, <0, -sqrt2, -sqrt2 / 2>
    uv_vectors
    <off2 + sqrt2 - 0.5, -sqrt3 / 2>, <off2 + sqrt2 + 1, -sqrt3>, <off2 + sqrt2, -sqrt3>
  }
  // right square
  triangle {
    <sqrt2, 0, -sqrt2 / 2>, <sqrt2, sqrt2 / 2, 0>, <sqrt2, 0, sqrt2 / 2>
    uv_vectors
    <off3, 0>, <off3 + sqrt2 / 2, sqrt2 / 2>, <off3 + sqrt2, 0>
  }
  triangle {
    <sqrt2, 0, -sqrt2 / 2>, <sqrt2, 0, sqrt2 / 2>, <sqrt2, -sqrt2 / 2, 0>
    uv_vectors
    <off3, 0>, <off3 + sqrt2, 0>, <off3 + sqrt2 / 2, -sqrt2 / 2>
  }
  // rear upper right hexagon
  triangle {
    <sqrt2, sqrt2 / 2, 0>, <sqrt2 / 2, sqrt2, 0>, <0, sqrt2, sqrt2 / 2>
    uv_vectors
    <off3 + sqrt2 - 0.5, sqrt3 / 2>, <off3 + sqrt2, sqrt3>, <off3 + sqrt2 + 1, sqrt3>
  }
  triangle {
    <sqrt2, sqrt2 / 2, 0>, <0, sqrt2, sqrt2 / 2>, <0, sqrt2 / 2, sqrt2>
    uv_vectors
    <off3 + sqrt2 - 0.5, sqrt3 / 2>, <off3 + sqrt2 + 1, sqrt3>, <off3 + sqrt2 + 1.5, sqrt3/2>
  }
  triangle {
    <sqrt2, sqrt2 / 2, 0>, <0, sqrt2 / 2, sqrt2>, <sqrt2 / 2, 0, sqrt2>
    uv_vectors
    <off3 + sqrt2 - 0.5, sqrt3 / 2>, <off3 + sqrt2 + 1.5, sqrt3/2>, <off3 + sqrt2 + 1, 0>
  }
  triangle {
    <sqrt2, sqrt2 / 2, 0>, <sqrt2 / 2, 0, sqrt2>, <sqrt2, 0, sqrt2 / 2>
    uv_vectors
    <off3 + sqrt2 - 0.5, sqrt3 / 2>, <off3 + sqrt2 + 1, 0>, <off3 + sqrt2, 0>
  }
  // rear lower right hexagon
  triangle {
    <sqrt2, -sqrt2 / 2, 0>, <sqrt2, 0, sqrt2 / 2>, <sqrt2 / 2, 0, sqrt2>
    uv_vectors
    <off3 + sqrt2 - 0.5, -sqrt3 / 2>, <off3 + sqrt2, 0>, <off3 + sqrt2 + 1, 0>
  }
  triangle {
    <sqrt2, -sqrt2 / 2, 0>, <sqrt2 / 2, 0, sqrt2>, <0, -sqrt2 / 2, sqrt2>
    uv_vectors
    <off3 + sqrt2 - 0.5, -sqrt3 / 2>, <off3 + sqrt2 + 1, 0>, <off3 + sqrt2 + 1.5, -sqrt3/2>
  }
  triangle {
    <sqrt2, -sqrt2 / 2, 0>, <0, -sqrt2 / 2, sqrt2>, <0, -sqrt2, sqrt2 / 2>
    uv_vectors
    <off3 + sqrt2 - 0.5, -sqrt3 / 2>, <off3 + sqrt2 + 1.5, -sqrt3/2>, <off3 + sqrt2 + 1, -sqrt3>
  }
  triangle {
    <sqrt2, -sqrt2 / 2, 0>, <0, -sqrt2, sqrt2 / 2>, <sqrt2 / 2, -sqrt2, 0>
    uv_vectors
    <off3 + sqrt2 - 0.5, -sqrt3 / 2>, <off3 + sqrt2 + 1, -sqrt3>, <off3 + sqrt2, -sqrt3>
  }
  // rear square
  triangle {
    <sqrt2 / 2, 0, sqrt2>, <0, sqrt2 / 2, sqrt2>, <-sqrt2 / 2, 0, sqrt2>
    uv_vectors
    <off4, 0>, <off4 + sqrt2 / 2, sqrt2 / 2>, <off4 + sqrt2, 0>
  }
  triangle {
    <sqrt2 / 2, 0, sqrt2>, <-sqrt2 / 2, 0, sqrt2>, <0, -sqrt2 / 2, sqrt2>
    uv_vectors
    <off4, 0>, <off4 + sqrt2, 0>, <off4 + sqrt2 / 2, -sqrt2 / 2>
  }
  // upper rear left hexagon
  triangle {
    <0, sqrt2 / 2, sqrt2>, <0, sqrt2, sqrt2 / 2>, <-sqrt2 / 2, sqrt2, 0>
    uv_vectors
    <off4 + sqrt2 - 0.5, sqrt3 / 2>, <off4 + sqrt2, sqrt3>, <off4 + sqrt2 + 1, sqrt3>
  }
  triangle {
    <0, sqrt2 / 2, sqrt2>, <-sqrt2 / 2, sqrt2, 0>, <-sqrt2, sqrt2 / 2, 0>
    uv_vectors
    <off4 + sqrt2 - 0.5, sqrt3 / 2>, <off4 + sqrt2 + 1, sqrt3>, <off4 + sqrt2 + 1.5, sqrt3/2>
  }
  triangle {
    <0, sqrt2 / 2, sqrt2>, <-sqrt2, sqrt2 / 2, 0>, <-sqrt2, 0, sqrt2 / 2>
    uv_vectors
    <off4 + sqrt2 - 0.5, sqrt3 / 2>, <off4 + sqrt2 + 1.5, sqrt3/2>, <off4 + sqrt2 + 1, 0>
  }
  triangle {
    <0, sqrt2 / 2, sqrt2>, <-sqrt2, 0, sqrt2 / 2>, <-sqrt2 / 2, 0, sqrt2>
    uv_vectors
    <off4 + sqrt2 - 0.5, sqrt3 / 2>, <off4 + sqrt2 + 1, 0>, <off4 + sqrt2, 0>
  }
  // lower rear left hexagon (last hexagon! yea!)
  triangle {
    <0, -sqrt2 / 2, sqrt2>, <-sqrt2 / 2, 0, sqrt2>, <-sqrt2, 0, sqrt2 / 2>
    uv_vectors
    <off4 + sqrt2 - 0.5, -sqrt3 / 2>, <off4 + sqrt2, 0>, <off4 + sqrt2 + 1, 0>
  }
  triangle {
    <0, -sqrt2 / 2, sqrt2>, <-sqrt2, 0, sqrt2 / 2>, <-sqrt2, -sqrt2 / 2, 0>
    uv_vectors
    <off4 + sqrt2 - 0.5, -sqrt3 / 2>, <off4 + sqrt2 + 1, 0>, <off4 + sqrt2 + 1.5, -sqrt3/2>
  }
  triangle {
    <0, -sqrt2 / 2, sqrt2>, <-sqrt2, -sqrt2 / 2, 0>, <-sqrt2 / 2, -sqrt2, 0>
    uv_vectors
    <off4 + sqrt2 - 0.5, -sqrt3 / 2>, <off4 + sqrt2 + 1.5, -sqrt3/2>, <off4 + sqrt2 + 1, -sqrt3>
  }
  triangle {
    <0, -sqrt2 / 2, sqrt2>, <-sqrt2 / 2, -sqrt2, 0>, <0, -sqrt2, sqrt2 / 2>
    uv_vectors
    <off4 + sqrt2 - 0.5, -sqrt3 / 2>, <off4 + sqrt2 + 1, -sqrt3>, <off4 + sqrt2, -sqrt3>
  }
  // top square
  triangle {
    <-sqrt2 / 2, sqrt2, 0>, <0, sqrt2, sqrt2 / 2>, <sqrt2 / 2, sqrt2, 0>
    uv_vectors
    <off2 + sqrt2, sqrt3 + 1>, <off2 + sqrt2 + 1, sqrt3 + 1>, <off3, sqrt3>
  }
  triangle {
    <-sqrt2 / 2, sqrt2, 0>, <sqrt2 / 2, sqrt2, 0>, <0, sqrt2, -sqrt2 / 2>
    uv_vectors
    <off2 + sqrt2, sqrt3 + 1>, <off3, sqrt3>, <off2 + sqrt2, sqrt3>
  }
  // bottom (and last!) square
  triangle {
    <0, -sqrt2, -sqrt2 / 2>, <sqrt2 / 2, -sqrt2, 0>, <0, -sqrt2, sqrt2 / 2>
    uv_vectors
    <off2 + sqrt2, -sqrt3>, <off3, -sqrt3>, <off3, -sqrt3 - 1>
  }
  triangle {
    <0, -sqrt2, -sqrt2 / 2>, <0, -sqrt2, sqrt2 / 2>, <-sqrt2 / 2, -sqrt2, 0>
    uv_vectors
    <off2 + sqrt2, -sqrt3>, <off3, -sqrt3 - 1>, <off2 + sqrt2, -sqrt3 - 1>
  }
}


object {
  s14
  pigment {
    uv_mapping
    pic_pig1
    translate <0, -0.5, 0>
    scale <(4/3), 1, 1> // aspect/size of image
    scale ((sqrt2 + 1) * 4 + 0.5) * (3/4)
  }
  finish { ambient 0.5 diffuse 0.5 }
  translate <0, sqrt2, 0>
  scale 0.9
  //rotate y*-10
  translate <3.2, 0, 4>
}


// now for a 20 sided
#declare vertex_length = vlength(
  (
     <cos(0), 0, sin(0)> -
     <cos(radians(72)), 0, sin(radians(72))>
  )
);


// use trial-and-error to determine point coords
#declare low_guess = 0.1;
#declare high_guess = 1;
#while ((high_guess - low_guess) > 0.0001)
  #declare mid_guess = (high_guess + low_guess) / 2;
  #declare first_point = <cos(0), mid_guess, sin(0)>;
  #declare second_point = <cos(radians(72 * 2)), -mid_guess, sin(radians(72 * 2))>;
  #declare guess_score = vlength((second_point - first_point)); // close are we?
  #if (guess_score > vertex_length)
    #declare low_guess = (low_guess + mid_guess) /2; // guess too high
  #else
    #declare low_guess = (high_guess + mid_guess) /2; // guess too low
  #end
#end
#declare t1_height = mid_guess / 2;
#debug concat("t1_height: ", str(t1_height, 0, 5), "\n")


// almost done.  Need one more coordinate - the Y coord of the "polar" point
#declare t2_height = 1 + (t1_height * t1_height);
#declare t2_height = sqrt(t2_height);
#debug concat("t2_height: ", str(t2_height, 0, 5), "\n")


#declare uv_tri_h = sqrt(3) * (1 / 2) * (1/5.5) * 0.5; // last number is fudge
#macro rad5(fiver_in)
  #local rad5_result = ((fiver_in * 2 * pi) / 5);
  rad5_result
#end


#declare s20_uv = mesh { // actually, 20 sided, not 12
  #declare cc = 0;
  #while (cc < 5)
    triangle { // bottom
      <-sin(rad5(cc)), -t1_height, cos(rad5(cc))>,
      <0, -t2_height, 0>,
      <-sin(rad5(cc + 1)), -t1_height, cos(rad5(cc + 1))>
      uv_vectors
      <cc / 5.5, -uv_tri_h>, <(cc + 0.5) / 5.5, -uv_tri_h * 3>, <(cc + 1) / 5.5, -uv_tri_h>
    }
    triangle { // middle bottom
      <-sin(rad5(cc)), -t1_height, cos(rad5(cc))>,
      <-sin(rad5(cc + 0.5)), t1_height, cos(rad5(cc + 0.5))>,
      <-sin(rad5(cc + 1)), -t1_height, cos(rad5(cc + 1))>      
      uv_vectors
      <cc / 5.5, -uv_tri_h>, <(cc + 0.5) / 5.5, uv_tri_h>, <(cc + 1) / 5.5, -uv_tri_h>
    }
    triangle { // middle upper
      <-sin(rad5(cc + 0.5)), t1_height, cos(rad5(cc + 0.5))>,
      <-sin(rad5(cc + 1.5)), t1_height, cos(rad5(cc + 1.5))>,
      <-sin(rad5(cc + 1)), -t1_height, cos(rad5(cc + 1))>
      uv_vectors
      <(cc + 0.5) / 5.5, uv_tri_h>,
      <(cc + 1.5) / 5.5, uv_tri_h>,
      <(cc + 1) / 5.5, -uv_tri_h>
    }
    triangle { // upper
      <-sin(rad5(cc + 0.5)), t1_height, cos(rad5(cc + 0.5))>,
      <0, t2_height, 0>,
      <-sin(rad5(cc + 1.5)), t1_height, cos(rad5(cc + 1.5))>
      uv_vectors
      <(cc + 0.5) / 5.5, uv_tri_h>,
      <(cc + 1) / 5.5, uv_tri_h * 3>,
      <(cc + 1.5) / 5.5, uv_tri_h>
    }
    #declare cc = cc + 1;
  #end
}


// figure out how to rotate shape to get one face flat on the ground
#declare f1 = <sin(0), -t1_height, cos(0)>;
#declare f2 = <sin(radians(72)), -t1_height, cos(radians(72))>;
#declare f3 = <0, -t2_height, 0>;
#declare f4 = f3 - ((f1 + f2) / 2);
#declare rot_amount = degrees(asin(abs(f4.y) / vlength(f4)));


object {
  s20_uv
  pigment {
    uv_mapping
    pic_pig1
    scale <1, 3/4, 1>
    translate <0, -0.5 * (3/4), 0>
  }
  finish { ambient 0.5 diffuse 0.5 }
  scale 2
  rotate y*72
  rotate x*-rot_amount
  rotate y*-36
  //rotate y*180
  translate <0, 1.76, 0> // line up with floor
  scale 0.7
  translate <0, 0, 4>
}


#declare p_height1 = sin(radians(36));
#declare p_height2 = cos(radians(18));
#declare p_width = cos(radians(36));


#macro do_pente_plus(pt_array, uv_array) // 5 (x,y,z) points, in CLOCKWISE order from first point
  triangle {
    pt_array[0], pt_array[1], pt_array[2]
    uv_vectors
    uv_array[0], uv_array[1], uv_array[2]
  }
  triangle {
    pt_array[0], pt_array[2], pt_array[3]
    uv_vectors
    uv_array[0], uv_array[2], uv_array[3]
  }
  triangle {
    pt_array[0], pt_array[3], pt_array[4]
    uv_vectors
    uv_array[0], uv_array[3], uv_array[4]
  }
#end


#declare uvp_result = array[5]
#declare uvp_result[0] = <1, 1>;  // force it to be an array of 2-vectors


#macro uv_point_down(start_pt) // start_pt must be a 2-vector
  #local OF = start_pt + <0, -p_height1 / 2>;
  #declare uvp_result[0] = OF + <0, p_height1 / 2>;
  #declare uvp_result[1] = OF + <p_width - 0.5, p_height1 / 2 + p_height2>;
  #declare uvp_result[2] = OF + <(p_width - 0.5) + 1, p_height1 / 2 + p_height2>;
  #declare uvp_result[3] = OF + <p_width * 2, p_height1 / 2>;
  #declare uvp_result[4] = OF + <p_width, -p_height1 / 2>;
#end


#macro uv_point_up(start_pt) // start_pt must be a 2-vector
  #local OF = start_pt;
  #declare uvp_result[0] = OF;
  #declare uvp_result[1] = OF + <p_width, p_height1>;
  #declare uvp_result[2] = OF + <p_width * 2, 0>;
  #declare uvp_result[3] = OF + <p_width * 2 - (p_width - 0.5), -p_height2>;
  #declare uvp_result[4] = OF + <p_width - 0.5, -p_height2>;
#end


/* We have the coords to lay a pentagon flat on the floor.  From
   this we try to develop the points for the side pentagons.  From
   that info we can dermine the y coords of the top pentagon */
// first - conside the pentagon on the floor, set so that each
// segment is 1 unit in length.  Now get the distance from the
// center to any vertex
#declare pent_radius = 0.5 / (sin(radians(36)));
#debug concat("pent_radius: ", str(pent_radius, 6, 6), "\n")
// now consider a side pentagon.  It will have two points on the
// floor, two points on the lower equator, and one point on the upper
// equator.  We'll look now at the two lower equator points
#declare pent_radius2 = p_width / (sin(radians(36)));
#debug concat("pent_radius2: ", str(pent_radius2, 6, 6), "\n")
// now use the existing information
// to derive the Y coordinate of any lower equator point
// use pythagorean to avoid trig this once
#declare lower_e_Y = (pent_radius2 - pent_radius);
#declare lower_e_Y = lower_e_Y * lower_e_Y;
#declare lower_e_Y = 1 - lower_e_Y;  // hypotenuse is one (its the edge of a hexagon
#declare lower_e_Y = sqrt(lower_e_Y); // pythag.  This is the Y coord now
#debug concat("lower_e_Y: ", str(lower_e_Y, 6, 6), "\n")
// strange.  lower_e_Y ends up being equal to pent_radius.  
// If that is correct, this shape is even weirder than I thought it was.
// It's already weird because of the Golden Ratio connects!!

// Now figure out upper_e (upper point of lower side pentagon).
// pythag again.
#declare upper_e_Y = p_width * p_width;
#declare upper_e_Y = 1 - upper_e_Y;
#declare upper_e_Y = sqrt(upper_e_Y);
#declare upper_e_Y = lower_e_Y + upper_e_Y;
#debug concat("upper_e_Y: ", str(upper_e_Y, 6, 6), "\n")

// right.  from that, we can calculate the Y coord of the
// top pentagon (whcih is also used for the upper point-down side
// pentagons
#declare top_Y = upper_e_Y + lower_e_Y;

// wow.  and we didn't have to go hueristic.  Cool.

// lets see if it works.  build it now.
#declare s12_uv = mesh {
  do_pente_plus( // bottom pentagon - point faces camera
    array[5]{
      pent_radius * <sin(radians(72 * 4)), 0, -cos(radians(72 * 4))>,
      pent_radius * <sin(radians(0)), 0, -cos(radians(0))>,
      pent_radius * <sin(radians(72)), 0, -cos(radians(72))>,
      pent_radius * <sin(radians(72 * 2)), 0, -cos(radians(72 * 2))>,
      pent_radius * <sin(radians(72 * 3)), 0, -cos(radians(72 * 3))>
    },
    // uv_vectors
    uv_point_up(<4 * p_width, -1.65>)
    uvp_result
  )
  // five lower side pentagons.  Relative to the UV mapping space,
  // these are point up
  #declare roty = -2 * 72;
  #while (roty < (72 * 3))
    do_pente_plus(
      array[5]{
        <pent_radius2 * sin(radians(roty)), lower_e_Y, pent_radius2 * -cos(radians(roty))>,
        <pent_radius2 * sin(radians(roty + 36)), upper_e_Y, pent_radius2 * -cos(radians(roty + 36))>,
        <pent_radius2 * sin(radians(roty + 72)), lower_e_Y, pent_radius2 * -cos(radians(roty + 72))>,
        <pent_radius * sin(radians(roty + 72)), 0, pent_radius * -cos(radians(roty + 72))>,
        <pent_radius * sin(radians(roty)), 0, pent_radius * -cos(radians(roty))>
      },
      // uv_vectors
      uv_point_up(<((2 + (roty / 72)) + 0.5) * 2 * p_width, -p_height1 / 2>)
      uvp_result
    )
    #declare roty = roty + 72;
  #end
  // five upper side pentagons.  Relative to the UV mapping space,
  // these are point down
  #declare roty = -2 * 72;
  #while (roty < (3 * 72))
    do_pente_plus(
      array[5]{
        <pent_radius2 * sin(radians(roty - 36)), upper_e_Y, pent_radius2 * -cos(radians(roty - 36))>,
        <pent_radius * sin(radians(roty - 36)), top_Y, pent_radius * -cos(radians(roty - 36))>,
        <pent_radius * sin(radians(roty + 36)), top_Y, pent_radius * -cos(radians(roty + 36))>,
        <pent_radius2 * sin(radians(roty + 36)), upper_e_Y, pent_radius2 * -cos(radians(roty + 36))>,
        <pent_radius2 * sin(radians(roty)), lower_e_Y, pent_radius2 * -cos(radians(roty))>,
      },
      // uv_vectors
      uv_point_down(<((roty / 72) + 2) * 2 * p_width, p_height1 / 2>)
      uvp_result
    )
    #declare roty = roty + 72;
  #end
  do_pente_plus( // upper pentagon - point faced away from camera
    array[5]{
      <pent_radius * sin(radians(-72 - 36)),      top_Y, pent_radius * -cos(radians(-72 - 36))>,
      <pent_radius * sin(radians((2 * 72) + 36)), top_Y, pent_radius * -cos(radians((2 * 72) + 36))>,
      <pent_radius * sin(radians(72 + 36)),       top_Y, pent_radius * -cos(radians(72 + 36))>,
      <pent_radius * sin(radians(36)),            top_Y, pent_radius * -cos(radians(36))>,
      <pent_radius * sin(radians(-36)),           top_Y, pent_radius * -cos(radians(-36))>
    },
    // uv_vectors - -0.4 is a kludge
    uv_point_up(<4.5 * p_width - 0.4, p_height1 / 2 + p_height2 * 2>)
    uvp_result
  )
}


object {
  s12_uv
  pigment {
    uv_mapping
    pic_pig1
    translate <0, -0.5, 0>
    scale p_width * 11
    scale <1, 3/4, 1>
  }
  finish { ambient 0.5 diffuse 0.5 }
  //translate <0, -top_Y / 2, 0>
  translate <-3.2, 0, 4>
}


// hexahedron (box)
// interestingly enough, the built in povray UV mapping for 
// the box object maps the picture backwards!  (left-right reversed)
// So this is a box built with a mesh instead of a box
mesh {
  // front
  triangle {
    <-0.5, 0.5, -0.5>, <0.5, 0.5, -0.5>, <0.5, -0.5, -0.5>
    uv_vectors
    <1, 2>, <2, 2>, <2, 1>
  }
  triangle {
    <-0.5, 0.5, -0.5>, <0.5, -0.5, -0.5>, <-0.5, -0.5, -0.5>
    uv_vectors
    <1, 2>, <2, 1>, <1, 1>
  }
  // bottom
  triangle {
    <-0.5, -0.5, -0.5>, <0.5, -0.5, -0.5>, <0.5, -0.5, 0.5>
    uv_vectors
    <1, 1>, <2, 1>, <2, 0>
  }
  triangle {
    <-0.5, -0.5, -0.5>, <0.5, -0.5, 0.5>, <-0.5, -0.5, 0.5>
    uv_vectors
    <1, 1>, <2, 0>, <1, 0>
  }
  // left side
  triangle {
    <-0.5, 0.5, 0.5>, <-0.5, 0.5, -0.5>, <-0.5, -0.5, -0.5>
    uv_vectors
    <0, 2>, <1, 2>, <1, 1>
  }
  triangle {
    <-0.5, 0.5, 0.5>, <-0.5, -0.5, -0.5>, <-0.5, -0.5, 0.5>
    uv_vectors
    <0, 2>, <1, 1>, <0, 1>
  }
  // top
  triangle {
    <-0.5, 0.5, 0.5>, <0.5, 0.5, 0.5>, <0.5, 0.5, -0.5>
    uv_vectors
    <1, 3>, <2, 3>, <2, 2>
  }
  triangle {
    <-0.5, 0.5, 0.5>, <0.5, 0.5, -0.5>, <-0.5, 0.5, -0.5>
    uv_vectors
    <1, 3>, <2, 2>, <1, 2>
  }
  // right side
  triangle {
    <0.5, 0.5, -0.5>, <0.5, 0.5, 0.5>, <0.5, -0.5, 0.5>
    uv_vectors
    <2, 2>, <3, 2>, <3, 1>
  }
  triangle {
    <0.5, 0.5, -0.5>, <0.5, -0.5, 0.5>, <0.5, -0.5, -0.5>
    uv_vectors
    <2, 2>, <3, 1>, <2, 1>
  }
  // back
  triangle {
    <0.5, 0.5, 0.5>, <-0.5, 0.5, 0.5>, <-0.5, -0.5, 0.5>
    uv_vectors
    <3, 2>, <4, 2>, <4, 1>
  }
  triangle {
    <0.5, 0.5, 0.5>, <-0.5, -0.5, 0.5>, <0.5, -0.5, 0.5>
    uv_vectors
    <3, 2>, <4, 1>, <3, 1>
  }
  pigment {
    uv_mapping
    pic_pig1
    scale 4
  }
  finish { ambient 0.6 diffuse 0.4 }
  translate <0, 0.501, 0>
  scale 1.5
  rotate y*80
  translate <0, 0, 0.4>
}


// for completeness, a tetrahedron
#declare tetra_top = vlength(<0.5, 0, -sqrt3 / 6>);
#declare tetra_top = tetra_top * tetra_top;
#declare tetra_top = 1 - tetra_top;
#declare tetra_top = sqrt(tetra_top);
mesh {
  triangle { // base (bottom)
    <0, 0, sqrt3 / 3>, // back point
    <0.5, 0, sqrt3 / -6>, // front right point
    <-0.5, 0, sqrt3 / -6> // front left point
    uv_vectors
    <1.5, -sqrt3 * 0.5>,
    <2, 0>,
    <1, 0>
  }
  triangle { // front
    <-0.5, 0, -sqrt3 / 6>,
    <0, tetra_top, 0>,
    <0.5, 0, -sqrt3 / 6>
    uv_vectors
    <1, 0>,
    <1.5, sqrt3 * 0.5>,
    <2, 0>
  }
  triangle { // right back
    <0.5, 0, -sqrt3 / 6>,
    <0, tetra_top, 0>,
    <0, 0, sqrt3 / 3>
    uv_vectors
    <2, 0>,
    <2.5, sqrt3 * 0.5>,
    <3, 0>
  }
  triangle { // left rear
    <0, 0, sqrt3 / 3>,
    <0, tetra_top, 0>,
    <-0.5, 0, -sqrt3 / 6>
    uv_vectors
    <0, 0>,
    <0.5, sqrt3 * 0.5>,
    <1, 0>
  }
  pigment {
    uv_mapping
    pic_pig1
    translate <0, -0.5, 0>
    scale <1, 3/4, 1>
    scale 3
  }
  finish { ambient 0.5 diffuse 0.5 }
  scale 2.3
  rotate y*34
  translate <-3.1, 0.01, 0.7>
}


light_source {
  <-3000, 3000, -2000>
  color rgb 1
}


/* actual end of this file */