Code Overview

Assignment 2 - Ray Tracing
Code Overview

Notes

As a matter of notation, all colors are specified by a 3D array where the first coordinate specifies the red color, the second specifies the green color, and the third specifies the blue color.
Flt is a typedef for double. This can be changed in the code but should not be.

File List

Main Ray Tracing code:

ray.[cpp/h]: Code responsible for casting rays, calling intersection methods, computing colors, etc.

Shape Classes:

shape.h: Abstract base class that all shapes must implement.
group.[cpp/h]: Shape subclass describing a scene-graph.
rayFileInstance.[cpp/h]: Shape subclass describing the scene graph specified in a .ray file.
triangle.[cpp/h]: Shape subclass describing a triangle.
sphere.[cpp/h]: Shape subclass describing a sphere.
cone.[cpp/h] Shape subclass describing a cone.
cylinder.[cpp/h]: Shape subclass describing a cylinder.
box.[cpp/h]: Shape subclass describing a box.
line.[cpp/h]: Shape subclass describing a line segment
.

Light Classes:

light.h: Abstract base class that all lights must implement.
pointLight.[cpp/h]: Light subclass describing a point light.
directionalLight.[cpp/h]: Light subclass describing a directional light.

spotLight.[cpp/h]: Light subclass describing a spot light.

Other Code:

main.cpp: Parses apart the command line arguments and invokes the ray tracer.
scene.[cpp/h]: Classes that store environmental information, textures, materials, rayFiles, etc.
geometry.[cpp/h]: Most of the code for the geometric manipulation you will need (matrix multiplication, vector addition, etc.).
boundingBox.[cpp/h]: Defines bounding boxes.
bmp.[cpp/h]: Code responsible for reading and writing BMP files.

Class List

File Name Type Name Subclass Of

shape.h class Shape -

shape.h struct IntersectionInfo -

group.[cpp/h] class ShapeListElement -

group.[cpp/h] class Group Shape

rayFileInstance.[cpp/h] class RayFileInstance Shape

triangle.[cpp/h] class Triangle Shape

sphere.[cpp/h] class Sphere Shape

cone.[cpp/h] class Cone Shape

cylinder.[cpp/h] class Cylinder Shape

box.[cpp/h] class Box Shape

line.[cpp/h] class Line Shape

light.h class Light -

pointLight.[cpp/h] class PointLight Light

directionalLight.[cpp/h] class DirectionalLight Light

spotLight.[cpp/h] class SpotLight Light

scene.[cpp/h] class Camera -

scene.[cpp/h] class Vertex -

scene.[cpp/h] class Material -

scene.[cpp/h] class Texture -

scene.[cpp/h] class RayFile -

scene.[cpp/h] class Scene -

geometry.[cpp/h] class Point2D -

geometry.[cpp/h] class Point3D -

geometry.[cpp/h] class Ray -

geometry.[cpp/h] class Matrix -

boundingBox.[cpp/h] class BoundingBox -

bmp.[cpp/h] struct Pixel -

bmp.[cpp/h] struct Image -

File Name	Type	Name	Subclass Of
`shape.h`	class	Shape	-
`shape.h`	struct	IntersectionInfo	-
`group.[cpp/h]`	class	ShapeListElement	-
`group.[cpp/h]`	class	Group	Shape
`rayFileInstance.[cpp/h]`	class	RayFileInstance	Shape
`triangle.[cpp/h]`	class	Triangle	Shape
`sphere.[cpp/h]`	class	Sphere	Shape
`cone.[cpp/h]`	class	Cone	Shape
`cylinder.[cpp/h]`	class	Cylinder	Shape
`box.[cpp/h]`	class	Box	Shape
`line.[cpp/h]`	class	Line	Shape
`light.h`	class	Light	-
`pointLight.[cpp/h]`	class	PointLight	Light
`directionalLight.[cpp/h]`	class	DirectionalLight	Light
`spotLight.[cpp/h]`	class	SpotLight	Light
`scene.[cpp/h]`	class	Camera	-
`scene.[cpp/h]`	class	Vertex	-
`scene.[cpp/h]`	class	Material	-
`scene.[cpp/h]`	class	Texture	-
`scene.[cpp/h]`	class	RayFile	-
`scene.[cpp/h]`	class	Scene	-
`geometry.[cpp/h]`	class	Point2D	-
`geometry.[cpp/h]`	class	Point3D	-
`geometry.[cpp/h]`	class	Ray	-
`geometry.[cpp/h]`	class	Matrix	-
`boundingBox.[cpp/h]`	class	BoundingBox	-
`bmp.[cpp/h]`	struct	Pixel	-
`bmp.[cpp/h]`	struct	Image	-

Return to top.

Function List

File Name Function Name

ray.[cpp/h] Image* RayTrace(const char* fileName, int width, int height, int rLimit, float cLimit)

ray.[cpp/h] Point3D GetColor(Scene scene, Ray ray, IntersectionInfo iInfo, int rDepth, float cLimit)

main.cpp int main(int argc, char** argv)

geometry.[cpp/h] Matrix IdentityMatrix(void)

bmp.[cpp/h] Image* ImageNew(int width, int height)

bmp.[cpp/h] void ImageFree(Image** img)

bmp.[cpp/h] void ImageCopy(Image* src, Image* dst)

bmp.[cpp/h] int ImageIsValid(Image* img)

bmp.[cpp/h] Pixel* ImageGetPixel(Image* img, int x, int y)

bmp.[cpp/h] void ImageSetPixel(Image* img, int x, int y, Pixel* p)

File Name	Function Name
ray.[cpp/h]	Image* RayTrace(const char* fileName, int width, int height, int rLimit, float cLimit)
ray.[cpp/h]	Point3D GetColor(Scene scene, Ray ray, IntersectionInfo iInfo, int rDepth, float cLimit)
main.cpp	int main(int argc, char** argv)
geometry.[cpp/h]	Matrix IdentityMatrix(void)
bmp.[cpp/h]	Image* ImageNew(int width, int height)
bmp.[cpp/h]	void ImageFree(Image** img)
bmp.[cpp/h]	void ImageCopy(Image* src, Image* dst)
bmp.[cpp/h]	int ImageIsValid(Image* img)
bmp.[cpp/h]	Pixel* ImageGetPixel(Image* img, int x, int y)
bmp.[cpp/h]	void ImageSetPixel(Image* img, int x, int y, Pixel* p)

Return to top.

Class Description

Shape: This abstract class is used to describe all shapes that are ray-tracable.

IntersectionInfo: This structure is used to store intersection information

ShapeListElement: This class is used to store a linked list of shapes

Group: This subclass of Shape represents a single node of the scene-graph

