3dtrial/tinyrender2/render.go

package main

import (
	//"log"
	"math"
)

func Bresenham2(fb *Framebuffer, color uint, x0 int, y0 int, x1 int, y1 int) {
	dx := int(math.Abs(float64(x1 - x0)))
	sx := -1
	if x0 < x1 {
		sx = 1
	}
	dy := -int(math.Abs(float64(y1 - y0)))
	sy := -1
	if y0 < y1 {
		sy = 1
	}
	err := dx + dy

	for {
		fb.SetSafe(uint(x0), uint(y0), color)
		if x0 == x1 && y0 == y1 {
			break
		}
		e2 := 2 * err
		if e2 >= dy {
			if x0 == x1 {
				break
			}
			err += dy
			x0 += sx
		}
		if e2 <= dx {
			if y0 == y1 {
				break
			}
			err += dx
			y0 += sy
		}
	}
}

func line(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i) {
	Bresenham2(fb, color, v0.X, v0.Y, v1.X, v1.Y)
}

/*func LineSweep(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i, v2 Vec2i) {

}*/

func Triangle1(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i, v2 Vec2i) {
	// The dude gets rid of "degenerate" triangles so... we do too?
	if v2.Y == v1.Y && v1.Y == v0.Y {
		return
	}
	// Very silly manual sorting by Y
	if v2.Y < v0.Y {
		v0, v2 = v2, v0
	}
	if v1.Y < v0.Y {
		v0, v1 = v1, v0
	}
	if v2.Y < v1.Y {
		v1, v2 = v2, v1
	}

	var v02step, v01step, v12step, xlong, xshort float32

	xlong = float32(v0.X)
	xshort = xlong

	// The first and last Y CAN'T be equal because sorting!!
	if v1.Y == v0.Y {
		xshort = float32(v1.X)
	}

	// We can check just for greater than because we sorted the vertices
	// Assume 02 is on the right(?)  and 01 on the left
	v02step = (float32(v2.X - v0.X)) / (float32(v2.Y-v0.Y) + 0.001) // long side always
	v01step = (float32(v1.X - v0.X)) / (float32(v1.Y-v0.Y) + 0.001) // first short side
	v12step = (float32(v2.X - v1.X)) / (float32(v2.Y-v1.Y) + 0.001) // second short side

	for y := v0.Y; y <= v2.Y; y++ {
		xleft := int(xshort)
		xright := int(xlong)
		if xleft > xright {
			xleft, xright = xright, xleft
		}
		// Draw a horizontal line from left to right
		for x := xleft; x <= xright; x++ {
			fb.SetSafe(uint(x), uint(y), color)
		}
		xlong += v02step
		if y < v1.Y {
			xshort += v01step
		} else {
			xshort += v12step
		}
	}
}

// How does this work? Compare with your
// other barycentric function (in a different repo). In the original
// cpp code, they used an overloaded operator ^ to mean cross product
func Barycentric(v0, v1, v2, p Vec2i) Vec3f {
	// WARN: Just not doing this one
	u := Vec3f{}
	if math.Abs(float64(u.Z)) < 1 {
		return Vec3f{-1, 1, 1}
	}
	return Vec3f{1 - (u.X+u.Y)/u.Z, u.Y / u.Z, u.X / u.Z}
}

// Figure out the minimum bounding box for a triangle defined by
// these vertices. Returns the top left and bottom right points,
// inclusive
func ComputeBoundingBox(v0, v1, v2 Vec2i) (Vec2i, Vec2i) {
	return Vec2i{min(v0.X, v1.X, v2.X), min(v0.Y, v1.Y, v2.Y)},
		Vec2i{max(v0.X, v1.X, v2.X), max(v0.Y, v1.Y, v2.Y)}
}

// The generic edge function, returning positive if P is on the right side of
// the line drawn between v1 and v2. This is counter clockwise
func EdgeFunction(v1, v2, p Vec2f) float32 {
	return (p.X-v1.X)*(v2.Y-v1.Y) - (p.Y-v1.Y)*(v2.X-v1.X)
}

// This computes the x and y per-pixel increment for the line going
// between v1 and v2 (also counter clockwise)
func EdgeIncrement(v1, v2 Vec2f) (float32, float32) {
	return (v2.Y - v1.Y), -(v2.X - v1.X)
}

func Triangle2(fb *Framebuffer, color uint, v0 Vec2i, v1 Vec2i, v2 Vec2i) {
	boundsTL, boundsBR := ComputeBoundingBox(v0, v1, v2)
	const expand = (2 << 12)
	//log.Print(boundsTL, boundsBR)
	v0f := v0.ToF()
	v1f := v1.ToF()
	v2f := v2.ToF()
	// Where to start our scanning
	pstart := Vec2f{float32(boundsTL.X) + 0.5, float32(boundsTL.Y) + 0.5}
	// parea := EdgeFunction(v0f, v1f, v2f)
	// invarea := 1 / parea
	w0_y := int(expand * EdgeFunction(v1f, v2f, pstart))
	w1_y := int(expand * EdgeFunction(v2f, v0f, pstart))
	w2_y := int(expand * EdgeFunction(v0f, v1f, pstart))
	w0_xit, w0_yit := EdgeIncrement(v1f, v2f)
	w1_xit, w1_yit := EdgeIncrement(v2f, v0f)
	w2_xit, w2_yit := EdgeIncrement(v0f, v1f)
	w0_xi := int(expand * w0_xit)
	w0_yi := int(expand * w0_yit)
	w1_xi := int(expand * w1_xit)
	w1_yi := int(expand * w1_yit)
	w2_xi := int(expand * w2_xit)
	w2_yi := int(expand * w2_yit)

	for y := boundsTL.Y; y <= boundsBR.Y; y++ {
		w0 := w0_y
		w1 := w1_y
		w2 := w2_y
		for x := boundsTL.X; x <= boundsBR.X; x++ {
			if w0 >= 0 && w1 >= 0 && w2 >= 0 {
				fb.SetSafe(uint(x), uint(y), color)
				// w0a := w0 * invarea
				// w1a := w1 * invarea
				// w2a := w2 * invarea
			}
			w0 += w0_xi
			w1 += w1_xi
			w2 += w2_xi
		}
		w0_y += w0_yi
		w1_y += w1_yi
		w2_y += w2_yi
	}
}