From 9e556ed5343384fcf9258fe0f37af3c1fb9b9b3d Mon Sep 17 00:00:00 2001
From: Roland Hieber <rhieber@gaffel.ibr.cs.tu-bs.de>
Date: Tue, 12 Jan 2010 18:08:26 +0100
Subject: [PATCH] code from assignment 1

---
 Camera.cxx            |  29 ++++++++
 Camera.hxx            |  20 ++++++
 Image.cxx             |  73 +++++++++++++++++++
 Image.hxx             |  28 ++++++++
 Makefile              |  26 +++++++
 MicroTrace.cxx        |  74 +++++++++++++++++++
 PerspectiveCamera.cxx |  46 ++++++++++++
 PerspectiveCamera.hxx |  35 +++++++++
 Primitive.hxx         |  12 ++++
 Ray.cxx               |  42 +++++++++++
 Ray.hxx               |  27 +++++++
 Triangle.cxx          |  51 +++++++++++++
 Triangle.hxx          |  16 +++++
 Vec3f.cxx             | 163 ++++++++++++++++++++++++++++++++++++++++++
 Vec3f.hxx             |  85 ++++++++++++++++++++++
 15 files changed, 727 insertions(+)
 create mode 100644 Camera.cxx
 create mode 100644 Camera.hxx
 create mode 100644 Image.cxx
 create mode 100644 Image.hxx
 create mode 100644 Makefile
 create mode 100644 MicroTrace.cxx
 create mode 100644 PerspectiveCamera.cxx
 create mode 100644 PerspectiveCamera.hxx
 create mode 100644 Primitive.hxx
 create mode 100644 Ray.cxx
 create mode 100644 Ray.hxx
 create mode 100644 Triangle.cxx
 create mode 100644 Triangle.hxx
 create mode 100644 Vec3f.cxx
 create mode 100644 Vec3f.hxx

