#include "colors.inc"
#include "finish.inc"
#include "woods.inc"
#include "stones.inc"

//-------------------
#declare ImageQ = 1;     // 0-1 Image Quality
#declare CamNum = 2;     // 1-2 Camera Position
#declare RadOn = 0;     // 0-1 Radiosity
//-------------------

#if (RadOn = 1)
  global_settings { radiosity {
    brightness 3.3
    count 100 //300
    distance_maximum 5.1
    error_bound 0.4 //0.3
    gray_threshold 0.5 //0.4?
    low_error_factor 0.8
    minimum_reuse 0.015 //<0.02
    nearest_count 6 //10
    recursion_limit 1 //2
  }}
#end

#declare WhiteTex = texture {
  T_Wood10
  finish { Glossy }
  scale 0.9
  rotate <37,-40,0>
}
#declare BlackTex = texture {
  T_Wood17
  finish { Glossy }
  scale 0.94
  rotate <45,45,0>
}
#declare SquareX = 2;
#declare HomeSquare = <-SquareX/2,0,-SquareX/2>;

camera {
  #if (CamNum = 1)
    location <4.7,9.5,-24>
    look_at <0.2,1.25,0>
    angle 11
  #end
  #if (CamNum = 2)
    location <0,8,-35>
    look_at <0,1.65,0>
    angle 21.6
  #end
}

// CHESS PIECE COMPONENTS
#declare PieceWid = 0.5;
#declare PieceHite = PieceWid*2.9;
#declare BaseHite = PieceWid*0.5;

#declare PawnBase = difference {
  cylinder {
    <0,0,0>,
    <0,BaseHite,0>,
    PieceWid
  }
  difference {
    cylinder {
      <0,0,0>,
      <0,PieceWid*1.1,0>,
      PieceWid*1.1
    }
    cone {
      <0,-0.0001,0>,
      PieceWid*1.1,
      <0,PieceWid*1.1,0>,
      0.0001
    }
    translate <0,PieceWid*0.28,0>
  }
}
#declare PTorusMaj = PieceWid*0.73;
#declare PTorusMin = PieceWid/8;
#declare PTorus = union {
  torus {
    PTorusMaj,
    PTorusMin
  }
  cylinder {
    <0,-PTorusMin,0>,
    <0,PTorusMin,0>,
    PTorusMaj
  }
}

#declare Torus1Y = PieceHite*0.21;
#declare Torus2Y = PieceHite*0.8;
#declare TwoTori = union {
  object { PTorus translate <0,Torus1Y,0> }
  object { PTorus translate <0,Torus2Y,0> }
}

#declare Shank = difference {
  cylinder {
    <0,Torus1Y,0>,
    <0,Torus2Y,0>
    PTorusMaj*1.12
  }
  torus {
    PieceWid*1.675,//1.67
    PieceWid*1.15
    translate <0,(Torus1Y+Torus2Y)/2,0>
  }
}
#declare TopSphereRad = PieceWid*0.65;
#declare TopSphereHite = PieceHite*0.99;
#declare TopSphere = sphere {
  <0,TopSphereHite,0>//0.95
  TopSphereRad
}

#declare Body = union {
  object { PawnBase }
  object { TwoTori }
  object { Shank }
  object { TopSphere }
}

// ASSEMBLE THE CHESS PIECES
#declare PieceSc = 1.2;
#declare RoyalSc = 1.55;

// the pawn
#declare Pawn = object {
  Body
}

// the rook
#declare Rook = union {
  object { Body }
  cylinder {
    <0,TopSphereRad,0>,
    <0,0,0>, TopSphereRad
    translate <0,TopSphereHite,0>
  }
  object {
    PTorus
    scale TopSphereRad/(PTorusMaj+PTorusMin) 
    translate <0,TopSphereHite+TopSphereRad,0>
  }
  scale PieceSc
}