RayFileInstance: This subclass of Shape is used to point to an instance of a scene-graph that is read out of a .ray file

Triangle: This subclass of Shape represents a triangle

Sphere: This subclass of Shape represents a sphere

Cone: This subclass of Shape represents a cone

Cylinder: This subclass of Shape represents a cylinder

Box: This subclass of Shape represents a box

Line: This subclass of Shape represents a line segment

Light: This abstract is used to describe all the different lights within the scene

PointLight: This subclass of Light is used to describe a point-light

DirectionalLight: This subclass of Light is used to describe a directional-light

SpotLight: This subclass of Light is used to describe a spot-light

Camera: This class is used to describe the location and orientation of the camera in the scene

Vertex: This class represents a vertex, it stores the vertex position, normal, and texture coordinate

Material: This class is used to store material information about a Shape

Texture: For Shapes that support texture-mapping this class stores the Image corresponding to the texture

RayFile: This class stores the instance of a scene-graph that is read out of a .ray file

Scene: This class is used to store all the information read out from a .ray file

Point2D: This class represents a 2D vector

Point3D: This class represents a 3D vector

Ray: This class represents a directed ray

Matrix: This class represents a 4x4 matrix, used to describe local transformations

BoundingBox: This class is used to describe the bounding box of a Shape.

Pixel: This stores the red, green, and blue components of a pixel

Image: This describes a 2D array of pixels which store an image

Return to top.

List of members and methods

