Hopefully before really raymarching testing

sdf.go

@@ -1,67 +1,168 @@
 package main
 
+import "math"
+
 const EPS = 0.001
 
 type SDF interface {
-	Distance(Vector3) float64
+	Distance(Vector3) (float64, Color)
+}
+
+func DistanceOnly(sdf SDF, p Vector3) float64 {
+	dist, _ := sdf.Distance(p)
+	return dist
 }
 
 func Gradient(sdf SDF, p Vector3, eps float64) Vector3 {
-	dx := (sdf.Distance(p.Add(Vector3{X: eps})) - sdf.Distance(p.Add(Vector3{X: -eps}))) / (2 * eps)
-	dy := (sdf.Distance(p.Add(Vector3{Y: eps})) - sdf.Distance(p.Add(Vector3{Y: -eps}))) / (2 * eps)
-	dz := (sdf.Distance(p.Add(Vector3{Z: eps})) - sdf.Distance(p.Add(Vector3{Z: -eps}))) / (2 * eps)
+	dx := (DistanceOnly(sdf, p.Add(Vector3{X: eps})) - DistanceOnly(sdf, p.Add(Vector3{X: -eps}))) / (2 * eps)
+	dy := (DistanceOnly(sdf, p.Add(Vector3{Y: eps})) - DistanceOnly(sdf, p.Add(Vector3{Y: -eps}))) / (2 * eps)
+	dz := (DistanceOnly(sdf, p.Add(Vector3{Z: eps})) - DistanceOnly(sdf, p.Add(Vector3{Z: -eps}))) / (2 * eps)
 	return Vector3{X: dx, Y: dy, Z: dz}
 }
 
 // Some transformations see https://iquilezles.org/articles/distfunctions/
 
-type translatedSDF struct {
+type TranslatedSDF struct {
 	primitive SDF
 	translate Vector3
 }
 
-func (s translatedSDF) Distance(p Vector3) float64 {
+func (s TranslatedSDF) Distance(p Vector3) (float64, Color) {
 	return s.primitive.Distance(p.Sub(s.translate))
 }
 
-type rotatedSDF struct {
+type RotatedSDF struct {
 	primitive SDF
 	rotVector Vector3
 	angle     float64
 }
 
-func (s rotatedSDF) Distance(p Vector3) float64 {
-	rotated_p := rotate(p, s.rotVector, s.angle)
+func (s RotatedSDF) Distance(p Vector3) (float64, Color) {
+	rotated_p := Rotate(p, s.rotVector, s.angle)
 	return s.primitive.Distance(rotated_p)
 }
 
-type scaledSDF struct {
+type ScaledSDF struct {
 	primitive SDF
 	scale     float64
 }
 
-func (s scaledSDF) Distance(p Vector3) float64 {
-	return s.primitive.Distance(p.Scale(1/s.scale)) * s.scale
+func (s ScaledSDF) Distance(p Vector3) (float64, Color) {
+	dist, color := s.primitive.Distance(p.Scale(1 / s.scale))
+	return dist * s.scale, color
 }
 
-type infiniteRep struct {
+type RepeatSDF struct {
 	primitive SDF
 	cellSize  Vector3
 }
 
-// TODO
-// func (s infiniteRep) Distance(p Vector3) float64 {
-// 	x, y, z := p.Unpack()
-// 	sx, sy, sz := s.cellSize.Unpack()
-// }
-
-// Sphere
-
-type Sphere struct {
-	center Vector3
-	radius float64
+func (s RepeatSDF) Distance(p Vector3) (float64, Color) {
+	x, y, z := p.Unpack()
+	sx, sy, sz := s.cellSize.Unpack()
+	round := math.RoundToEven
+	nearest_cell := Vector3{sx * round(x/sx), sy * round(y/sy), sz * round(z/sz)}
+	return s.primitive.Distance(p.Sub(nearest_cell))
 }
 
-func (s Sphere) Distance(p Vector3) float64 {
-	return p.Sub(s.center).Length()
+type UnionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+}
+
+func (s UnionSDF) Distance(p Vector3) (float64, Color) {
+	d1, color1 := s.primitive1.Distance(p)
+	d2, color2 := s.primitive2.Distance(p)
+	d := math.Min(d1, d2)
+
+	color := color1
+	if d2 < d1 {
+		color = color2
+	}
+	return d, color
+}
+
+type SubstractionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+}
+
+func (s SubstractionSDF) Distance(p Vector3) (float64, Color) {
+	d1, color1 := s.primitive1.Distance(p)
+	d2, _ := s.primitive2.Distance(p)
+
+	d := math.Max(-d1, d2)
+	return d, color1
+}
+
+type IntersectionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+}
+
+func (s IntersectionSDF) Distance(p Vector3) (float64, Color) {
+
+	d1, color1 := s.primitive1.Distance(p)
+	d2, color2 := s.primitive2.Distance(p)
+	c1 := color1.GetColor(p)
+	c2 := color2.GetColor(p)
+	d := math.Max(d1, d2)
+	color := c1.Add(c2).Scale(0.5)
+	return d, color
+}
+
+type SmoothUnionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+	k          float64
+}
+
+func (s SmoothUnionSDF) Distance(p Vector3) (float64, Color) {
+	k := 4 * s.k
+	d1, color1 := s.primitive1.Distance(p)
+	d2, color2 := s.primitive2.Distance(p)
+	c1 := color1.GetColor(p)
+	c2 := color2.GetColor(p)
+	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)
+	color := Mix(c1, c2, t)
+	return d, color
+}
+
+type SmoothSubstractionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+	k          float64
+}
+
+func (s SmoothSubstractionSDF) Distance(p Vector3) (float64, Color) {
+	k := 4 * s.k
+	d1, color1 := s.primitive1.Distance(p)
+	d2, color2 := s.primitive2.Distance(p)
+	c1 := color1.GetColor(p)
+	c2 := color2.GetColor(p)
+	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)
+	color := Mix(c1, c2, t)
+	return d, color
+}
+
+type SmoothIntersectionSDF struct {
+	primitive1 SDF
+	primitive2 SDF
+	k          float64
+}
+
+func (s SmoothIntersectionSDF) Distance(p Vector3) (float64, Color) {
+	k := 4 * s.k
+	d1, color1 := s.primitive1.Distance(p)
+	d2, color2 := s.primitive2.Distance(p)
+	c1 := color1.GetColor(p)
+	c2 := color2.GetColor(p)
+	d := math.Max(k-math.Abs(d1-d2), 0.0)
+	t := SmoothStep(d2-d1, -k, k)
+	color := Mix(c1, c2, t)
+	return d, color
 }