diff --git a/README.md b/README.md
index 725c7a3..4a7f52e 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,2 @@
 Simple cpu ray-marching in go
-Focus on Lisiblity & Features
+Focus on Lisiblity & Features, sacrifice performance
diff --git a/src/main.go b/src/main.go
index 8b092f2..1868e3b 100644
--- a/src/main.go
+++ b/src/main.go
@@ -13,8 +13,8 @@ import (
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
-const WIDTH = 200
-const HEIGHT = 200
+const WIDTH = 100
+const HEIGHT = 100
 const TEXTURE_SCALE = 4
 
 const MAX_DIST = 500.0
@@ -69,7 +69,7 @@ func compute_pixel(y0 int, y1 int, wg *sync.WaitGroup, screenCenter Vector3, phi
 			origin := screenCenter.Add(phiVec.Scale(-sx)).Add(thetaVec.Scale(sy))
 			direction := (origin.Sub(cameraPos)).Normalized()
 
-			hit, colorVec := rayMarch(origin, direction, 1)
+			hit, colorVec := rayMarch(origin, direction)
 			var fr, fg, fb float64
 			if hit {
 				fr, fg, fb = colorVec.Unpack()
diff --git a/src/material.go b/src/material.go
index d238e1a..d9075ee 100644
--- a/src/material.go
+++ b/src/material.go
@@ -1,8 +1,6 @@
 package main
 
-import (
-	"math"
-)
+import "math"
 
 type Color interface {
 	GetColor(Vector3) Vector3
@@ -62,7 +60,7 @@ func MixMat(mat1 MaterialBrut, mat2 MaterialBrut, t float64, p Vector3) Material
 		mat1.specularColor.GetColor(p).Scale(1 - t).Add((mat2.specularColor.GetColor(p)).Scale(t)),
 		mat1.specularFac*(1-t) + mat2.specularFac*t,
 		mat1.specularExp*(1-t) + mat2.specularExp*t,
-		mat1.reflectanceFac*(1-t) + mat2.reflectanceFac*t,
+		(mat1.reflectanceFac*(1-t) + mat2.reflectanceFac) * t,
 		mat1.reflectanceTint.GetColor(p).Scale(1 - t).Add((mat2.reflectanceTint.GetColor(p)).Scale(t)),
 		mat1.refractFac*(1-t) + mat2.refractFac*t,
 		mat1.refractIndice*(1-t) + mat2.refractIndice*t,
@@ -70,14 +68,14 @@ func MixMat(mat1 MaterialBrut, mat2 MaterialBrut, t float64, p Vector3) Material
 }
 
 type MixedMaterial struct {
-	mat1 Material
-	mat2 Material
+	mat1 *Material
+	mat2 *Material
 	t    float64
 	p    Vector3
 }
 
 func (mixedMat MixedMaterial) GetMaterialBrut() MaterialBrut {
-	return MixMat((mixedMat.mat1).GetMaterialBrut(), (mixedMat.mat2).GetMaterialBrut(), mixedMat.t, mixedMat.p)
+	return MixMat((*mixedMat.mat1).GetMaterialBrut(), (*mixedMat.mat2).GetMaterialBrut(), mixedMat.t, mixedMat.p)
 }
 
 func DefaultMaterial(diffuseColor Color) MaterialBrut {
@@ -88,7 +86,7 @@ func DefaultMaterial(diffuseColor Color) MaterialBrut {
 		specularColor:   Vector3{255, 255, 255},
 		specularFac:     1,
 		specularExp:     35.0,
-		reflectanceFac:  0.2,
+		reflectanceFac:  0.0,
 		reflectanceTint: Vector3{255, 255, 255},
 		refractFac:      0.0,
 		refractIndice:   1.0,
@@ -97,7 +95,7 @@ func DefaultMaterial(diffuseColor Color) MaterialBrut {
 
 // Colors
 
-var RED = Vector3{125, 0, 0}
+var RED = Vector3{255, 0, 0}
 var GREEN = Vector3{0, 255, 0}
 var BLUE = Vector3{0, 0, 255}
 var WHITE = Vector3{255, 255, 255}
diff --git a/src/primitives_sdf.go b/src/primitives_sdf.go
index ba173ab..9999c1e 100644
--- a/src/primitives_sdf.go
+++ b/src/primitives_sdf.go
@@ -6,8 +6,8 @@ type Sphere struct {
 	material Material
 }
 
-func (s Sphere) Distance(p Vector3) (float64, Material) {
-	return p.Length() - s.radius, s.material
+func (s Sphere) Distance(p Vector3) (float64, *Material) {
+	return p.Length() - s.radius, &s.material
 }
 
 // Box
@@ -16,9 +16,9 @@ type Box struct {
 	material   Material
 }
 
-func (s Box) Distance(p Vector3) (float64, Material) {
+func (s Box) Distance(p Vector3) (float64, *Material) {
 	q := p.Abs().Sub(s.dimensions)
-	return q.Max(0.0).Length() + min(max(q.X, max(q.Y, q.Z)), 0.0), s.material
+	return q.Max(0.0).Length() + min(max(q.X, max(q.Y, q.Z)), 0.0), &s.material
 }
 
 // Plane
@@ -27,6 +27,6 @@ type Plane struct {
 	material Material
 }
 
-func (s Plane) Distance(p Vector3) (float64, Material) {
-	return p.Dot(s.normal), s.material
+func (s Plane) Distance(p Vector3) (float64, *Material) {
+	return p.Dot(s.normal), &s.material
 }
diff --git a/src/ray_marching.go b/src/ray_marching.go
index 8a8aec7..d7b806f 100644
--- a/src/ray_marching.go
+++ b/src/ray_marching.go
@@ -39,42 +39,23 @@ func shadow(point Vector3) float64 {
 		}
 		res = min(res, SOFT_SHADOW_COEFF*dist/dist_total)
 		dist_total += dist
-		p.Radd(direction.Scale(dist))
+		p = p.Add(direction.Scale(dist))
 	}
 	return res
 }
 
-func reflect(point Vector3, direction Vector3, normal Vector3, mat Material, reflectNumber int) Vector3 {
-	brutMat := mat.GetMaterialBrut()
-	if reflectNumber <= 0 || brutMat.reflectanceFac < EPS {
-		return Vector3{0, 0, 0}
-	}
-	reflected := Reflect(direction, normal).Scale(-1)
-	reflectRayOrigin := point.Add(reflected.Scale(5 * EPS))
-	hit, color := rayMarch(reflectRayOrigin, reflected, reflectNumber-1)
-	if !hit {
-		color = Vector3{0, 0, 0}
-	}
-	// fmt.Println("Reflect")
-	return color.Scale(brutMat.reflectanceFac)
-}
-
-func rayMarch(origin Vector3, direction Vector3, reflectNumber int) (bool, Vector3) {
+func rayMarch(origin Vector3, direction Vector3) (bool, Vector3) {
 	p := origin
 	for range MAX_STEP {
 		dist, mat := scene.Distance(p)
 		if dist < EPS {
 			normal := Gradient(scene, p, EPS).Normalized()
-			phongShade := phongShading(p, normal, mat)
-			shadowCoeff := max(shadow(p), 0.3)
-			reflectColor := reflect(p, direction, normal, mat, reflectNumber)
-			return true, phongShade.Add(reflectColor).Scale(shadowCoeff)
-			// return true, phongShading(p, normal, *mat)
+			return true, phongShading(p, normal, *mat).Scale(max(shadow(p), 0.3))
 		}
 		if dist > MAX_DIST {
 			break
 		}
-		p.Radd(direction.Scale(dist))
+		p = p.Add(direction.Scale(dist))
 	}
 	return false, GREY
 }
diff --git a/src/sdf.go b/src/sdf.go
index c57df23..64f52c0 100644
--- a/src/sdf.go
+++ b/src/sdf.go
@@ -5,7 +5,7 @@ import (
 )
 
 type SDF interface {
-	Distance(Vector3) (float64, Material)
+	Distance(Vector3) (float64, *Material)
 }
 
 func DistanceOnly(sdf SDF, p Vector3) float64 {
@@ -27,7 +27,7 @@ type TranslatedSDF struct {
 	translate Vector3
 }
 
-func (s TranslatedSDF) Distance(p Vector3) (float64, Material) {
+func (s TranslatedSDF) Distance(p Vector3) (float64, *Material) {
 	return s.primitive.Distance(p.Sub(s.translate))
 }
 
@@ -37,7 +37,7 @@ type RotatedSDF struct {
 	angle     float64
 }
 
-func (s RotatedSDF) Distance(p Vector3) (float64, Material) {
+func (s RotatedSDF) Distance(p Vector3) (float64, *Material) {
 	rotated_p := Rotate(p, s.rotVector, s.angle)
 	return s.primitive.Distance(rotated_p)
 }
@@ -47,7 +47,7 @@ type ScaledSDF struct {
 	scale     float64
 }
 
-func (s ScaledSDF) Distance(p Vector3) (float64, Material) {
+func (s ScaledSDF) Distance(p Vector3) (float64, *Material) {
 	dist, color := s.primitive.Distance(p.Scale(1 / s.scale))
 	return dist * s.scale, color
 }
@@ -57,7 +57,7 @@ type RepeatSDF struct {
 	cellSize  Vector3
 }
 
-func (s RepeatSDF) Distance(p Vector3) (float64, Material) {
+func (s RepeatSDF) Distance(p Vector3) (float64, *Material) {
 	x, y, z := p.Unpack()
 	sx, sy, sz := s.cellSize.Unpack()
 	round := math.RoundToEven
@@ -70,10 +70,10 @@ type UnionSDF struct {
 	primitive2 SDF
 }
 
-func (s UnionSDF) Distance(p Vector3) (float64, Material) {
+func (s UnionSDF) Distance(p Vector3) (float64, *Material) {
 	d1, color1 := s.primitive1.Distance(p)
 	d2, color2 := s.primitive2.Distance(p)
-	d := min(d1, d2)
+	d := math.Min(d1, d2)
 
 	color := color1
 	if d2 < d1 {
@@ -87,11 +87,11 @@ type SubstractionSDF struct {
 	primitive2 SDF
 }
 
-func (s SubstractionSDF) Distance(p Vector3) (float64, Material) {
+func (s SubstractionSDF) Distance(p Vector3) (float64, *Material) {
 	d1, color1 := s.primitive1.Distance(p)
 	d2, _ := s.primitive2.Distance(p)
 
-	d := max(d1, -d2)
+	d := math.Max(d1, -d2)
 	return d, color1
 }
 
@@ -100,14 +100,14 @@ type IntersectionSDF struct {
 	primitive2 SDF
 }
 
-func (s IntersectionSDF) Distance(p Vector3) (float64, Material) {
+func (s IntersectionSDF) Distance(p Vector3) (float64, *Material) {
 
 	d1, mat1 := s.primitive1.Distance(p)
 	d2, mat2 := s.primitive2.Distance(p)
-	d := max(d1, d2)
+	d := math.Max(d1, d2)
 
 	var mat Material = MixedMaterial{mat1, mat2, 0.5, p}
-	return d, mat
+	return d, &mat
 }
 
 type SmoothUnionSDF struct {
@@ -116,15 +116,15 @@ type SmoothUnionSDF struct {
 	k          float64
 }
 
-func (s SmoothUnionSDF) Distance(p Vector3) (float64, Material) {
+func (s SmoothUnionSDF) Distance(p Vector3) (float64, *Material) {
 	k := 4 * s.k
 	d1, mat1 := s.primitive1.Distance(p)
 	d2, mat2 := s.primitive2.Distance(p)
-	h := max(k-math.Abs(d1-d2), 0.0)
-	d := min(d1, d2) - h*h*0.25/k
+	h := math.Max(k-math.Abs(d1-d2), 0.0)
+	d := math.Min(d1, d2) - h*h*0.25/k
 	t := SmoothStep(d2-d1, -k, k)
 	var mat Material = MixedMaterial{mat2, mat1, t, p}
-	return d, mat
+	return d, &mat
 }
 
 type SmoothSubstractionSDF struct {
@@ -133,15 +133,15 @@ type SmoothSubstractionSDF struct {
 	k          float64
 }
 
-func (s SmoothSubstractionSDF) Distance(p Vector3) (float64, Material) {
+func (s SmoothSubstractionSDF) Distance(p Vector3) (float64, *Material) {
 	k := 4 * s.k
 	d1, mat1 := s.primitive1.Distance(p)
 	d2, mat2 := s.primitive2.Distance(p)
-	h := max(k-math.Abs(-d1-d2), 0.0)
-	d := max(d1, -d2) + h*h*0.25/k
+	h := math.Max(k-math.Abs(-d1-d2), 0.0)
+	d := math.Max(d1, -d2) + h*h*0.25/k
 	t := SmoothStep(d1-d2, -k, k)
 	var mat Material = MixedMaterial{mat1, mat2, t, p}
-	return d, mat
+	return d, &mat
 }
 
 type SmoothIntersectionSDF struct {
@@ -150,13 +150,13 @@ type SmoothIntersectionSDF struct {
 	k          float64
 }
 
-func (s SmoothIntersectionSDF) Distance(p Vector3) (float64, Material) {
+func (s SmoothIntersectionSDF) Distance(p Vector3) (float64, *Material) {
 	k := 4 * s.k
 	d1, mat1 := s.primitive1.Distance(p)
 	d2, mat2 := s.primitive2.Distance(p)
-	h := max(k-math.Abs(d1-d2), 0.0)
-	d := max(d1, d2) + h*h*0.25/k
+	h := math.Max(k-math.Abs(d1-d2), 0.0)
+	d := math.Max(d1, d2) + h*h*0.25/k
 	t := SmoothStep(d2-d1, -k, k)
 	var mat Material = MixedMaterial{mat1, mat2, t, p}
-	return d, mat
+	return d, &mat
 }
diff --git a/src/vec3.go b/src/vec3.go
index 3f02686..7aea4c9 100644
--- a/src/vec3.go
+++ b/src/vec3.go
@@ -16,18 +16,12 @@ func (u Vector3) Add(v Vector3) Vector3 {
 	return Vector3{u.X + v.X, u.Y + v.Y, u.Z + v.Z}
 }
 
-func (u *Vector3) Radd(v Vector3) {
-	u.X += v.X
-	u.Y += v.Y
-	u.Z += v.Z
-}
-
 func (u Vector3) Neg() Vector3 {
 	return Vector3{-u.X, -u.Y, -u.Z}
 }
 
 func (u Vector3) Sub(v Vector3) Vector3 {
-	return Vector3{u.X - v.X, u.Y - v.Y, u.Z - v.Z}
+	return u.Add(v.Neg())
 }
 
 func (u Vector3) Scale(a float64) Vector3 {