Shape (shape.h):
- Material* Shape::material
- virtual char* Shape::name(void)
- virtual void Shape::write(int indent, FILE* fp=stdout)
- virtual Flt Shape::intersect(Rayray, IntersectionInfo& iInfo)
- virtual BoundingBox Shape::getBoundingBox(void)
- void Shape::free(void)
IntersectionInfo (shape.h):
- Material* IntersectionInfo::material
- Point3D IntersectionInfo::iCoordinate
- Point3D IntersectionInfo::normal
- Point2D IntersectionInfo::texCoordinate
ShapeListElement (group.[cpp/h]):
- ShapeListElement* ShapeListElement::next
- Shape* ShapeListElement::shape
- ShapeListElement::ShapeListElement(Shape* shape)
- void ShapeListElement::addShape(Shape* shape)
Group (group.[cpp/h]):
- Matrix Group::localTransform
- ShapeListElement* Group::shapeList
- BoundingBox Group::bBox
- Group::Group(FILE* fp)
- Group::Group(Matrix localTransform)
- void Group::addShape(Shape* shape)
- char* Group::name(void)
- void Group::write(int indent, FILE* fp=stdout)
- Flt Group::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox Group::getBoundingBox(void)
- void Group::free(void)
RayFileInstance (rayFileInstance.[cpp/h]):
- RayFileInstance::RayFileInstance(RayFile* rayFile)
- char* RayFileInstance::name(void)
- void RayFileInstance::write(int indent, FILE* fp=stdout)
- Flt RayFileInstance::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox RayFileInstance::getBoundingBox(void)
Triangle (triangle.[cpp/h])
- Vertex* Triangle::v[3]
- Triangle::Triangle(FILE* fp, int* materialIndex, Vertex* vList, int vSize)
- char* Triangle::name(void)
- void Triangle::write(int indent, FILE* fp=stdout)
- Flt Triangle::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox Triangle::getBoundingBox(void)
Sphere (sphere.[cpp/h]):
- Point3D Sphere::center
- Flt Sphere::radius
- Sphere::Sphere(FILE* fp, int* materialIndex)
- char* Sphere::name(void)
- void Sphere::write(int indent, FILE* fp=stdout)
- Flt Sphere::intersect(Rayray, IntersectionInfo& iInfo)
- BoundingBox Sphere::getBoundingBox(void)
Cone (cone.[cpp/h]):
- Point3D Cone::center
- Flt Cone::height
- Flt Cone::radius
- Cone::Cone(FILE* fp, int* materialIndex)
- char* Cone::name(void)
- void Cone::write(int indent, FILE* fp=stdout)
- Flt Cone::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox Cone::getBoundingBox(void)
Cylinder (cylinder.[cpp/h]):
- Point3D Cylinder::center
- Flt Cylinder::height
- Flt Cylinder::radius
- Cylinder::Cylinder(FILE* fp, int* materialIndex)
- char* Cylinder::name(void)
- void Cylinder::write(int indent, FILE* fp=stdout)
- Flt Cylinder::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox Cylinder::getBoundingBox(void)
Box (box.[cpp/h]):
- Point3D Box::center
- Point3D Box::length
- Box::Box(FILE* fp, int* materialIndex)
- char* Box::name(void)
- void Box::write(int indent, FILE* fp=stdout)
- Flt Box::intersect(Ray ray, IntersectionInfo& iInfo)
- BoundingBox Box::getBoundingBox(void)
Line (line.[cpp/h]):
- Point3D Line::start
- Point3D Line::end
- Line::Line(FILE* fp, int* materialIndex)
- Line::Line(Ray ray, Material* material)
- char* Line::name(void)
- void Line::write(int indent, FILE* fp=stdout)
- Flt Line::intersect(Rayray, IntersectionInfo& iInfo)
- BoundingBox Line::getBoundingBox(void)
Light (light.h)
- Point3D Light::color
- virtual int Light::read(FILE* fp)
- virtual void Light::write(FILE* fp=stdout)
- virtual Point3D Light::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo)
- virtual Point3D Light::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo)
- virtual int Light::isInShadow(IntersectionInfo iInfo, Shape* shape)
PointLight (pointLight.[cpp/h]):
- Point3D PointLight::location
- Flt PointLight::constAtten
- Flt PointLight::linearAtten
- Flt PointLight::quadAtten
- int PointLight::read(FILE* fp)
- void PointLight::write(FILE* fp=stdout)
- Point3D PointLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo)
- Point3D PointLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo)
- int PointLight::isInShadow(IntersectionInfo iInfo, Shape* shape)
DirectionalLight (directionalLight.[cpp/h]):
- Point3D DirectionalLight::direction
- int DirectionalLight::read(FILE* fp)
- void DirectionalLight::write(FILE* fp=stdout)
- Point3D DirectionalLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo)
- Point3D DirectionalLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo)
- int DirectionalLight::isInShadow(IntersectionInfo iInfo, Shape* shape)
SpotLight (spotLight.[cpp/h]):
- Point3D SpotLight::location
- Point3D SpotLight::direction
- Flt SpotLight::constAtten
- Flt SpotLight::linearAtten
- Flt SpotLight::quadAtten
- Flt SpotLight::cutOffAngle
- Flt SpotLight::dropOffRate
- int SpotLight::read(FILE* fp)
- void SpotLight::write(FILE* fp=stdout)
- Point3D SpotLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo)
- Point3D SpotLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo)
- int SpotLight::isInShadow(IntersectionInfo iInfo, Shape* shape)
Camera (scene.[cpp/h]):
- Flt Camera::heightAngle
- Flt Camera::aspectRatio
- Point3D Camera::position
- Point3D Camera::direction
- Point3D Camera::up
- Point3D Camera::right
- int Camera::read(FILE* fp)
- void Camera::write(FILE* fp=stdout)
Vertex (scene.[cpp/h]):
- int Vertex::index
- Point3D Vertex::position
- Point3D Vertex::normal
- Point2D Vertex::texCoordinate
- int Vertex::read(FILE* fp)
- void Vertex::write(FILE* fp=stdout)
Material (scene.[cpp/h]):
- int Material::index
- Point3D Material::ambient
- Point3D Material::diffuse
- Point3D Material::specular
- Point3D Material::emmisive
- Flt Material::kspec
- Flt Material::ktran
- Flt Material::refind
- Texture* Material::tex
- char Material::foo[ ]
- int Material::read(FILE* fp)
- void Material::write(FILE* fp=stdout)
Texture (scene.[cpp/h]):
- int Texture::index
- char Texture::filename[ ]
- Image* Texture::img
- int Texture::read(FILE* fp)
- void Texture::write(FILE* fp=stdout)
RayFile (scene.[cpp/h])
- int RayFile::index
- char RayFile::filename[ ]
- Scene* RayFile::scene
- int RayFile::read(FILE* fp)
- void RayFile::write(FILE* fp=stdout)
- void RayFile::free(void)
Scene (scene.[cpp/h]):
- Point3D Scene::ambient
- Point3D Scene::background
- Camera Scene::camera
- Light** Scene::lights
- int Scene::lightNum
- Shape* Scene::shape
- Scene::Scene(void)
- Material* Scene::getMaterial(int index)
- void Scene::read(const char* filename)
- void Scene::write(FILE* fp=stdout)
Point2D (geometry.[cpp/h]):
- Point2D::Point2D(void)
- Point2D::Point2D(Flt x, Flt y)
- Flt& Point2D::operator[ ] (int index)
- void Point2D::print(void)
- void Point2D::printnl(void)
- Flt Point2D::dot(Point2D pt)
- Flt Point2D::length(void)
- Point2D Point2D::unit(void)
- Point2D Point2D::negate(void)
- Point2D Point2D::operator- (void)
- Point2D Point2D::scale(Flt scl)
- Point2D Point2D::operator* (Flt scale)
- Point2D Point2D::operator/ (Flt scale)
- Point2D Point2D::add(Point2D pt)
- Point2D Point2D::operator+ (Point2D pt)
- Point2D Point2D::subtract(Point2D pt)
- Point2D Point2D::operator- (Point2D pt)
- Point2D Point2D::mult(Point2D pt)
Point3D (geometry.[cpp/h]):
- Point3D::Point3D(void)
- Point3D::Point3D(Flt x, Flt y, Flt z)
- Flt& Point3D::operator[ ] (int index)
- void Point3D::print(void)
- void Point3D::printnl(void)
- Flt Point3D::dot(Point3D pt)
- Flt Point3D::length(void)
- Point3D Point3D::unit(void)
- Point3D Point3D::negate(void)
- Point3D Point3D::operator- (void)
- Point3D Point3D::scale(Flt scl)
- Point3D Point3D::operator* (Flt scale)
- Point3D Point3D::operator/ (Flt scale)
- Point3D Point3D::add(Point3D pt)
- Point3D Point3D::operator+ (Point3D pt)
- Point3D Point3D::subtract(Point3D pt)
- Point3D Point3D::operator- (Point3D pt)
- Point3D Point3D::crossProduct(Point3D pt)
- Point3D Point3D::mult(Point3D pt)
Ray (geometry.[cpp/h]):
- Point3D Ray::p
- Point3D Ray::d
- Ray::Ray(void)
- Ray::Ray(Point3D p,Point3D d)
- void Ray::print(void)
- void Ray::printnl(void)
- Ray Ray::translate(Point3D pt)
- Point3D Ray::operator( ) (Flt param)
- Point3D Ray::position(Flt param)
Matrix (geometry.[cpp/h]):
- Flt& Matrix::operator( ) (int col,int row)
- Flt Matrix::det(void)
- void Matrix::print(void)
- void Matrix::printnl(void)
- Matrix Matrix::mult(Matrix m)
- Matrix Matrix::operator* (Matrix m)
- Matrix Matrix::transpose(void)
- Matrix Matrix::invert(void)
- Point3D Matrix::multPosition(Point3D position)
- Point3D Matrix::multDirection(Point3D direction)
- Point3D Matrix::multNormal(Point3D normal)
- Ray Matrix::mult(Ray ray)
- Ray Matrix::operator* (Ray ray)
BoundingBox (boundingBox.[cpp/h]):
- Point3D BoundingBox::p[2]
- BoundingBox::BoundingBox(void)
- BoundingBox::BoundingBox(Point3D p1, Point3D p2)
- BoundingBox::BoundingBox(Point3D* pList, int listSize)
- BoundingBox BoundingBox::operator+ (BoundingBox b)
- BoundingBox BoundingBox::Transform(Matrixm)
- Flt BoundingBox::intersects(Ray ray)
Pixel (bmp.[cpp/h]):
- unsigned char Pixel::r
- unsigned char Pixel::g
- unsigned char Pixel::b
Image (bmp.[cpp/h]):
- int Image::width
- int Image::height
- Pixel* Image::pixels

Return to top.

Functions

Image* RayTrace(const char* fileName, int width, int height, int rLimit, float cLimit)
This function is the meat of the ray-tracer. It reads in a .ray file with the specified file-name and returns the ray-traced image. The width and height specify the size of the Image. The ray-tracer is recursive and will stop if either the depth exceeds rLimit or the color contribution is smaller than cLimit.
Point3D GetColor(Scene scene, Ray ray, IntersectionInfo iInfo, int rDepth, float cLimit)
This function returns the color at the point of intersection, recursively casting reflected and refracted rays. The recursion terminates when either the maximum recursion depth has been reached or the color contribution falls below cLimit.
int main(int argc, char** argv)
This function reads the user specified parameters, obtaining the .ray file name, the destination file name, the width, the height, etc. and invokes the RayTrace(...) command. It then writes out the image to the specified destination file.
Matrix IdentityMatrix(void)
This function returns the identity Matrix.
Image* ImageNew(int width, int height)
This function allocates memory for an Image of the desired size.
void ImageFree(Image** img)
This function frees up the resources associated with an Image.
void ImageCopy(Image* src, Image* dst)
This function copies src to dst. It is assumed that memory has already been allocated for dst and that the two images are of the same size.
int ImageIsValid(Image* img)
This function test that img is a valid Image. (That is, that its width and height are positive and that memory has been successfully allocated for it.)
Pixel* ImageGetPixel(Image* img, int x, int y)
This function returns a pointer to the Pixel of the Image at the specified position.
void ImageSetPixel(Image* img, int x, int y, Pixel* p)
This function sets the Pixel of the Image with p. (Note that it does not make a copy of p.)