diff --git a/Camera.cxx b/Camera.cxx
new file mode 100644
index 0000000..7664b15
--- /dev/null
+++ b/Camera.cxx
@@ -0,0 +1,29 @@
+#include "Camera.hxx"
+
+Camera::Camera()
+  : m_resX(-1),
+    m_resY(-1)
+{
+}
+
+Camera::Camera(int resX, int resY) 
+  : m_resX(resX),
+    m_resY(resY)
+{
+}
+
+Camera::~Camera()
+{
+}
+
+int
+Camera::resX() const
+{
+  return m_resX;
+}
+
+int 
+Camera::resY() const
+{
+  return m_resY;
+}
diff --git a/Camera.hxx b/Camera.hxx
new file mode 100644
index 0000000..51f9865
--- /dev/null
+++ b/Camera.hxx
@@ -0,0 +1,20 @@
+#ifndef CAMERA_HXX
+#define CAMERA_HXX
+
+#include "Ray.hxx"
+
+class Camera 
+{
+public:
+  Camera(int resX, int resY);
+  virtual ~Camera();
+  virtual bool InitRay(float x, float y, Ray &ray) = 0;
+  
+  int resX() const;
+  int resY() const;
+protected:
+  Camera();
+
+  int m_resX, m_resY;
+};
+#endif
diff --git a/Image.cxx b/Image.cxx
new file mode 100644
index 0000000..b45cac9
--- /dev/null
+++ b/Image.cxx
@@ -0,0 +1,73 @@
+#include <cassert>
+#include <fstream>
+#include <iostream>
+
+#include "Image.hxx"
+
+Image::Image(int resX, int resY)
+:
+  m_resX(resX),
+  m_resY(resY)
+{
+  assert (resX > 0 && resY > 0);
+  std::cerr << "(Image): ResX = " << m_resX << ", resY = " << m_resY << std::endl;
+  m_pixel = new Vec3f[m_resX*m_resY];
+}
+
+Image::~Image()
+{
+  delete [] m_pixel;
+}
+
+Image::Image()
+{
+}
+
+Image::Image(const Image& o)
+{
+  operator=(o);
+}
+
+Image&
+Image::operator=(const Image& o)
+{
+  return *this;
+}
+
+Vec3f&
+Image::operator()(int x, int y)
+{
+  assert(x >= 0 && x < m_resX);
+  assert(y >= 0 && y < m_resY);
+	 
+  return m_pixel[y*m_resX+x];	 
+}
+
+void Image::WritePPM(const std::string& fileName)
+{
+  std::cerr << "(Image): Writing to file " << fileName << std::endl;
+  std::ofstream file(fileName.c_str());
+  
+  if(!file.is_open())
+    {
+      std::cerr << "(Image): Could not open file " << fileName << std::endl;
+      return;
+    }
+  
+  file << "P3" << std::endl;
+  file << m_resX << " " << m_resY << " " << 255 << std::endl;
+  for (int y=m_resY-1;y>=0;y--) 
+    {
+      for (int x=0;x<m_resX;x++)
+	{
+	  file 
+	    << (int)(255.99999999 * (*this)(x,y)[0]) << " "
+	    << (int)(255.99999999 * (*this)(x,y)[1]) << " "
+	    << (int)(255.99999999 * (*this)(x,y)[2]) << " "
+	    << "\t";
+	}
+      file << std::endl;
+      file << std::flush;
+    }
+  file.close();
+ }
diff --git a/Image.hxx b/Image.hxx
new file mode 100644
index 0000000..89a7a9e
--- /dev/null
+++ b/Image.hxx
@@ -0,0 +1,28 @@
+#ifndef IMAGE_HXX
+#define IMAGE_HXX
+
+#include <string>
+
+#include "Vec3f.hxx"
+
+class Image
+{
+public:
+  Image(int resX,int resY);
+  ~Image();
+  
+  //! pixel access operator read/write
+  Vec3f& operator()(int x, int y);
+    
+  void WritePPM(const std::string& fileName);/*in Image.cxx*/
+  
+private:
+  Image();
+  Image(const Image& );
+  Image& operator=(const Image& );
+  
+  int m_resX, m_resY;
+  Vec3f* m_pixel;
+};
+
+#endif
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..2223440
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,26 @@
+.SUFFIXES: .cxx .a
+
+all: MicroTrace
+
+CC = g++ 
+CFLAGS = -O3 -Wall
+
+OBJ = MicroTrace.o\
+      Vec3f.o\
+      Camera.o\
+      PerspectiveCamera.o\
+      Image.o\
+      Ray.o
+
+%.o: %.cxx *.hxx
+	$(CC) $(CFLAGS) -c $< -o $@
+
+%.a:
+	ar r $@ $<
+
+
+
+MicroTrace: $(OBJ)
+
+clean: 
+	rm *.o *.a MicroTrace
diff --git a/MicroTrace.cxx b/MicroTrace.cxx
new file mode 100644
index 0000000..d0b1d6e
--- /dev/null
+++ b/MicroTrace.cxx
@@ -0,0 +1,74 @@
+#include <string>
+
+#include "Vec3f.hxx"
+//#include "Sphere.hxx"
+//#include "Triangle.hxx"
+//#include "InfinitePlane.hxx"
+
+#include "Image.hxx"
+#include "PerspectiveCamera.hxx"
+
+void RenderFrame(Camera &camera,
+		 const std::string& fileName)
+{
+  /* scene objects */
+
+  /*
+    Sphere s1(Vec3f(-2,1.7,0),2);
+    Sphere s2(Vec3f(1,-1,1),2.2);
+    Sphere s3(Vec3f(3,0.8,-2),2);*/
+  //InfinitePlane p1(Vec3f(0,-1,0),Vec3f(0,1,0));
+
+  /*
+    Triangle t1(Vec3f(-2,3.7,0),Vec3f(1,2,1),Vec3f(3,2.8,-2)); 
+    Triangle t2(Vec3f(3,2,3),Vec3f(3,2,-3),Vec3f(-3,2,-3)); 	
+  */
+  Image img(camera.resX(),camera.resY()); // image array
+  Ray ray;                            // primary ray
+  
+  for(int y=0;y<camera.resY();y++)
+    for (int x=0;x<camera.resX();x++) 
+      {
+	
+	/* Initialize your ray here */
+	
+	camera.InitRay(x+0.5,y+0.5,ray); // initialize ray
+	
+	Vec3f col = Vec3f(0,0,0); // background color
+	
+	/*      
+		if (s1.Intersect(ray))
+		col = Vec3f(1,0,0);
+		if (s2.Intersect(ray))
+		col = Vec3f(0,1,0);
+		if (s3.Intersect(ray))
+		col = Vec3f(0,0,1);
+		if (p1.Intersect(ray))
+		col = Vec3f(1,1,0);
+		if (t1.Intersect(ray))
+		col = Vec3f(0,1,1);
+		if (t2.Intersect(ray))
+		col = Vec3f(1,1,1);
+		
+		img(x,y) = col; // store pixel color
+	*/
+      }
+  img.WritePPM(fileName); // write final image
+}
+
+#define RESX 640 // image x-resolution
+#define RESY 480 // image y-resolution
+
+int main(int, char**)
+{
+  /* render three images with different camera settings */
+
+  PerspectiveCamera c1(Vec3f(0,0,10),Vec3f(0,0,-1),Vec3f(0,1,0),60,RESX,RESY);
+  RenderFrame(c1,"perspective1.ppm");
+
+  PerspectiveCamera c2(Vec3f(-8,3,8),Vec3f(1,-.1,-1),Vec3f(0,1,0),45,RESX,RESY);
+  RenderFrame(c2,"perspective2.ppm");
+
+  PerspectiveCamera c3(Vec3f(-8,3,8),Vec3f(1,-.1,-1),Vec3f(1,1,0),45,RESX,RESY);
+  RenderFrame(c3,"perspective3.ppm");
+}
diff --git a/PerspectiveCamera.cxx b/PerspectiveCamera.cxx
new file mode 100644
index 0000000..b7faff6
--- /dev/null
+++ b/PerspectiveCamera.cxx
@@ -0,0 +1,46 @@
+#include "PerspectiveCamera.hxx"
+
+PerspectiveCamera::PerspectiveCamera()
+  : Camera()
+{
+}
+
+PerspectiveCamera::PerspectiveCamera(const Vec3f& pos,
+				     const Vec3f& dir,
+				     const Vec3f& up,
+				     float angle,
+				     int resX,
+				     int resY)
+  : Camera(resX,resY),
+    m_pos(pos),
+    m_dir(dir),
+    m_up(up),
+    m_angle(angle)    
+{
+  // preprocess the values and fill the rest of the member variables here
+}
+
+PerspectiveCamera::~PerspectiveCamera()
+{
+}
+
+PerspectiveCamera::PerspectiveCamera(const PerspectiveCamera& )
+{
+
+}
+
+PerspectiveCamera&
+PerspectiveCamera::operator=(const PerspectiveCamera& )
+{
+  return *this;
+}
+
+bool
+PerspectiveCamera::InitRay(float x, //!< pixel x-coordinate 
+			   float y, //!< pixel y-coordinate
+			   Ray& ray //!< should be filled by this function
+			   )
+{
+  // define direction,position and maximum hit distance of Ray here
+  return false;
+}
diff --git a/PerspectiveCamera.hxx b/PerspectiveCamera.hxx
new file mode 100644
index 0000000..8178087
--- /dev/null
+++ b/PerspectiveCamera.hxx
@@ -0,0 +1,35 @@
+#ifndef PERSPECTIVECAMERA_HXX
+#define PERSPECTIVECAMERA_HXX
+
+#include "Camera.hxx"
+
+class PerspectiveCamera : public Camera
+{
+public:
+  PerspectiveCamera(const Vec3f& pos,
+		    const Vec3f& dir,
+		    const Vec3f& up,
+		    float angle,
+		    int resX, 
+		    int resY
+		    );
+  ~PerspectiveCamera();
+
+  virtual bool InitRay(float x, float y, Ray &ray);
+
+private:
+  //! hidden constructors to prevent misuse. If you need those at some point, just make them public and implement them properly!
+  PerspectiveCamera();
+  PerspectiveCamera(const PerspectiveCamera& c);
+  PerspectiveCamera& operator=(const PerspectiveCamera& c);
+
+  //! input values
+  Vec3f m_pos, m_dir, m_up;
+  float m_angle;
+  
+  //! preprocessed values
+  float m_focus;
+  Vec3f m_xAxis, m_yAxis, m_zAxis;
+  float m_aspect;
+};
+#endif
diff --git a/Primitive.hxx b/Primitive.hxx
new file mode 100644
index 0000000..f147b35
--- /dev/null
+++ b/Primitive.hxx
@@ -0,0 +1,12 @@
+#ifndef PRIMITIVE_HXX
+#define PRIMITIVE_HXX
+
+#include "Ray.hxx"
+
+class Primitive
+{
+public:
+  virtual bool Intersect(Ray &ray) = 0;
+};
+
+#endif
diff --git a/Ray.cxx b/Ray.cxx
new file mode 100644
index 0000000..be4a4f4
--- /dev/null
+++ b/Ray.cxx
@@ -0,0 +1,42 @@
+#include "Ray.hxx"
+
+Ray::Ray()
+{
+}
+
+Ray::Ray(const Vec3f& org, 
+	 const Vec3f& dir)
+{
+}
+
+Ray::~Ray()
+{
+}
+
+Ray::Ray(const Ray& r)
+{
+}
+
+Ray&
+Ray::operator=(const Ray& r)
+{
+  return *this;
+}
+
+const Vec3f&
+Ray::origin() const
+{
+  return Vec3f();
+}
+
+const Vec3f&
+Ray::direction() const
+{
+  return Vec3f();
+}
+
+float
+Ray::t() const
+{
+  return 0.0f;
+}
diff --git a/Ray.hxx b/Ray.hxx
new file mode 100644
index 0000000..a432830
--- /dev/null
+++ b/Ray.hxx
@@ -0,0 +1,27 @@
+#ifndef RAY_HXX
+#define RAY_HXX
+
+#include "Vec3f.hxx"
+
+class Ray
+{
+public:
+  Ray();
+  Ray(const Vec3f& org, const Vec3f& dir);
+  ~Ray();
+  Ray(const Ray& r);
+  Ray& operator=(const Ray& r);
+  
+  const Vec3f& origin() const;
+  const Vec3f& direction() const;
+  float t() const;
+private:
+  Vec3f m_org; //!< ray origin
+  Vec3f m_dir; //!< ray direction
+  float m_t;   //!< current/maximum hit distance
+};
+
+inline std::ostream &operator<<(std::ostream &o,const Ray &ray)
+{ o << "Ray [" << ray.origin() << "+t*" << ray.direction() << "]"; return o; }
+
+#endif
diff --git a/Triangle.cxx b/Triangle.cxx
new file mode 100644
index 0000000..ffddbc8
--- /dev/null
+++ b/Triangle.cxx
@@ -0,0 +1,51 @@
+#include "Triangle.hxx"
+
+Triangle::Triangle(const Vec3f& a,
+		   const Vec3f& b,
+		   const Vec3f& c)
+  : m_a(a),
+    m_b(b),
+    m_c(c)
+{
+}
+
+Triangle::~Triangle()
+{
+}
+
+bool
+Triangle::Intersect(Ray& ray)
+{
+  const Vec3f edge1 = m_b-m_a;
+  const Vec3f edge2 = m_c-m_a;
+  
+  const Vec3f pvec = ray.direction().cross(edge2);
+  
+  const float det = edge1.dot(pvec);
+  if (fabs(det) < Epsilon) return false;
+  
+  const float inv_det = 1.0f / det;
+  
+  const Vec3f tvec = ray.origin()-m_a;
+  float lambda = tvec.dot( pvec );
+  lambda *= inv_det;
+    
+  if (lambda < 0.0f || lambda > 1.0f) 
+    return false;
+
+  const Vec3f qvec = tvec.cross(edge1);
+  float mue = ray.direction().dot(qvec);
+  mue *= inv_det;
+  
+  if (mue < 0.0f || mue+lambda > 1.0f) 
+    return false;
+
+  float f = edge2.dot(qvec);
+  f *= inv_det;
+  if (ray.t() <= f || f <  1e-4  ) 
+    return false;
+  
+  ray.setT(f);
+    
+  return true;
+}
diff --git a/Triangle.hxx b/Triangle.hxx
new file mode 100644
index 0000000..320cca5
--- /dev/null
+++ b/Triangle.hxx
@@ -0,0 +1,16 @@
+#ifndef TRIANGLE_HXX
+#define TRIANGLE_HXX
+
+#include "Primitive.hxx"
+
+class Triangle : public Primitive
+{
+public:
+  Triangle(const Vec3f& a, const Vec3f& b, const Vec3f& c);
+  virtual ~Triangle();
+  
+  virtual bool Intersect(Ray& ray);
+private:
+  Vec3f m_a, m_b, m_c;
+};
+#endif
diff --git a/Vec3f.cxx b/Vec3f.cxx
new file mode 100644
index 0000000..c063913
--- /dev/null
+++ b/Vec3f.cxx
@@ -0,0 +1,163 @@
+#include <cassert>
+
+#include "Vec3f.hxx"
+
+Vec3f::Vec3f()
+{
+
+}
+
+Vec3f::Vec3f(float x, float y, float z)
+{
+
+}
+
+Vec3f::~Vec3f()
+{
+}
+
+Vec3f::Vec3f(const Vec3f& o)
+{
+
+}
+
+Vec3f& 
+Vec3f::operator=(const Vec3f& o)
+{
+  
+  return *this;
+}
+
+float 
+Vec3f::operator|(const Vec3f& o)
+{
+  
+  return 0.0f;
+}
+
+float 
+Vec3f::dot(const Vec3f& o)
+{
+  
+  return 0.0f;
+}
+  
+Vec3f 
+Vec3f::operator%(const Vec3f& o)
+{
+
+  return Vec3f();
+}
+
+Vec3f 
+Vec3f::cross(const Vec3f& o)
+{
+  
+  return Vec3f();
+}
+  
+void 
+Vec3f::normalize()
+{
+  
+}
+
+float 
+Vec3f::norm() const
+{
+  return 0.0f;
+}
+
+Vec3f 
+Vec3f::operator*(const float t) const
+{
+  return Vec3f();
+}
+
+Vec3f& 
+Vec3f::operator*=(const float t)
+{
+  return *this;
+}
+
+Vec3f 
+Vec3f::operator/(const float t) const
+{
+  return Vec3f();
+}
+
+Vec3f& 
+Vec3f::operator/=(const float t)
+{
+  return *this;
+}
+
+// example implementation of a standard operator
+Vec3f 
+Vec3f::operator+(const Vec3f& o) const
+{
+  Vec3f v(*this);
+  
+  return v += o;
+}
+
+// example implementation of an in-place operator
+Vec3f& 
+Vec3f::operator+=(const Vec3f& o)
+{
+  for(unsigned int i = 0; i < 3; ++i)
+    {
+      m_values[i] += o.m_values[i];
+    }
+  
+  return *this;
+}
+  
+Vec3f 
+Vec3f::operator-(const Vec3f& o) const
+{
+  return Vec3f();
+}
+
+Vec3f& 
+Vec3f::operator-=(const Vec3f& o)
+{
+  return *this;
+}
+  
+Vec3f 
+Vec3f::operator*(const Vec3f& o) const
+{
+  return Vec3f();
+}
+
+Vec3f& 
+Vec3f::operator*=(const Vec3f& o)
+{
+  return *this;
+}
+
+Vec3f 
+Vec3f::operator/(const Vec3f& o) const
+{
+  return Vec3f();
+}
+
+Vec3f& 
+Vec3f::operator/=(const Vec3f& o)
+{
+  return *this;
+}
+
+float 
+Vec3f::operator[](unsigned int i) const
+{
+  return 0.0f;
+}
+
+float& 
+Vec3f::operator[](unsigned int i)
+{
+  assert(i < 3);
+  return m_values[i];
+}
diff --git a/Vec3f.hxx b/Vec3f.hxx
new file mode 100644
index 0000000..74f304b
--- /dev/null
+++ b/Vec3f.hxx
@@ -0,0 +1,85 @@
+#ifndef VEC3F_HXX
+#define VEC3F_HXX
+
+#include <cmath>
+#include <iostream>
+
+
+#ifndef MIN
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+#define max(a,b) MAX(a,b)
+#define min(a,b) MIN(a,b)
+
+#define Epsilon 1E-4
+#define Infinity HUGE_VAL
+
+//! Standard operators and useful methods for 3d vectors
+//! Fill in the missing parts in Vec3f.cxx
+class Vec3f 
+{
+public:
+  Vec3f();
+  Vec3f(float x, float y, float z);
+  
+  ~Vec3f();
+
+  Vec3f(const Vec3f& o);
+  Vec3f& operator=(const Vec3f& o);
+
+  //! dot product
+  float operator|(const Vec3f& o);
+  float dot(const Vec3f& o);
+  
+  //! cross product
+  Vec3f operator%(const Vec3f& o);
+  Vec3f cross(const Vec3f& o);
+  
+  //! normalize vector
+  void normalize();
+  //! length of a vector
+  float norm() const;
+
+  //! (self-)multiply with scalar
+  Vec3f operator*(const float t) const;
+  Vec3f& operator*=(const float t);
+
+  //! (self-)division by scalar
+  Vec3f operator/(const float t) const;
+  Vec3f& operator/=(const float t);
+
+  //! vector (self-)addition
+  Vec3f operator+(const Vec3f& o) const;
+  Vec3f& operator+=(const Vec3f& o);
+  
+  //! vector (self-)subtraction
+  Vec3f operator-(const Vec3f& o) const;
+  Vec3f& operator-=(const Vec3f& o);
+  
+  //! component-wise multiplication of two vectors
+  Vec3f operator*(const Vec3f& o) const;
+  Vec3f& operator*=(const Vec3f& o);
+
+  //! component-wise division of two vectors
+  Vec3f operator/(const Vec3f& o) const;
+  Vec3f& operator/=(const Vec3f& o);
+
+  //! element access functions ( read-only and read-write )
+  float operator[](unsigned int i) const;
+  float& operator[](unsigned int i);
+ 
+private:
+  float m_values[3];
+};
+
+inline std::ostream& operator<<(std::ostream& o, const Vec3f& v)
+{
+  o << "(" << v[0] << "," << v[1] << "," << v[2] << ")";
+  return o;
+}
+
+#endif
+
+
-- 
2.20.1