Added Vector3 and sphere. There is an unknown problem with the normal calculation of the sphere.

Author: kogandg

Renderer/Color.cpp

@@ -68,22 +68,22 @@ void Color::SetRaw(unsigned char raw[])
 	}
 }
 
-double Color::GetR()
+double Color::GetR() const
 {
 	return (double)(r)/255.0f;
 }
 
-double Color::GetG()
+double Color::GetG() const
 {
 	return (double)(g) / 255.0f;
 }
 
-double Color::GetB()
+double Color::GetB() const
 {
 	return (double)(b) / 255.0f;
 }
 
-double Color::GetA()
+double Color::GetA() const
 {
 	return (double)(a) / 255.0f;
 }
@@ -119,3 +119,13 @@ Color& Color::operator=(const Color& c)
 	return *this;
 }
 
+Color Color::operator*(double t)
+{
+	return Color(GetR()*t, GetG()*t, GetB()*t);
+}
+
+Color Color::operator+(const Color& obj)
+{
+	return Color(GetR() + obj.GetR(), GetG() + obj.GetG(), GetB() + obj.GetB());
+}
+

Renderer/Color.h

@@ -28,16 +28,18 @@ class Color
 	unsigned char* GetRaw();
 	void SetRaw(unsigned char raw[]);
 
-	double GetR();
-	double GetG();
-	double GetB();
-	double GetA();
+	double GetR() const;
+	double GetG() const;
+	double GetB() const;
+	double GetA() const;
 
 	void SetR(double r);
 	void SetG(double g);
 	void SetB(double b);
 	void SetA(double a);
 
 	Color& operator =(const Color &c);
+	Color operator*(double t);
+	Color operator+(const Color& obj);
 };
 

Renderer/Ray.cpp

@@ -0,0 +1,27 @@
+#include "Ray.h"
+
+Ray::Ray()
+{
+
+}
+
+Ray::Ray(const Vector3& origin, const Vector3& direction)
+{
+	this->origin = origin;
+	this->direction = direction;
+}
+
+Vector3 Ray::At(double t) const
+{
+	return origin + direction*t;
+}
+
+Vector3 Ray::GetOrigin() const
+{
+	return origin;
+}
+
+Vector3 Ray::GetDirection() const
+{
+	return direction;
+}

Renderer/Ray.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Vector3.h"
+
+class Ray
+{
+private:
+	Vector3 origin;
+	Vector3 direction;
+public:
+	Ray();
+	Ray(const Vector3& origin, const Vector3& direction);
+
+	Vector3 At(double t) const;
+
+	Vector3 GetOrigin() const;
+	Vector3 GetDirection() const;
+};
+

Renderer/Renderer.cpp

@@ -1,23 +1,98 @@
 #include <iostream>
+#include <math.h>
 
 #include "Color.h"
 #include "TGAImage.h"
+#include "Vector3.h"
+#include "Ray.h"
 
 using namespace std;
 
+double hitSphere(const Vector3& center, double radius, const Ray& r)
+{
+	Vector3 oc = r.GetOrigin() - center;
+	//quaradic equation
+	double a = r.GetDirection().Dot(r.GetDirection());
+	double b = oc.Dot(r.GetDirection()) * 2.0;
+	double c = oc.Dot(oc) - (radius * radius);
+	double discriminant = (b * b) - (4 * a * c);
+
+	if (discriminant < 0)
+	{
+		return -1.0;
+	}
+	else
+	{
+		return (-b - sqrt(discriminant)) / (2.0 * a);
+	}
+}
+
+Color rayColor(const Ray& r) {
+	double t = hitSphere(Vector3(0, 0, -1), 0.5, r);
+	if (t > 0.0)
+	{
+		Vector3 normal = (r.At(t) - Vector3(0, 0, -1)).Unit();
+		return Color(normal.X + 1, normal.Y + 1, normal.Z + 1) * 0.5;
+	}
+
+	Vector3 unitDirection = r.GetDirection().Unit();
+	double a = (unitDirection.Y + 1.0) * 0.5;
+	return Color(1.0, 1.0, 1.0) * (1.0 - a) + Color(0.5, 0.7, 1.0) * a;
+}
+
 int main()
 {
-    int imageWidth = 256;
-    int imageHeight = 256;
-
-    TGAImage image(imageWidth, imageHeight, 4);
-    for (int y = 0; y < imageHeight; y++)
-    {
-        for (int x = 0; x < imageWidth; x++)
-        {
-            Color color(double(x) / double(imageWidth - 1), double(y) / double(imageHeight - 1), 0);
-            image.SetPixel(x, y, color);
-        }
-    }
-    image.WriteTGAFile("out.tga");
+	//Image
+	double aspectRatio = 16.0 / 9.0;
+	int imageWidth = 400;
+
+	//Calc height using aspect ratio and ensure it is at least 1
+	int imageHeight = double(imageWidth) / aspectRatio;
+	if (imageHeight < 1)
+	{
+		imageHeight = 1;
+	}
+
+	TGAImage image(imageWidth, imageHeight, 4);
+
+	//Camera
+	double focalLength = 1.0;
+	double viewportHeight = 2.0;
+	double viewportWidth = viewportHeight * (double(imageWidth) / double(imageHeight));
+	Vector3 cameraCenter = Vector3(0, 0, 0);
+
+	//Calc vectors across the horizonal and down the vertical edges of viewport
+	Vector3 viewportU = Vector3(viewportWidth, 0, 0);//horizontal
+	Vector3 viewportV = Vector3(0, -viewportHeight, 0);//vertical
+
+	//Calc delta vector for pixels across viewport
+	Vector3 pixelDeltaU = viewportU / imageWidth;
+	Vector3 pixelDeltaV = viewportV / imageHeight;
+
+	//Calc location of upper left pixel
+	Vector3 viewportUpperLeft = cameraCenter - Vector3(0, 0, focalLength) - viewportU / 2 - viewportV / 2;
+	Vector3 pixel0Center = viewportUpperLeft + (pixelDeltaU + pixelDeltaV) * 0.5;
+
+	//Render
+	for (int y = 0; y < imageHeight; y++)
+	{
+		//clog << "\x1b[2K";
+		//clog << "\rScanlines remaining: " << (imageHeight - y) << ' ' << flush;
+
+		for (int x = 0; x < imageWidth; x++)
+		{
+			Vector3 pixelCenter = pixel0Center + (pixelDeltaU * x) + (pixelDeltaV * y);
+			Vector3 rayDirection = pixelCenter - cameraCenter;
+			Ray ray = Ray(cameraCenter, rayDirection);
+
+			//Color color = Color(double(x) / double(imageWidth - 1), double(y) / double(imageHeight - 1), 0);
+			Color color = rayColor(ray);
+
+
+			image.SetPixel(x, y, color);
+		}
+	}
+	//clog << "\x1b[2K";
+	//clog << "\rDone";
+	image.WriteTGAFile("out.tga");
 }