Return to top.

Description of Class Members and Methods

Shape: This class is the abstract class that all objects that are ray-traceable must implement.
- Material* Shape::material: This stores the material associated with the shape.
- virtual char* Shape::name(void): This abstract method returns a descriptive name of the Shape.
- virtual void Shape::write(int indent, FILE* fp=stdout): This abstract method writes the Shape out to a file (default is STDOUT) in the .ray format. The indent parameter specifies the offset in white space to be used in writing.
- virtual Flt Shape::intersect(Ray ray, IntersectionInfo& iInfo): This virtual method is reponsible for determining if the the ray intersects the Shape and if it does, the method fills in the intersection information. It returns -1.0 if the ray does not intersect the Shape. Otherwise it returns the distance along the ray to the point of intersection.
- virtual BoundingBox Shape::getBoundingBox(void): This method returns the bounding box for the Shape
- void Shape::free(void): This method is called to free up any resources associated with the Shape
IntersectionInfo: This structure stores the intersection information.

Material* IntersectionInfo::material: This is the material description of the point where the intersection occurs
Point3D IntersectionInfo::iCoordinate: This is the position at which the intersection occurs
Point3D IntersectionInfo::normal: This is the normal to the surface at the point of intersection
Point2D IntersectionInfo::texCoordinate: This is the texture coordinate for the point of intersection

ShapeListElement: This class allows for a linked list of Shapes

ShapeListElement* ShapeListElement::next This is a pointer to the next element in the Shape list
Shape* ShapeListElement::shape: This is a pointer to the shape associated with the list element
ShapeListElement::ShapeListElement(Shape* shape): This constructor generates a new list element given a pointer to a Shape
void ShapeListElement::addShape(Shape* shape): Given an element of the list, this method adds a new element with the specified Shape into the list. (Immediately after the specified element.)

Group: This subclass of Shape consists of a local transformation and a list of Shapes to which the transformation is applied. (It is a subclass of Shape because one can determine the point of intersection with a group by intersecting with all the Shapes in its list and returning the closest point of intersection with the appropriate intersection information.) This class can be thought of as a single node in the scene-graph.

Matrix Group::localTransform: This stores the local transformation to be applied to all the Shapes in the list.
ShapeListElement* Group::shapeList: This is the list of Shapes associated to the group.
BoundingBox Group::bBox: This is the bounding box that contains all of the Shapes in the Group's list.
Group::Group(FILE* fp): Invoked by the .ray parser, this method reads in the local transformation from the file and sets its Shape list to NULL.
Group::Group(Matrix localTransform): This constructor creates a new Group object with the specified local transformation. The Shape list is set to NULL.
void Group::addShape(Shape* shape): This method adds a Shape to the list of Shapes.
char* Group::name(void): This method overrides the abstract Shape::name( ) method, and returns the string "group".
void Group::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Group::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method. This is done by transforming the Ray into the local coordinate system, intersecting with all of the Shapes in the list, converting the point of intersection back into world coordinates, determining which intersection point is closest, filling in the IntersectionInfo appropriately, and returning the distance along the Ray. Once the bounding box for the group has been set up, the ray-tracing process can be further sped up by first testing if the Ray intersects the bounding box and only if it does, proceeding to run the intersection with each of the child Shapes.
BoundingBox Group::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It does this by calling the Shape::getBoundingBox( ) method of each of the Shapes in its list of shapes. It then generates a new bounding box containing the union of all of the childrens' bounding boxes, and transforms it using the Group::localTransform. Before returning the bounding box to the user, it stores it in Group::bBox for future use.
void Group::free(void): This method frees up all resources associated with the Group by first freeing up all the resources associted with the Shapes in the list and then freeing the list itself.

RayFileInstance: If the .ray file includes other .ray files multiple times, it is desirable to have only one instance of the scene-graph specified in the .ray file and have it be accessible from different nodes. (This reduces the size of the scene-graph.) This class is a storage conatiner for the pointer to the scene-graph.

RayFileInstance::RayFileInstance(RayFile* rayFile): This instantiator generates a new instance which points to the specified RayFile.
char* RayFileInstance::name(void): This method overrides the abstract Shape::name( ) method and returns the string "ray file instance".
void RayFileInstance::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt RayFileInstance::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method. It does so by calling the intersect method of the RayFile object it points to.
BoundingBox RayFileInstance::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box obtained by calling the Shape::getBoundingBox( ) method of the Shape pointed associated to the .ray file.

Triangle: This subclass of Shape describes a triangular shape.

Vertex* Triangle::v[3]: These are the pointers to three vertices defining the Triangle.
Triangle::Triangle(FILE* fp, int* materialIndex, Vertex* vList, int vSize): This constructor creates a new Triangle object by reading the vertex indices from the file, checking that they are within bounds and not equal, and setting the vertex pointer appropriately.
char* Triangle::name(void): This method overrides the abstract Shape::name( ) method and returns the string "triangle".
void Triangle::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Triangle::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method.
BoundingBox Triangle::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the three vertices of the triangle.

Sphere: This subclass of Shape describes a sphere.

Point3D Sphere::center: This is the position of the center of the sphere.
Point3D Sphere::radius: This is the radius of the sphere
Sphere::Sphere(FILE* fp, int* materialIndex): This constructor creates a new Sphere object by reading the center and radius from the file. Additionally it sets the material index.
char* Sphere::name(void): This method overrides the abstract Shape::name( ) method and returns the string "sphere".
void Sphere::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Sphere::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method.
BoundingBox Sphere::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the Sphere.

Cone: This subclass of Shape describes a cone.