// the bishop
#declare Bishop = union {
  object { Body }
  cone {
    <0,TopSphereRad*2.4,0>,  0.06,
    <0,0,0>, TopSphereRad*0.97
    translate <0,PieceHite*1.0456,0>
  }
  scale PieceSc
}

// the knight
#declare NoseOffset = -0.038;
#declare ManeZ = 0.12;
#declare ManeY = TopSphereHite*1.17;
#declare ManeCone = cone {
  <0,0.18,0>,  0.042,
  <0,0,0>, 0.09
}
#declare ManeLoop = 0;
#declare XX = 15;
#declare Muzzle = 0.15;
#declare MuzzleLen = TopSphereRad*1.62;

#declare Knight = union {
  object { Body }
  union {
    cone {
      <0,MuzzleLen,0>,  Muzzle,
      <0,0,0>, TopSphereRad*0.995
    }
    object {
      PTorus
      scale Muzzle/(PTorusMaj+PTorusMin) 
      translate <0,MuzzleLen,0>
    }
    rotate z*90
    translate <NoseOffset,TopSphereHite,0>
  }
  #while (ManeLoop<XX)
    object {
      ManeCone
      translate <0,TopSphereRad*0.9,0>
      rotate <0,0,-130*(ManeLoop/(XX-1))>
      rotate <0,0,20>
      translate <0,TopSphereHite,0>
    }
    #declare ManeLoop = ManeLoop+1;
  #end
  scale PieceSc
}

// the queen
#declare QueenLoop = 0;
#declare XXX = 250;
#declare CrownAng = -50;

#declare CrownCone = cone {
  <0,0.165,0>,  0.007,
  <0,0,0>, 0.07
}

#declare Queen = union {
  object {
    Body
  }
  #while (QueenLoop<XXX)
    object {
      CrownCone
      translate <0,TopSphereRad*0.9,0>
      rotate <CrownAng,0,0>
      rotate <0,360*(QueenLoop/(XXX-1)),0>
      translate <0,TopSphereHite,0>
    }
    #declare QueenLoop = QueenLoop+1;
  #end
  scale RoyalSc
}

// the king
#declare CrossX = 0.1;
#declare CrossY = TopSphereHite*1.84;
#declare CrossZ = 3;
#declare King = difference {
  object {
    Rook
    scale 1/PieceSc
    scale RoyalSc
  }
  box {
    <-CrossX,CrossY,-CrossZ>,
    <CrossX,10,CrossZ>
  }
  box {
    <-CrossZ,CrossY+0.00001,-CrossX>,
    <CrossZ,10,CrossX>

  }
}

// PLACE THE OBJECTS
background { Gray80 }

plane {
  y, 0.0
  texture {
    checker
    texture{T_Stone13 scale 0.5},//41-37
    texture{T_Stone44 scale 5}//44
  }
  scale SquareX
}

light_source {
  <-8,20,-29>
  color White*1.5
  #if (ImageQ = 1)
    area_light
    <1.1,0,0>, <0,1.1,0>, 4, 4
    adaptive 3
    jitter
  #end
}

// objects
object {
  Pawn
  texture {BlackTex rotate y*-42}
  translate HomeSquare
  translate <-SquareX*2,0,0>
}

object {
  Knight
  texture {WhiteTex}
  rotate y*-33
  translate HomeSquare
  translate <-SquareX,0,0>
}
object {
  Bishop
  texture {BlackTex rotate y*2 translate <0,0.4,0>}
  translate HomeSquare
  translate <0,0,0>
}
object {
  Rook
  texture {WhiteTex translate <0,0.2,0>}
  rotate y*57
  translate HomeSquare
  translate <SquareX,0,0>
}

object {
  Queen
  texture {BlackTex rotate y*-92}
  translate HomeSquare
  translate <SquareX*2,0,0>
}
object {
  King
  texture {WhiteTex rotate y*-142}
  rotate y*31
  translate HomeSquare
  translate <SquareX*3,0,0>
}