fixed #include file extensions as well (#9)

include/bounding_box.hpp

@@ -4,9 +4,9 @@
 //#####################################################################
 // Function #in
 //#####################################################################
-#include "object.h"
-#include "ray.h"
-#include "vec.h"
+#include "object.hpp"
+#include "ray.hpp"
+#include "vec.hpp"
 
 template<class T, int d>
 vec<T,d> componentwise_max(const vec<T,d>& a, const vec<T,d>& b)

include/box.hpp

@@ -1,8 +1,8 @@
 #ifndef __BOX_H__
 #define __BOX_H__
 
-#include "ray.h"
-#include "misc.h"
+#include "ray.hpp"
+#include "misc.hpp"
 #include <limits>
 
 class Box

include/camera.hpp

@@ -2,8 +2,8 @@
 #define __CAMERA_H__
 
 #include <algorithm>
-#include "vec.h"
-#include "misc.h"
+#include "vec.hpp"
+#include "misc.hpp"
 
 typedef unsigned int Pixel;
 

include/direction_light.hpp

@@ -5,8 +5,8 @@
 #include <vector>
 #include <iostream>
 #include <limits>
-#include "vec.h"
-#include "light.h"
+#include "vec.hpp"
+#include "light.hpp"
 
 class Direction_Light : public Light
 {

include/flat_shader.hpp

@@ -1,7 +1,7 @@
 #ifndef __FLAT_SHADER_H__
 #define __FLAT_SHADER_H__
 
-#include "shader.h"
+#include "shader.hpp"
 
 class Flat_Shader : public Shader
 {

include/hierarchy.hpp

@@ -1,7 +1,7 @@
 #ifndef __HIERARCHY_H__
 #define __HIERARCHY_H__
 
-#include "object.h"
+#include "object.hpp"
 
 /*
   A hierarchy is a binary tree.  We represent the hierarchy as a complete

include/light.hpp

@@ -5,7 +5,7 @@
 #include <vector>
 #include <iostream>
 #include <limits>
-#include "vec.h"
+#include "vec.hpp"
 
 class Ray;
 

include/mesh.hpp

@@ -1,7 +1,7 @@
 #ifndef __MESH_H__
 #define __MESH_H__
 
-#include "object.h"
+#include "object.hpp"
 
 // Consider a hit to be inside a triange if all barycentric weights
 // satisfy weight>=-weight_tol

include/object.hpp

@@ -2,8 +2,8 @@
 #define __OBJECT_H__
 
 #include <vector>
-#include "box.h"
-#include "vec.h"
+#include "box.hpp"
+#include "vec.hpp"
 
 // t has to be bigger than small_t to register an intersection with a ray.  You
 // may need to tweak this value.

include/phong_shader.hpp

@@ -1,7 +1,7 @@
 #ifndef __PHONG_SHADER_H__
 #define __PHONG_SHADER_H__
 
-#include "shader.h"
+#include "shader.hpp"
 
 class Phong_Shader : public Shader
 {

include/plane.hpp

@@ -1,7 +1,7 @@
 #ifndef __PLANE_H__
 #define __PLANE_H__
 
-#include "object.h"
+#include "object.hpp"
 
 class Plane : public Object
 {

include/point_light.hpp

@@ -5,8 +5,8 @@
 #include <vector>
 #include <iostream>
 #include <limits>
-#include "vec.h"
-#include "light.h"
+#include "vec.hpp"
+#include "light.hpp"
 
 class Point_Light : public Light
 {

include/ray.hpp

@@ -1,7 +1,7 @@
 #ifndef __RAY_H__
 #define __RAY_H__
 
-#include "vec.h"
+#include "vec.hpp"
 
 class Object;
 class Ray

include/reflective_shader.hpp

@@ -2,7 +2,7 @@
 #define __REFLECTIVE_SHADER_H__
 
 #include <algorithm>
-#include "shader.h"
+#include "shader.hpp"
 
 class Reflective_Shader : public Shader
 {

include/render_world.hpp

@@ -2,9 +2,9 @@
 #define __RENDER_WORLD_H__
 
 #include <vector>
-#include "camera.h"
-#include "hierarchy.h"
-#include "object.h"
+#include "camera.hpp"
+#include "hierarchy.hpp"
+#include "object.hpp"
 
 class Light;
 class Shader;

include/shader.hpp

@@ -1,7 +1,7 @@
 #ifndef __SHADER_H__
 #define __SHADER_H__
 
-#include "vec.h"
+#include "vec.hpp"
 class Render_World;
 class Ray;
 

include/sphere.hpp

@@ -1,7 +1,7 @@
 #ifndef __SPHERE_H__
 #define __SPHERE_H__
 
-#include "object.h"
+#include "object.hpp"
 class Sphere : public Object
 {
     vec3 center;

include/spot_light.hpp

@@ -5,8 +5,8 @@
 #include <vector>
 #include <iostream>
 #include <limits>
-#include "vec.h"
-#include "light.h"
+#include "vec.hpp"
+#include "light.hpp"
 
 class Spot_Light : public Light
 {

src/box.cpp

@@ -1,5 +1,5 @@
 #include <limits>
-#include "box.h"
+#include "box.hpp"
 
 // Return whether the ray intersects this box.
 bool Box::Intersection(const Ray& ray) const

src/camera.cpp

@@ -1,4 +1,4 @@
-#include "camera.h"
+#include "camera.hpp"
 
 Camera::Camera()
     :colors(0)

src/flat_shader.cpp

@@ -1,4 +1,4 @@
-#include "flat_shader.h"
+#include "flat_shader.hpp"
 
 vec3 Flat_Shader::
 Shade_Surface(const Ray& ray,const vec3& intersection_point,

src/hierarchy.cpp

@@ -1,5 +1,5 @@
 #include <algorithm>
-#include "hierarchy.h"
+#include "hierarchy.hpp"
 
 // Reorder the entries vector so that adjacent entries tend to be nearby.
 // You may want to implement box.cpp first.

src/main.cpp

@@ -1,5 +1,5 @@
-#include "render_world.h"
-#include "object.h"
+#include "render_world.hpp"
+#include "object.hpp"
 #include <iostream>
 #include <cstdio>
 #include <unistd.h>

src/mesh.cpp

@@ -1,4 +1,4 @@
-#include "mesh.h"
+#include "mesh.hpp"
 #include <fstream>
 #include <string>
 #include <limits>

src/parse.cpp

@@ -1,16 +1,16 @@
 #include <map>
 #include <sstream>
 #include <string>
-#include "direction_light.h"
-#include "flat_shader.h"
-#include "mesh.h"
-#include "phong_shader.h"
-#include "plane.h"
-#include "point_light.h"
-#include "reflective_shader.h"
-#include "render_world.h"
-#include "sphere.h"
-#include "spot_light.h"
+#include "direction_light.hpp"
+#include "flat_shader.hpp"
+#include "mesh.hpp"
+#include "phong_shader.hpp"
+#include "plane.hpp"
+#include "point_light.hpp"
+#include "reflective_shader.hpp"
+#include "render_world.hpp"
+#include "sphere.hpp"
+#include "spot_light.hpp"
 
 void Parse(Render_World& world,int& width,int& height,const char* test_file)
 {

src/phong_shader.cpp

@@ -1,8 +1,8 @@
-#include "light.h"
-#include "phong_shader.h"
-#include "ray.h"
-#include "render_world.h"
-#include "object.h"
+#include "light.hpp"
+#include "phong_shader.hpp"
+#include "ray.hpp"
+#include "render_world.hpp"
+#include "object.hpp"
 
 vec3 Phong_Shader::
 Shade_Surface(const Ray& ray,const vec3& intersection_point,

src/plane.cpp

@@ -1,5 +1,5 @@
-#include "plane.h"
-#include "ray.h"
+#include "plane.hpp"
+#include "ray.hpp"
 #include <cfloat>
 #include <limits>
 

src/reflective_shader.cpp

@@ -1,6 +1,6 @@
-#include "reflective_shader.h"
-#include "ray.h"
-#include "render_world.h"
+#include "reflective_shader.hpp"
+#include "ray.hpp"
+#include "render_world.hpp"
 
 vec3 Reflective_Shader::
 Shade_Surface(const Ray& ray,const vec3& intersection_point,

src/render_world.cpp

@@ -1,8 +1,8 @@
-#include "render_world.h"
-#include "flat_shader.h"
-#include "object.h"
-#include "light.h"
-#include "ray.h"
+#include "render_world.hpp"
+#include "flat_shader.hpp"
+#include "object.hpp"
+#include "light.hpp"
+#include "ray.hpp"
 
 extern bool disable_hierarchy;
 

src/sphere.cpp

@@ -1,5 +1,5 @@
-#include "sphere.h"
-#include "ray.h"
+#include "sphere.hpp"
+#include "ray.hpp"
 
 // Determine if the ray intersects with the sphere
 Hit Sphere::Intersection(const Ray& ray, int part) const