Point3D Cone::center: This is the position of the center of the cone. (Note that this is not the position of the center of the cone's base.)
Flt Cone::height: This is the height of the cone.
Flt Cone::radius: This is the radius of the base of the cone.
Cone::Cone(FILE* fp, int* materialIndex): This constructor creates a new Coneobject by reading the center, height and radius from the file. Additionally it sets the material index.
char* Cone::name(void): This method overrides the abstract Shape::name( ) method and returns the string "cone".
void Cone::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Cone::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method.
BoundingBox Cone::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the Cone.

Cylinder: This subclass of Shape describes a cylinder.

Point3D Cylinder::center: This is the position of the center of the cylinder.
Flt Cylinder::height: This is the height of the cylinder.
Flt Cylinder::radius: This is the radius of the cylinder.
Cylinder::Cylinder(FILE* fp, int* materialIndex): This constructor creates a new Cylinder object by reading the center, height and radius from the file. Additionally it sets the material index.
char* Cylinder::name(void): This method overrides the abstract Shape::name( ) method and returns the string "cylinder".
void Cylinder::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Cylinder::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstractShape::intersect(Ray,IntersectionInfo&) method.
BoundingBox Cylinder::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the Cylinder.

Box: Subclass of Shape that describes a box. All boxes are treated as axis-aligned cubes. If you need a different kind of box, the desired transformation must be applied externally.

Point3D Box::center: This is the position of the center of the box.
Point3D Box::length: This specifies the dimensions of the box. (Note that the length specifies the length of the side, not the length from the center.)
Box::Box(FILE* fp, int* materialIndex): This constructor creates a new Box object by reading the center and length from the file. Additionally it sets the material index.
char* Box::name(void): This method overrides the abstract Shape::name( ) method and returns the string "box".
void Box::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Box::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method.
BoundingBox Box::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the Box.

Line: This subclass of Shape describes a line segment. While it cannot be ray-traced (it does not have a surface) it is useful for debugging purposes when using the ray-viewer.

Point3D Line::start: This is the starting point of the line segment.
Point3D Line::end: This is ending point of the line segment.
Line::Line(FILE* fp, int* materialIndex): This constructor creates a new Line object by reading the starting and ending points from the file. Additionally it sets the material index.
Line::Line(Ray ray, Material* material): This constructor creates a new Line objects using the ray position as the start point and the ray position displaced by the ray direction as the end point. It associates the specified material with the new Line.
char* Line::name(void): This method overrides the abstract Shape::name( ) method and returns the string "line".
void Line::write(int indent, FILE* fp=stdout): This method overrides the abstract Shape::write(int,FILE*) method.
Flt Line::intersect(Ray ray, IntersectionInfo& iInfo): This method overrides the abstract Shape::intersect(Ray,IntersectionInfo&) method. Since a line segment cannot be ray-traced, this method always returns -1.0.
BoundingBox Line::getBoundingBox(void): This method overrides the abstract Shape::getBoundingBox( ) method. It returns the bounding box containing the Line.

Light: This class is the abstract class that all objects calling themselves "lights" must implement.

Point3D Light::color: This is the color of the light.
virtual int Light::read(FILE* fp): This abstract method reads the appropriate light information from a file.
virtual void Light::write(FILE* fp=stdout): This abstract method writes the Light out to a file (default is STDOUT) in the .ray format.
virtual Point3D Light::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo): Given the camera position and information about the point of intersection, this abstract method returns the diffuse color contribution of this light at the point of intersection. (It does not perform any calculations to test if the point of intersection is in shadow with respect to this Light.)
virtual Point3D Light::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo): Given the camera position and information about the point of intersection, this abstract method returns the specular color contribution of this light at the point of intersection. (It does not perform any calculations to test if the point of intersection is in shadow with respect to this Light.)
virtual int Light::isInShadow(IntersectionInfo iInfo, Shape* shape): Given the intersection information and a description of the scene-shape (the Shape passed in should be the root of the scene-graph) this method determines whether or not the point of intersection is in shadow with respect to the light.

PointLight: This Light subclass describes a light with specified position in space, and specified constant, linear and quadratic attenuation. The attenuation factor specifes the factor by which to scale the light cotribution from the light at the point of intersection. If d is the distance between the light source and the point of intersection then the scale factor is given by: 1.0/(ca+d*la+d*d*qa), where ca is the constant attenuation, la is the linear attenuation, and qa is the quadratic attenuation. (So to have a light source with no attenuation you should have (ca,la,qa)=(1.0,0.0,0.0).)

Point3D PointLight::location: This is the position of the point-light.
Flt PointLight::constAtten: This is the constant attenuation term.
Flt PointLight::linearAtten: This is the linear attenuation term.
Flt PointLight::quadAtten: This is the quadratic attenuation term.
int PointLight::read(FILE* fp): This method overrides the Light::read(FILE*) method and sets the light location and constant/linear/quadratic attenuation terms, as specified in the file.
void PointLight::write(FILE* fp=stdout): This method overrides the abstract Light::write(int,FILE*) method.
Point3D PointLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getDiffuse(Point3D,IntersectionInfo) method .
Point3D PointLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getSpecular(Point3D,IntersectionInfo) method .
int PointLight::isInShadow(IntersectionInfo iInfo, Shape* shape): This method overrides the abstract Light::isInShadow(IntersectionInfo,Shape*) method. It does so by generating a new Ray whose position is the point of intersection and whose direction is the direction of the line between the point of intersection and the light. It determines if it is in shadow by intersecting the new Ray with the scene-graph and determining if their is a point of intersection at a position closer than the position of the point-light.

DirectionalLight: This Light subclass describes a light with no position in space and only a direction. (As such it does not make sense to talk about its attenuation as a function of distance.)

Point3D DirectionalLight::direction: This is the direction of the directional-light.
int DirectionalLight::read(FILE* fp): This method overrides the Light::read(FILE*) method and sets the light direction, as specified in the file.
void DirectionalLight::write(FILE* fp=stdout): This method overrides the abstract Light::write(int,FILE*) method.
Point3D DirectionalLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getDiffuse(Point3D,IntersectionInfo) method .
Point3D DirectionalLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getSpecular(Point3D,IntersectionInfo) method .
int DirectionalLight::isInShadow(IntersectionInfo iInfo, Shape* shape): This method overrides the abstract Light::isInShadow(IntersectionInfo,Shape*) method. It does so by generating a new Ray whose position is the point of intersection and whose direction is the negative direction of the light. It determines if it is in shadow by intersecting the Ray with the scene and determining if their are any intersections.

SpotLight: This Light subclass describes a spot light with specified position and direction, in space, specified constant, linear and quadratic attenuation terms, and with specified cut-off angle and drop-off rate. The attenuation factor specifes the factor by which to scale the light cotribution from the light at the point of intersection. If d is the distance between the light source and the point of intersection then the scale factor is given by: 1.0/(ca+d*la+d*d*qa), where ca is the constant attenuation, la is the linear attenuation, and qa is the quadratic attenuation. (So to have a light source with no attenuation you should have (ca,la,qa)=(1.0,0.0,0.0).)