Renderer/Renderer.vcxproj

@@ -128,12 +128,19 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="Color.cpp" />
+    <ClCompile Include="Ray.cpp" />
     <ClCompile Include="Renderer.cpp" />
     <ClCompile Include="TGAImage.cpp" />
+    <ClCompile Include="Vector3.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Color.h" />
+    <ClInclude Include="Ray.h" />
     <ClInclude Include="TGAImage.h" />
+    <ClInclude Include="Vector3.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="out.tga" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Renderer/Renderer.vcxproj.filters

@@ -24,6 +24,12 @@
     <ClCompile Include="Color.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Vector3.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Ray.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="TGAImage.h">
@@ -32,5 +38,16 @@
     <ClInclude Include="Color.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Vector3.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Ray.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="out.tga">
+      <Filter>Resource Files</Filter>
+    </Image>
   </ItemGroup>
 </Project>

Renderer/Vector3.cpp

@@ -0,0 +1,106 @@
+#include "Vector3.h"
+
+Vector3::Vector3()
+{
+	X = 0;
+	Y = 0;
+	Z = 0;
+}
+
+Vector3::Vector3(double x, double y, double z)
+{
+	X = x;
+	Y = y;
+	Z = z;
+}
+
+Vector3::Vector3(const Vector3& v)
+{
+	X = v.X;
+	Y = v.Y;
+	Z = v.Z;
+}
+
+double Vector3::Length()
+{
+	return sqrt(LengthSquared());
+}
+
+double Vector3::LengthSquared()
+{
+	return (X * X) + (Y * Y) + (Z * Z);
+}
+
+double Vector3::Dot(const Vector3& v)
+{
+	return (X * v.X) + (Y * v.Y) + (Z * v.Z);
+}
+
+Vector3 Vector3::Cross(const Vector3& v)
+{
+	return Vector3((Y * v.Z) - (Z * v.Y), (Z * v.X) - (X * v.Z), (X * v.Y) - (Y * v.X));
+}
+
+Vector3 Vector3::Unit()
+{
+	double length = Length();
+	return Vector3(X/length, Y/length, Z/length);
+}
+
+Vector3 Vector3::operator-() const
+{
+	return Vector3(-X, -Y, -Z);
+}
+
+Vector3& Vector3::operator+=(const Vector3& rhs)
+{
+	X += rhs.X;
+	Y += rhs.Y;
+	Z += rhs.Z;
+	return *this;
+}
+
+Vector3& Vector3::operator*=(double t)
+{
+	X *= t;
+	Y *= t;
+	Z *= t;
+	return *this;
+}
+
+Vector3& Vector3::operator/=(double t)
+{
+	return *this *= 1 / t;
+}
+
+Vector3 Vector3::operator+(const Vector3& obj) const
+{
+	return Vector3(X + obj.X, Y + obj.Y, Z + obj.Z);
+}
+
+Vector3 Vector3::operator-(const Vector3& obj) const
+{
+	return Vector3(X - obj.X, Y - obj.Y, Z - obj.Z);
+}
+
+Vector3 Vector3::operator*(const Vector3& obj) const
+{
+	return Vector3(X * obj.X, Y * obj.Y, Z * obj.Z);
+}
+
+Vector3 Vector3::operator*(double t) const
+{
+	return Vector3(X * t, Y * t, Z * t);
+}
+
+Vector3 Vector3::operator/(double t) const
+{
+	return Vector3(X / t, Y / t, Z / t);
+}
+
+
+
+
+
+
+