Triangles (#51)

Fixes #50

Added triangle primitive, and some new benchmarks.

Author: JarrodBegnoche

README.md

@@ -19,7 +19,8 @@ Raytracer written in Go, based on the book [The Ray Tracer Challenge by Jamis Bu
 - ✅ Chapter 13: [Cylinders and Cones](https://user-images.githubusercontent.com/40322086/108651820-98a51380-7490-11eb-8519-c72a496c025c.png)
 - ✅ Chapter 14: [Groups](https://user-images.githubusercontent.com/40322086/110737622-b5b14480-81fb-11eb-8b70-ff4517a84bac.png)
 - ✅ Chapter 14.5: [Bounding Boxes](https://user-images.githubusercontent.com/40322086/112742776-6e4ae800-8f5f-11eb-8a4e-66a5d145fc3f.png)
-- Chapter 15: Triangles
+- Chapter 15: [Triangles](https://user-images.githubusercontent.com/40322086/113527126-8be50680-958a-11eb-8521-6a738a7189c3.png)
+- Chapter 15.5: OBJ files
 - Chapter 16: Constructive Solid Geometry
 
 ## Latest Render
@@ -28,22 +29,28 @@ Raytracer written in Go, based on the book [The Ray Tracer Challenge by Jamis Bu
 
 ## Benchmark stats
 
-### Benchmarks of different bounding box setups with 4096 spheres
+### Benchmarks of primitives calculation
 
-pkg: github.com/factorion/graytracer/pkg/components
+pkg: github.com/factorion/graytracer/pkg/primitives
 cpu: AMD Ryzen 7 2700 Eight-Core Processor
 | Function | Iterations | Speed | Memory | Allocations |
-| -------- | ---------- | ----- | ------ | ----------- |
-| BenchmarkNoBoundingBoxes-16 | 1711 | 614977 ns/op | 5960 B/op | 113 allocs/op |
-| Benchmark8BoundingBoxes-16 | 10000 | 117799 ns/op | 7336 B/op | 124 allocs/op |
-| Benchmark64BoundingBoxes-16 | 32006 | 37650 ns/op | 7432 B/op | 129 allocs/op |
+| -------- | ---------: | ----: | -----: | ----------: |      
+| BenchmarkSubmatrix4x4-16 | 5329711 | 223.5 ns/op | 152 B/op | 4 allocs/op |
+| BenchmarkMatrixMultiply-16 | 3388286 | 357.6 ns/op | 224 B/op | 5 allocs/op |
+| BenchmarkMatrixDeterminant4x4-16 | 387013 | 3099 ns/op | 1568 B/op | 52 allocs/op |
+| BenchmarkMatrixMinor3x3-16 | 7517265 | 160.8 ns/op | 80 B/op | 3 allocs/op |
+| BenchmarkMatrixCofactor3x3-16 | 7162288 | 168.5 ns/op | 80 B/op | 3 allocs/op |
+| BenchmarkMatrixInverse4x4-16 | 74745 | 16077 ns/op | 8064 B/op | 265 allocs/op |
+| BenchmarkPVTransform-16 | 131638082 | 9.265 ns/op | 0 B/op | 0 allocs/op |
+| BenchmarkPVReflect-16 | 178992032 | 6.959 ns/op | 0 B/op | 0 allocs/op |
+| BenchmarkRayTransform-16 | 37492969 | 32.03 ns/op | 0 B/op | 0 allocs/op |
 
 ### Benchmarks of basic shape calculations
 
 pkg: github.com/factorion/graytracer/pkg/shapes
-cpu: AMD Ryzen 7 2700 Eight-Core Processor          
+cpu: AMD Ryzen 7 2700 Eight-Core Processor
 | Function | Iterations | Speed | Memory | Allocations |
-| -------- | ---------- | ----- | ------ | ----------- |
+| -------- | ---------: | ----: | -----: | ----------: |
 | BenchmarkConeIntersection-16 | 5701870 | 207.7 ns/op | 72 B/op | 2 allocs/op |
 | BenchmarkConeNormal-16 | 3989524 | 305.8 ns/op | 224 B/op | 5 allocs/op |
 | BenchmarkCubeIntersection-16 | 9322422 | 130.6 ns/op | 48 B/op | 1 allocs/op |
@@ -54,3 +61,15 @@ cpu: AMD Ryzen 7 2700 Eight-Core Processor
 | BenchmarkPlaneNormal-16 | 4438746 | 273.1 ns/op | 224 B/op | 5 allocs/op |
 | BenchmarkSphereIntersection-16 | 6149660 | 200.8 ns/op | 72 B/op | 2 allocs/op |
 | BenchmarkSphereNormal-16 | 3968947 | 300.2 ns/op | 224 B/op | 5 allocs/op |
+| BenchmarkTriangleIntersection-16 | 11317957 | 107.5 ns/op | 24 B/op | 1 allocs/op |
+| BenchmarkTriangleNormal-16 | 4596672 | 266.7 ns/op | 224 B/op | 5 allocs/op |
+
+### Benchmarks of different bounding box setups with 4096 spheres
+
+pkg: github.com/factorion/graytracer/pkg/components
+cpu: AMD Ryzen 7 2700 Eight-Core Processor
+| Function | Iterations | Speed | Memory | Allocations |
+| -------- | ---------: | ----: | -----: | ----------: |
+| BenchmarkNoBoundingBoxes-16 | 1711 | 614977 ns/op | 5960 B/op | 113 allocs/op |
+| Benchmark8BoundingBoxes-16 | 10000 | 117799 ns/op | 7336 B/op | 124 allocs/op |
+| Benchmark64BoundingBoxes-16 | 32006 | 37650 ns/op | 7432 B/op | 129 allocs/op |

cmd/graytracer/main.go

@@ -71,7 +71,7 @@ func MakeHex(mat patterns.Material, transform primitives.Matrix) shapes.Shape {
 		bottom := shapes.MakeCone(true)
 		bottom.SetMaterial(mat)
 		bottom.SetTransform(primitives.RotationY(i * math.Pi / 3).Multiply(
-						    primitives.Translation(0, -1, 0).Multiply(
+							primitives.Translation(0, -1, 0).Multiply(
 							primitives.RotationX(3 * math.Pi / 4).Multiply(
 							primitives.Scaling(0.25, math.Sqrt(2), 0.25)))))
 		hex.AddShape(corner)
@@ -88,13 +88,13 @@ func main() {
 	var threads int
 	var fov float64
 	flag.IntVar(&threads, "threads", runtime.NumCPU(), "Number of threads for rendering")
-	flag.UintVar(&width, "width", 320, "Width of rendered image")
-	flag.UintVar(&height, "height", 240, "Height of rendered image")
-	flag.Float64Var(&fov, "fov", math.Pi/4, "Field of View (in Radians)")
+	flag.UintVar(&width, "width", 480, "Width of rendered image")
+	flag.UintVar(&height, "height", 270, "Height of rendered image")
+	flag.Float64Var(&fov, "fov", math.Pi/3, "Field of View (in Radians)")
 	flag.Parse()
 	camera = components.MakeCamera(width, height, fov)
-	camera.ViewTransform(primitives.MakePoint(-20, 50, -35),
-						 primitives.MakePoint(15, 10, 15),
+	camera.ViewTransform(primitives.MakePoint(0, 1.5, -4.5),
+						 primitives.MakePoint(0, 1, 0),
 						 primitives.MakeVector(0, 1, 0))
 	ch = make(chan XY, 1000)
 	imgMutex = &sync.Mutex{}
@@ -104,25 +104,93 @@ func main() {
 	img = image.NewRGBA(image.Rectangle{upLeft, lowRight})
 	world = components.MakeWorld()
 	world.SetBackground(*patterns.MakeRGB(0.9, 0.9, 0.9))
-	for x := 0.0; x < 10; x++ {
-		for y := 0.0; y < 10; y++ {
-			for z := 0.0; z < 10; z++ {
-				mat := patterns.Material{Pat: patterns.MakeRGB(x * 0.1, y * 0.1, z * 0.1),
-										 Ambient: 0.1, Diffuse: 0.7, Specular: 0.5,
-										 Shininess: 200, Reflective: 0.1, Transparency: 0, RefractiveIndex: 0}
-				hex := MakeHex(mat, primitives.Translation(x * 4, y * 3, z * 4))
-				world.AddObject(hex)
-			}
-		}
+	d4 := shapes.MakeGroup()
+	d4.SetTransform(primitives.Translation(1.75, 0.5, 0.5).Multiply(
+					primitives.RotationY(math.Pi / 2).Multiply(
+					primitives.Translation(0, 1.0 / 3.0, 0))))
+	d4_mat := patterns.Material{Pat: patterns.MakeRGB(0.8, 0, 0.8), Ambient: 0.1, Diffuse: 0.7, Specular: 0.5,
+								Shininess: 200, Reflective: 0.1, Transparency: 0, RefractiveIndex: 0}
+	d4_points := []primitives.PV{primitives.MakePoint(0, -1.0 / 3.0, math.Sqrt(8.0 / 9.0)),
+								 primitives.MakePoint(math.Sqrt(2.0 / 3.0), -1.0 / 3.0, -math.Sqrt(2.0 / 9.0)),
+								 primitives.MakePoint(-math.Sqrt(2.0 / 3.0), -1.0 / 3.0, -math.Sqrt(2.0 / 9.0)),
+								 primitives.MakePoint(0, 1, 0)}
+	d4_triangles := []*shapes.Triangle{shapes.MakeTriangle(d4_points[0], d4_points[1], d4_points[2]),
+						 			   shapes.MakeTriangle(d4_points[0], d4_points[1], d4_points[3]),
+									   shapes.MakeTriangle(d4_points[0], d4_points[2], d4_points[3]),
+									   shapes.MakeTriangle(d4_points[1], d4_points[2], d4_points[3])}
+	for _, triangle := range d4_triangles {
+		triangle.SetMaterial(d4_mat)
+		d4.AddShape(triangle)
 	}
-	
-	// Render time without bounding boxes
-	// Render finished : 1m34.8119446s
-	// Render time with bounding boxes
-	// Render finished : 2.4859576s
-
+	world.AddObject(d4)
+	d8 := shapes.MakeGroup()
+	d8.SetTransform(primitives.Translation(0, 1, 0.5).Multiply(
+					primitives.Scaling(0.75, 0.75, 0.75)))
+	d8_mat := patterns.Material{Pat: patterns.MakeRGB(0, 0.8, 0), Ambient: 0.1, Diffuse: 0.7, Specular: 0.5,
+								Shininess: 200, Reflective: 0.1, Transparency: 0, RefractiveIndex: 0}
+	d8_points := []primitives.PV{primitives.MakePoint(0, 1, 0),
+								 primitives.MakePoint(1, 0, 0),
+								 primitives.MakePoint(0, 0, 1),
+								 primitives.MakePoint(-1, 0, 0),
+								 primitives.MakePoint(0, 0, -1),
+								 primitives.MakePoint(0, -1, 0)}
+	d8_triangles := []*shapes.Triangle{shapes.MakeTriangle(d8_points[0], d8_points[1], d8_points[2]),
+									   shapes.MakeTriangle(d8_points[0], d8_points[2], d8_points[3]),
+									   shapes.MakeTriangle(d8_points[0], d8_points[3], d8_points[4]),
+									   shapes.MakeTriangle(d8_points[0], d8_points[4], d8_points[1]),
+									   shapes.MakeTriangle(d8_points[5], d8_points[1], d8_points[2]),
+									   shapes.MakeTriangle(d8_points[5], d8_points[2], d8_points[3]),
+									   shapes.MakeTriangle(d8_points[5], d8_points[3], d8_points[4]),
+									   shapes.MakeTriangle(d8_points[5], d8_points[4], d8_points[1])}
+	for _, triangle := range d8_triangles {
+		triangle.SetMaterial(d8_mat)
+		d8.AddShape(triangle)
+	}
+	world.AddObject(d8)
+	d20 := shapes.MakeGroup()
+	d20.SetTransform(primitives.Translation(-2, 1, 2).Multiply(
+					 primitives.Scaling(0.5, 0.5, 0.5)))
+	d20_mat := patterns.Material{Pat: patterns.MakeRGB(0.9, 0, 0), Ambient: 0.1, Diffuse: 0.7, Specular: 0.5,
+								 Shininess: 200, Reflective: 0.1, Transparency: 0, RefractiveIndex: 0}
+	d20_points := []primitives.PV{primitives.MakePoint(0, -1, -math.Phi), // 0
+								  primitives.MakePoint(0, -1, math.Phi),  // 1
+								  primitives.MakePoint(0, 1, -math.Phi),  // 2
+								  primitives.MakePoint(0, 1, math.Phi),   // 3
+								  primitives.MakePoint(-1, -math.Phi, 0), // 4
+								  primitives.MakePoint(-1, math.Phi, 0),  // 5
+								  primitives.MakePoint(1, -math.Phi, 0),  // 6
+								  primitives.MakePoint(1, math.Phi, 0),   // 7
+								  primitives.MakePoint(-math.Phi, 0, -1), // 8
+								  primitives.MakePoint(math.Phi, 0, -1),  // 9
+								  primitives.MakePoint(-math.Phi, 0, 1),  // 10
+								  primitives.MakePoint(math.Phi, 0, 1)}   // 11
+	d20_triangles := []*shapes.Triangle{shapes.MakeTriangle(d20_points[0], d20_points[2], d20_points[8]), // front
+										shapes.MakeTriangle(d20_points[0], d20_points[2], d20_points[9]),
+										shapes.MakeTriangle(d20_points[1], d20_points[3], d20_points[10]), // back
+										shapes.MakeTriangle(d20_points[1], d20_points[3], d20_points[11]),
+										shapes.MakeTriangle(d20_points[9], d20_points[11], d20_points[6]), // right
+										shapes.MakeTriangle(d20_points[9], d20_points[11], d20_points[7]),
+										shapes.MakeTriangle(d20_points[8], d20_points[10], d20_points[4]), // left
+										shapes.MakeTriangle(d20_points[8], d20_points[10], d20_points[5]),
+										shapes.MakeTriangle(d20_points[4], d20_points[6], d20_points[0]), // bottom
+										shapes.MakeTriangle(d20_points[4], d20_points[6], d20_points[1]),
+										shapes.MakeTriangle(d20_points[4], d20_points[8], d20_points[0]), // bottom split
+										shapes.MakeTriangle(d20_points[4], d20_points[10], d20_points[1]),
+										shapes.MakeTriangle(d20_points[6], d20_points[9], d20_points[0]),
+										shapes.MakeTriangle(d20_points[6], d20_points[11], d20_points[1]),
+										shapes.MakeTriangle(d20_points[5], d20_points[7], d20_points[2]), // top
+										shapes.MakeTriangle(d20_points[5], d20_points[7], d20_points[3]),
+										shapes.MakeTriangle(d20_points[5], d20_points[8], d20_points[2]), //top split
+										shapes.MakeTriangle(d20_points[5], d20_points[10], d20_points[3]),
+										shapes.MakeTriangle(d20_points[7], d20_points[9], d20_points[2]),
+										shapes.MakeTriangle(d20_points[7], d20_points[11], d20_points[3])}
+	for _, triangle := range d20_triangles {
+		triangle.SetMaterial(d20_mat)
+		d20.AddShape(triangle)
+	}
+	world.AddObject(d20)
 	light := components.PointLight{Intensity: patterns.MakeRGB(1, 1, 1),
-		Position: primitives.MakePoint(-30, 60, -30)}
+								   Position: primitives.MakePoint(-1, 0.5, -5)}
 	world.AddLight(light)
 	fmt.Println("Creating goroutines")
 	wg.Add(threads)

image.png

@@ -130,7 +130,7 @@ func (m Matrix) Cofactor(row, column uint8) float64 {
 func (m Matrix) Inverse() (Matrix, error) {
 	determinant := m.Determinant()
 	if determinant == 0 {
-		return nil, errors.New("Not invertible")
+		return nil, errors.New("not invertible")
 	}
 	size := uint8(len(m))
 	inverse := MakeMatrix(size)

pkg/primitives/matrix.go

@@ -47,7 +47,7 @@ func TestMatrixEquals(t *testing.T) {
 	}
 }
 
-func TestSubmatrix(t * testing.T) {
+func TestSubmatrix(t *testing.T) {
 	tables := []struct {
 		matrix primitives.Matrix
 		row uint8
@@ -67,6 +67,14 @@ func TestSubmatrix(t * testing.T) {
 	}
 }
 
+func BenchmarkSubmatrix4x4(b *testing.B) {
+	matrix := primitives.Matrix{{-6, 1, 1, 6}, {-8, 5, 8, 6}, {-1, 0, 8, 2}, {-7, 1, -1, 1}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix.Submatrix(2, 1)
+	}
+}
+
 func TestMatrixMultiply(t *testing.T) {
 	tables := []struct {
 		matrix1, matrix2, product primitives.Matrix
@@ -85,6 +93,15 @@ func TestMatrixMultiply(t *testing.T) {
 	}
 }
 
+func BenchmarkMatrixMultiply(b *testing.B) {
+	matrix1 := primitives.Matrix{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 8, 7, 6}, {5, 4, 3, 2}}
+	matrix2 := primitives.Matrix{{-2, 1, 2, 3}, {3, 2, 1, -1}, {4, 3, 6, 5}, {1, 2, 7, 8}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix1.Multiply(matrix2)
+	}
+}
+
 func TestMatrixTranspose(t *testing.T) {
 	tables := []struct {
 		matrix1, transpose primitives.Matrix
@@ -119,6 +136,14 @@ func TestMatrixDeterminant(t *testing.T) {
 	}
 }
 
+func BenchmarkMatrixDeterminant4x4(b *testing.B) {
+	matrix := primitives.Matrix{{-2, -8, 3, 5}, {-3, 1, 7, 3}, {1, 2, -9, 6}, {-6, 7, 7, -9}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix.Determinant()
+	}
+}
+
 func TestMatrixMinor(t *testing.T) {
 	tables := []struct {
 		matrix1 primitives.Matrix
@@ -136,6 +161,14 @@ func TestMatrixMinor(t *testing.T) {
 	}
 }
 
+func BenchmarkMatrixMinor3x3(b *testing.B) {
+	matrix := primitives.Matrix{{3, 5, 0}, {2, -1, -7}, {6, -1, 5}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix.Minor(1, 0)
+	}
+}
+
 func TestMatrixCofactor(t *testing.T) {
 	tables := []struct {
 		matrix1 primitives.Matrix
@@ -153,6 +186,14 @@ func TestMatrixCofactor(t *testing.T) {
 	}
 }
 
+func BenchmarkMatrixCofactor3x3(b *testing.B) {
+	matrix := primitives.Matrix{{3, 5, 0}, {2, -1, -7}, {6, -1, 5}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix.Cofactor(0, 0)
+	}
+}
+
 func TestNonInvertibleMatrix(t *testing.T) {
 	tables := []struct {
 		matrix1 primitives.Matrix
@@ -196,7 +237,14 @@ func TestMatrixInverse(t *testing.T) {
 	}
 }
 
-//Test
+func BenchmarkMatrixInverse4x4(b *testing.B) {
+	matrix := primitives.Matrix{{-5, 2, 6, -8}, {1, -5, 1, 8}, {7, 7, -6, -7}, {1, -3, 7, 4}}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrix.Inverse()
+	}
+}
+
 func TestMatrixProcess(t *testing.T) {
 	tables := []struct {
 		matrix1, matrix2 primitives.Matrix
@@ -216,4 +264,4 @@ func TestMatrixProcess(t *testing.T) {
 			t.Errorf("Expected %v, got %v", table.matrix1, matrix1)
 		}
 	}
-}
+}

pkg/primitives/matrix_test.go

@@ -80,6 +80,15 @@ func TestPVTransform(t *testing.T) {
 	}
 }
 
+func BenchmarkPVTransform(b *testing.B) {
+	point := primitives.MakePoint(1, 2, 3)
+	transform := primitives.Translation(5, 6, 7)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		point.Transform(transform)
+	}
+}
+
 func TestPVNegate(t *testing.T) {
 	tables := []struct {
 		v, n primitives.PV
@@ -175,7 +184,7 @@ func TestCrossProduct(t *testing.T) {
 	}
 }
 
-func TestReflect(t *testing.T) {
+func TestPVReflect(t *testing.T) {
 	tables := []struct {
 		start, normal, reflect primitives.PV
 	}{
@@ -189,3 +198,12 @@ func TestReflect(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkPVReflect(b *testing.B) {
+	vector := primitives.MakeVector(1, -1, 0)
+	normal := primitives.MakeVector(0, 1, 0)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		vector.Reflect(normal)
+	}
+}

pkg/primitives/pv_test.go

@@ -69,3 +69,12 @@ func TestRayTransform(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkRayTransform(b *testing.B) {
+	ray := primitives.Ray{primitives.MakePoint(1, 2, 3), primitives.MakeVector(0, 1, 0)}
+	transform := primitives.Translation(3, 4, 5)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ray.Transform(transform)
+	}
+}