// Persistence Of Vision raytracer version 3.0 file.
// File: 3d_math.pov
// Vers: 1.0
// Desc: Plotting 3D Math Functions
// Date: 03/28/1998
// Auth: Mark Arrasmith

//
// This is an example for sin(x^2 + y^2)
//
// To use this file for other 3d math functions just
// change the x and y boundaries using Lower/Upper_X
// and Lower/Upper_Y.  Add your function to all the
// Z_Pos_? declare statements.  Note that here I am
// treating z and pov's y coordinate to stick to 
// "normal" math conventions.
//
// Also, you will have to change the color functions
// to account for whatever values you want.  For
// example you can take the (sin(Z_Pos_?))^2 or cosine
// to make sure the values are between 0 and 1.
//

#version 3.0
global_settings { assumed_gamma 1.0 }

#include "colors.inc"


// ------------------------------------------------------------------
// Look down at an angle
// ------------------------------------------------------------------
camera
{
  location  <2,4,-6>
  look_at   <0,0,0>
}


// ------------------------------------------------------------------
// Simple background
// ------------------------------------------------------------------
background { color rgb <1.0, 1.0, 1.0> }


// ------------------------------------------------------------------
// A light source
// ------------------------------------------------------------------
light_source{ <0,40,-15> White }


// ------------------------------------------------------------------
// Set up the loop variables and intial boundary:
// the Sc & Tc variable will go from 0 to Num_of_Points.
// Also, we will use the "standard" axis for mathematics
// where z is vertical and x,y are the plane.
// ------------------------------------------------------------------
#declare Num_of_Points = 100 //grid in xy plane

#declare Lower_X = -pi //Lower bound on x
#declare Upper_X = pi //Upper bound on x
#declare Diff_X = Upper_X - Lower_X //Width of x-coordinates
#declare Delta_X = Diff_X/Num_of_Points 

#declare Lower_Y = -pi //Lower bound on y
#declare Upper_Y = pi //Upper bound on y
#declare Diff_Y = Upper_Y - Lower_Y //Width of y-coordinates
#declare Delta_Y = Diff_Y/Num_of_Points

// ------------------------------------------------------------------
// Create a surface built from our basic shape
// first scan along the y-axis using Tc and then
// along the x-axis using Sc
// ------------------------------------------------------------------
// Sc goes from 0 to Num_of_Points
#declare Sc = 0
#while (Sc<Num_of_Points)

  // Use Sc to get the x_c and x_c_delta location
  #declare x_c = Lower_X + Sc*Delta_X
  #declare x_c_delta = Lower_X + (Sc+1)*Delta_X

  // Calculate Point A at (x_c,Lower_Y)
  #declare X_Pos_A = x_c 
  #declare Y_Pos_A = Lower_Y
  #declare Z_Pos_A = sin(x_c*x_c + Lower_Y*Lower_Y)
  
  // Calculate Point B at (x_c_delta,Lower_Y)
  #declare X_Pos_B = x_c_delta
  #declare Y_Pos_B = Lower_Y
  #declare Z_Pos_B = sin(x_c_delta*x_c_delta + Lower_Y*Lower_Y)

  // Tc goes from 0 to Num_of_Points
  #declare Tc = 0
  #while (Tc<Num_of_Points)

	// scale Tc to get the y_c_delta location
	#declare y_c_delta = Lower_Y + (Tc+1)*Delta_Y
	
    // Calculate Point C at (x_c,y_c_delta)
   	#declare X_Pos_C = x_c 
	#declare Y_Pos_C = y_c_delta
	#declare Z_Pos_C = sin(x_c*x_c + y_c_delta*y_c_delta)

    // Calculate Point D at (x_c_delta,y_c_delta)
	#declare X_Pos_D = x_c_delta
	#declare Y_Pos_D = y_c_delta
	#declare Z_Pos_D = sin(x_c_delta*x_c_delta + y_c_delta*y_c_delta)


    // Create the colors
	#declare Red_c = Z_Pos_D
   	#declare Green_c = 1-Z_Pos_D
   	#declare Blue_c = -2*abs(Z_Pos_D - 0.5) + 1

    // Triangle ADB
    triangle {
      <X_Pos_A,Z_Pos_A,Y_Pos_A>, <X_Pos_D,Z_Pos_D,Y_Pos_D>, <X_Pos_B,Z_Pos_B,Y_Pos_B>
      texture
      {
        pigment { color rgb <Red_c,Green_c,Blue_c>}
        finish { ambient .2 diffuse .6 phong .75 phong_size 150 }
      }
    }

    // Triangle ADC
    triangle {
      <X_Pos_A,Z_Pos_A,Y_Pos_A>, <X_Pos_D,Z_Pos_D,Y_Pos_D>, <X_Pos_C,Z_Pos_C,Y_Pos_C>
      texture
      {
        pigment { color rgb <Red_c,Green_c,Blue_c>}
        finish { ambient .2 diffuse .6 phong .75 phong_size 25 }
      }
    }

    // Calculate Point A by letting A = C
   	#declare X_Pos_A = X_Pos_C
	#declare Y_Pos_A = Y_Pos_C
	#declare Z_Pos_A = Z_Pos_C

    // Calculate Point B by letting B = D
   	#declare X_Pos_B = X_Pos_D
	#declare Y_Pos_B = Y_Pos_D
	#declare Z_Pos_B = Z_Pos_D


     // manually increment our counter inside the loop
    #declare Tc=Tc+1
  #end


  // manually increment our counters inside the loop
  #declare Sc=Sc+1

#end