Point3D SpotLight::location: This is the position of the spot-light.
Point3D SpotLight::direction: This is the direction of the spot-light.
Flt SpotLight::constAtten: This is the constant attenuation term.
Flt SpotLight::linearAtten: This is the linear attenuation term.
Flt SpotLight::quadAtten: This is the quadratic attenuation term.
Flt SpotLight::cutOffAngle: This is the cut-off angle of the spot-light. Which is to say, if the angle between the light direction and the ray from the light to the point of intersection is larger than the cutOffAngle, then this light does not contribute to the lighting equation.
Flt SpotLight::dropOffRate: This is the drop-off rate of the spot light. It takes a value between 0.0 and 1.0. (It specifies how quickly the light attenuates as a function of the angle between the line from the point of intersection to the light position, and the direction of the spot-light.) More specifically, the cosine of the angle between the light direction and the ray from the light to the point of intersection, raised to the power of 128*dropOffRate gives the appropriate scale factor of the light as a function of angle. (This scaling should be considered in addition to the computed attenuation.)
int SpotLight::read(FILE* fp): This method overrides the Light::read(FILE*) method and sets the light position, light direction, attenuation terms, cut-off angle and drop-off rate as specified in the file.
void SpotLight::write(FILE* fp=stdout): This method overrides the abstract Light::write(int,FILE*) method.
Point3D SpotLight::getDiffuse(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getDiffuse(Point3D,IntersectionInfo) method .
Point3D SpotLight::getSpecular(Point3D cameraPosition, IntersectionInfo iInfo): This method overrides the abstract Light::getSpecular(Point3D,IntersectionInfo) method .
int SpotLight::isInShadow(IntersectionInfo iInfo, Shape* shape): This method overrides the abstract Light::isInShadow(IntersectionInfo,Shape*) method. It does so by generating a new Ray whose position is the point of intersection and whose direction is the direction of the line between the point of intersection and the light. It determines if it is in shadow by intersecting the new Ray with the scene-graph and determining if their is a point of intersection at a position closer than the position of the spot-light.

Camera: This class describes the camera casting the rays into the scene.

Flt Camera::heightAngle: This is half of the height angle of the view frustrum.
Flt Camera::aspectRatio: This is the ratio of width to height of the view plane.
Point3D Camera::position: This is the position of the camera in world coordinates.
Point3D Camera::direction: This is the direction of site of the Camera.
Point3D Camera::up: This is the up direction of the Camera.
Point3D Camera::right: This is the right direction of the Camera (This can be obtained by taking the cross product of the up direction and the line of site direction -- though not necassarily in that order. The parser automatically sets this value for you, even though it is not specified in the .ray file.)
int Camera::read(FILE* fp): This method reads out the half-height angle, the aspect ratio, position, the line of site direction and the up direction from the file and sets the Camera parameters.
void Camera::write(FILE* fp=stdout): This method writes the Camera out to a file (default is STDOUT) in the .ray format.

Vertex: This class is used to store vertex information.

int Vertex::index: This specifies the index of the Vertex within the list of vertices specified in the .ray file.
Point3D Vertex::position: This specifies the location of the vertex.
Point3D Vertex::normal: This specifies the normal direction at the vertex.
Point2D Vertex::texCoordinate: This specifies the texture coordinate at the vertex.
int Vertex::read(FILE* fp): This method reads out the position, normal and texture coordinates from the file and sets the Vertex parameters.
void Vertex::write(FILE* fp=stdout): This method writes the Vertex out to a file (default is STDOUT) in the .ray format.

Material: This class is used to describe the material properties of a Shape.

int Material::index: This specifies the index of the Material within the list of Materials specified in the .ray file.
Point3D Material::ambient: This specifies the ambient color of the Shape associated with the Material.
Point3D Material::diffuse: This specifies the diffuse color of the Shape associated with the Material.
Point3D Material::specular: This specifies the specular color of the Shape associated with the Material.
Point3D Material::emmisive: This specifies the emissive color of the Shape associated with the Material.
Flt Material::kspec: This specifies the specular "shininess" of the Shape associated with the Material. This should take a value between 0.0 and 1.0. The cosine of the angle between the ray and the direction to the light, raised to the power of 128*kspec gives the appropriate scaling factor for the specular highlite. This scaling factor is the same used to scale the contribution of the recursively reflected rays.
Flt Material::ktran: This specifies the transparency of the Shape associated with the Material. This should take a value between 0.0 and 1.0.
Flt Material::refind: This specifies the refraction index of the Shape associated with the Material.
Texture* Material::tex: If there is a Texture associated with the Shape, this is a pointer to that texture. If there is no Texture then this value is NULL.
char Material::foo[ ]: This stores a string that the user can use to specify some other material properties not inherently supported by the ray-tracer.
int Material::read(FILE* fp): This method reads out the ambient, diffuse, specular, and emissive colors, the specular "shininess" coefficient, the transparency, the refraction index, the Texture index and the foo-string from the file. (The parser then uses the Texture index to set the Texture pointer, and also sets the index.)
void Material::write(FILE* fp=stdout): This method writes the Material out to a file (default is STDOUT) in the .ray format.

Texture: This class is used to store the Image used for texture-mapping a Shape.

int Texture::index: This specifies the index of the Texture within the list of Textures specified in the .ray file
char Texture::filename[ ]: This is the name of the .bmp file from which the Image is to be read.
Image* Texture::img: This is a pointer to the Image read from the .bmp file.
int Texture::read(FILE* fp): This method reads out the .bmp file-name from the file. It then reads the file and generates the Image. (The parser then sets the index of the Texture.)
void Texture::write(FILE* fp=stdout): This method writes the Texture out to a file (default is STDOUT) in the .ray format.

RayFile: This class is used to store the scene-graph information of other .ray files that are included in the .ray file being parsed.

int RayFile::index: This specifies the index of RayFile within the list of RayFiles specified in the .ray file.
char RayFile::filename[ ]: This is the name of the .ray file from which the scene-graph information is to be read.
Scene* RayFile::scene: This a pointer to the scene-graph read from the .ray file.
int RayFile::read(FILE* fp): This method reads out the .ray file-name from the file. It then reads the file and generates the corresponding scene-graph. (The parser then sets the index of the RayFile.)
void RayFile::write(FILE* fp=stdout): This method writes the RayFile out to a file (default is STDOUT) in the .ray format.
void RayFile::free(void): This method frees up any resources associated with the scene-graph read from the file.

Scene: This class stores all of the information read from the .ray file including the Camera, background and ambient color, the list of Lights in the scene, and a pointer to the root node of the scene-graph.

Point3D Scene::ambient: This is the ambient color of the environment.
Point3D Scene::background: This is the background color of the environment.
Camera Scene::camera: This is the Camera that is used to ray-trace the scene.
Light** Scene::lights: This is the list of lights illuminating the scene.
int Scene::lightNum: This is the number of lights illuminating the scene.
Shape* Scene::shape: This is a pointer to the root node of the scene-graph.
Scene::Scene(void): This constructor creates a new Scene and sets all positions to (0.0,0.0,0.0) and all pointers to NULL.
Material* Scene::getMaterial(int index): Since the Materials are private, this method provides a way of getting a pointer to a Material given its index. (This is particularly useful if you want to write out Line objects corresponding to cast rays out to a file since the do not have any Material associated with them.)
void Scene::read(const char* filename): Given a name of a .ray file, this method reads out all of the Scene information. (This method assumes that there is an unspecified Group with the identity matrix as its local transform that is the root of the scene-graph.)
void Scene::write(FILE* fp=stdout): This method writes the Scene out to a file (default is STDOUT) in the .ray format. Note that since there is an assumed Group you can write more shapes to the file. In particular, for debugging purposes, you can transform your Rays into lines and add those to the file. Then, using the ray-viewer, you can check if you are sending off your rays in the right direction.

Point2D: This class defines a 2D vector and is used primarily for storing and manipulating texture coordinates.

Point2D::Point2D(void): This contsructor creates a new Point2D with coordinates (0.0,0.0).
Point2D::Point2D(Flt x, Flt y): This constructor creates a new Point2D with coordinates (x,y).
Flt& Point2D::operator[ ] (int index): This method allows one to access the Point2D in the same way one would access an array. (If p is of type Point2D then the commandp[i] returns a reference, not a copy, of the i-th coordinate of p.
void Point2D::print(void): This method prints out the Point2D to the screen.
void Point2D::printnl(void): This method prints out the Point2D to the screen followed by a new-line character.
Flt Point2D::dot(Point2D pt): This method returns the dot product of the Point2D object with pt. (If p is a Point2D then "p.dot(pt)" is the same as "p[0]*pt[0]+p[1]*pt[1]".)
Flt Point2D::length(void): This method returns the euclidean length of the Point2D object.
Point2D Point2D::unit(void): This method returns a unit-length scaled version of the Point2D object. (Note: an assert is used to make sure that the length of the Point2D is not 0.0.)
Point2D Point2D::negate(void): This method returns a copy of the Point2D object, scaled by -1.0. (If p is a Point2D then "p.negate( )" is the same as Point2D(-p[0],-p[1])".)
Point2D Point2D::operator- (void): This method returns a copy of the Point2D object, scaled by -1.0. (If p is a Point2D then "-p" is the same as Point2D(-p[0],-p[1])".)
Point2D Point2D::scale(Flt scl): This method returns a copy of the Point2D object, scaled by scl. (If p is a Point2D then "p.scale(s)" is the same as Point2D(p[0]*s,p[1]*s)".)
Point2D Point2D::operator* (Flt scale): This method returns a copy of the Point2D object, scaled by scale. (If p is a Point2D then "p*s" is the same as Point2D(p[0]*s,p[1]*s)".)
Point2D Point2D::operator/ (Flt scale): This method returns a copy of the Point2D object, scaled by 1/scale. (If p is a Point2D then "p/s" is the same as Point2D(p[0]/s,p[1]/s)".)
Point2D Point2D::add(Point2D pt): This method returns the sum of the Point2D object with pt. (If p is a Point2D then "p.add(pt)" is the same as Point2D(p[0]+pt[0],p[1]+pt[1])".)
Point2D Point2D::operator+ (Point2D pt): This method returns the sum of the Point2D object with pt. (If p is a Point2D then "p+pt" is the same as Point2D(p[0]+pt[0],p[1]+pt[1])".)
Point2D Point2D::subtract(Point2D pt): This method returns the difference of the Point2D object with pt. (If p is a Point2D then "p.subtract(pt)" is the same as Point2D(p[0]-pt[0],p[1]-pt[1])".)
Point2D Point2D::operator- (Point2D pt): This method returns the difference of the Point2D object with pt. (If p is a Point2D then "p-pt" is the same as Point2D(p[0]-pt[0],p[1]-pt[1])".)
Point2D Point2D::mult(Point2D pt): This method returns the component wise product the Point2D object with pt. (If p is a Point2D then "p.mult(pt)" is the same as Point2D(p[0]*pt[0],p[1]*pt[1])".)

Point3D: This class defines a 3D vector and is used for describing the positions of points, colors, directions and normals.

Point3D::Point3D(void): This contsructor creates a new Point3D with coordinates (0.0,0.0,0.0).
Point3D::Point3D(Flt x, Flt y, Flt z): This constructor creates a new Point3D with coordinates (x,y,z).
Flt& Point3D::operator[ ] (int index): This method allows one to access the Point3D in the same way one would access an array. (If p is of type Point3D then the command p[i] returns a reference, not a copy, of the i-th coordinate of p.
void Point3D::print(void): This method prints out the Point3D to the screen.
void Point3D::printnl(void): This method prints out the Point3D to the screen followed by a new-line character.
Flt Point3D::dot(Point3D pt): This method returns the dot product of the Point3D object with pt. (If p is a Point3D then "p.dot(pt)" is the same as "p[0]*pt[0]+p[1]*pt[1]+p[2]*pt[2]".)
Flt Point3D::length(void): This method returns the euclidean length of the Point3D object.
Point3D Point3D::unit(void): This method returns a unit-length scaled version of the Point3D object. (Note: an assert is used to make sure that the length of the Point3D is not 0.0.)
Point3D Point3D::negate(void): This method returns a copy of the Point3D object, scaled by -1.0. (If p is a Point3D then "p.negate( )" is the same as Point2D(-p[0],-p[1],-p[2])".)
Point3D Point3D::operator- (void): This method returns a copy of the Point3D object, scaled by -1.0. (If p is a Point3D then "-p" is the same as Point2D(-p[0],-p[1],-p[2])".)
Point3D Point3D::scale(Flt scl): This method returns a copy of the Point3D object, scaled by scl. (If p is a Point3D then "p.scale(s)" is the same as Point2D(p[0]*s,p[1]*s,p[2]*s)".)
Point3D Point3D::operator* (Flt scale): This method returns a copy of the Point3D object, scaled by scale. (If p is a Point3D then "p*s" is the same as Point2D(p[0]*s,p[1]*s,p[2]*s)".)
Point3D Point3D::operator/ (Flt scale): This method returns a copy of the Point3D object, scaled by 1/scale. (If p is a Point3D then "p/s" is the same as Point2D(p[0]/s,p[1]/s,p[2]/s)".)
Point3D Point3D::add(Point3Dpt): This method returns the sum of the Point3D object with pt. (If p is a Point3D then "p.add(pt)" is the same as Point2D(p[0]+pt[0],p[1]+pt[1],p[1]+pt[2],)".)
Point3D Point3D::operator+ (Point3D pt): This method returns the sum of the Point3D object with pt. (If p is a Point3D then "p+pt" is the same as Point2D(p[0]+pt[0],p[1]+pt[1],p[1]+pt[2],)".)
Point3D Point3D::subtract(Point3D pt): This method returns the difference of the Point3D object with pt. (If p is a Point3D then "p.subtract(pt)" is the same as Point2D(p[0]-pt[0],p[1]-pt[1],p[2]-pt[2],)".)
Point3D Point3D::operator- (Point3D pt): This method returns the difference of the Point3D object with pt. (If p is a Point3D then "p-pt" is the same as Point2D(p[0]-pt[0],p[1]-pt[1],p[2]-pt[2],)".)
Point3D Point3D::crossProduct(Point3D pt): This method returns the cross-product of the Point3D object with pt.
Point3D Point3D::mult(Point3D pt): This method returns the component wise product of the Point3D object with pt. (If p is a Point3D then "p.mult(pt)" is the same as Point2D(p[0]*pt[0],p[1]*pt[1],p[2]*pt[2],)".)

Ray: This is the class describing a directed Ray. A Ray is specified by its starting position and its direction, notits endpoint.

Point3D Ray::p: This is is the starting position of the Ray.
Point3D Ray::d: This is the direction of the Ray.
Ray::Ray(void): This constructor creates a new Ray with position and direction (0.0,0.0,0.0).
Ray::Ray(Point3D p,Point3D d): This constructor creates a new Ray with position p and direction d.
void Ray::print(void): This method prints out the Ray to the screen.
void Ray::printnl(void): This method prints out the Ray to the screen followed by a new-line character.
Ray Ray::translate(Point3D pt): This method returns a copy of the Ray object translated by pt. (If r is a Ray then "r.translate(pt)" is the same thing as "Ray(r.p+pt,r.d)".)
Point3D Ray::operator( ) (Flt param): This method returns the parametrized position of the ray. (If r is a Ray then "r(s)" is the same thing as "r.p+r.d*s".)
Point3D Ray::position(Flt param): This method returns the parametrized position of the ray. (If r is a Ray then "r.position(s)" is the same thing as "r.p+r.d*s".)

Matrix: This is the class describing affine transformations. The Matrix is a 4x4 matrix and is indexed in the column-row notation (first index specifying column, second index specifying row).

Flt& Matrix::operator( ) (int col,int row): This method returns a reference to the value in column col and row row. (If m is of type Matrix then "m(i,j)=1.0" sets the value at column i and row j to 1.0.)
Flt Matrix::det(void): This method returns the determinant of the Matrix.
void Matrix::print(void): This method prints out the Matrix to the screen.
void Matrix::printnl(void): This method prints out the Matrix to the screen followed by a new-line character.
Matrix Matrix::mult(Matrix m): This method returns the matrix product of the Matrix with m. (Multiplication by m is done on the right.)
Matrix Matrix::operator* (Matrix m): This method returns the matrix product of the Matrix with m. (Multiplication by m is done on the right.)
Matrix Matrix::transpose(void): This method returns the transpose of the Matrix.
Matrix Matrix::invert(void): This method returns the inverse of the Matrix.
Point3D Matrix::multPosition(Point3D position): This method applies the Matrix transformation to position treating it as a point in space. (This means that the translation part of the transformation is also applied.)
Point3D Matrix::multDirection(Point3D direction): This method applies the Matrix transformation to direction treating as a direction in space. (This means that the translation part of the transformation is not applied.)
Point3D Matrix::multNormal(Point3D normal): This method applies the Matrix transformation to direction treating it as a normal vector. (This means that if P is the plane normal to normal then the returned Point3D is the unit-length vector normal to the image of P under the Matrix transformation.)
Ray Matrix::mult(Ray ray): This method applies that Matrix transformation to a Ray.
Ray Matrix::operator* (Ray ray): This method applies that Matrix transformation to a Ray.

BoundingBox: This is the class describing the bounding box for a Shape. The bounding box is axis aligned and is specified by two antipodal vertices.

Point3D BoundingBox::p[2]: These are the two antipodal points describing the bounding box.
BoundingBox::BoundingBox(void): This constructor generates a bounding box whose antipodal points are both (0.0,0.0,0.0).
BoundingBox::BoundingBox(Point3D p1, Point3D p2): This constructor generates a bounding box containing the two specified points. It sets p[0] to be the point with the (x,y,z) coordinates equal to the minimum of the respecive (x,y,z) values of p1 and p2 and p[1] to be the point with (x,y,z) coordinates equal to the maximum of the respective (x,y,z) values of p1 and p2.
BoundingBox::BoundingBox(Point3D* pList, int listSize): This method generates the smallest bounding box that contains all of the points in the list.
BoundingBox BoundingBox::operator+ (BoundingBox b): This method provides a way for obtaining the bounding box containing the union of two bounding boxes.
BoundingBox BoundingBox::transform(Matrix m): This method transforms the bounding box using the transform m and returns the bounding box containing the transformed bounding box. (Note: Since bounding boxes are axis aligned applying a transform will not, in general return an axis aligned bounding box. An extra step has to be taken to compute the bounding box of the transformed bounding box. Also, it is not enough to compute the bounding box for the transform of the two vertices defining the initial bounding box since the transform need not preserve angles.)
Flt BoundingBox::intersects(Ray ray): This method returns the distance from the Ray to the bounding box. If the ray starts within the box it returns 0.0. If the ray does not intersect the box it returns -1.0.

Pixel: This is a struct that holds the red, green, and blue values of a point in an Image.

unsigned char Pixel::r: This is the red component of the pixel and can take values in the range 0-255.
unsigned char Pixel::g: This is the green component of the pixel and can take values in the range 0-255.
unsigned char Pixel::b: This is the blue component of the pixel and can take values in the range 0-255.

Image: This is a struct that stores an array of Pixels and the size of the Image.

int Image::width: This is the width of the image.
int Image::height: This is the height of the image.
Pixel* Image::pixels: This is the array of Pixels that make up the Image. (If img is of type Image then the pixel at position (x,y) can be accessed by "img->pixels[y*img->width+x]"

Return to top.

Assignment 2 - Ray Tracing Code Overview

Notes

File List

Class List

Function List

Class Description

List of members and methods

Functions

Description of Class Members and Methods

Assignment 2 - Ray Tracing
Code Overview