3dtrial/renderer3/hrend/render.go

package hrend

import (
// "log"
// "math"
)

type ObjectDef struct {
	Model    *ObjModel
	Texture  Framebuffer // This needs to go somewhere else eventually!
	Pos      Vec3f
	LookVec  Vec3f
	Color    Vec3f
	Scale    float32
	Lighting bool
}

func NewObjectDef(model *ObjModel, texture Framebuffer) *ObjectDef {
	result := ObjectDef{
		Model:    model,
		Texture:  texture,
		LookVec:  Vec3f{X: 0, Y: 0, Z: -1},
		Scale:    1,
		Lighting: true,
	}
	return &result
}

// 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)}
}

func ComputeBoundingBoxF(v0, v1, v2 Vec3f) (Vec3f, Vec3f) {
	return Vec3f{min(v0.X, v1.X, v2.X), min(v0.Y, v1.Y, v2.Y), min(v0.Z, v1.Z, v2.Z)},
		Vec3f{max(v0.X, v1.X, v2.X), max(v0.Y, v1.Y, v2.Y), max(v0.Z, v1.Z, v2.Z)}
}

// 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 Vec3f) 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 Vec3f) (float32, float32) {
	return (v2.Y - v1.Y), -(v2.X - v1.X)
}

// 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 EdgeFunctioni(v1, v2, p Vec2i) int {
	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 EdgeIncrementi(v1, v2 Vec2i) (int, int) {
	return (v2.Y - v1.Y), -(v2.X - v1.X)
}

func ZClip(v0f Vec3f, v1f Vec3f, v2f Vec3f) bool {
	maxz := max(v0f.Z, v1f.Z, v2f.Z)
	return maxz < -1 || maxz > 1
}

func TriangleFlat(fb *RenderBuffer, color *Vec3f, v0f Vec3f, v1f Vec3f, v2f Vec3f) {
	v0 := v0f.ToVec2i()
	v1 := v1f.ToVec2i()
	v2 := v2f.ToVec2i()
	//r, g, b := Uint2Col(color)
	boundsTL, boundsBR := ComputeBoundingBox(v0, v1, v2)
	if boundsBR.X < 0 || boundsBR.Y < 0 || boundsTL.X >= int(fb.Width) || boundsTL.Y >= int(fb.Height) {
		return
	}
	parea := EdgeFunctioni(v0, v1, v2)
	if parea <= 0 {
		return
	}
	if boundsTL.Y < 0 {
		boundsTL.Y = 0
	}
	if boundsTL.X < 0 {
		boundsTL.X = 0
	}
	if boundsBR.Y >= int(fb.Height) {
		boundsBR.Y = int(fb.Height - 1)
	}
	if boundsBR.X >= int(fb.Width) {
		boundsBR.X = int(fb.Width - 1)
	}
	// Where to start our scanning
	pstart := Vec2i{boundsTL.X, boundsTL.Y}
	invarea := 1 / float32(parea)
	w0_y := EdgeFunctioni(v1, v2, pstart)
	w1_y := EdgeFunctioni(v2, v0, pstart)
	w2_y := EdgeFunctioni(v0, v1, pstart)
	w0_xi, w0_yi := EdgeIncrementi(v1, v2)
	w1_xi, w1_yi := EdgeIncrementi(v2, v0)
	w2_xi, w2_yi := EdgeIncrementi(v0, v1)
	r := byte(255 * color.X)
	g := byte(255 * color.Y)
	b := byte(255 * color.Z)

	for y := uint(boundsTL.Y); y <= uint(boundsBR.Y); y++ {
		w0 := w0_y
		w1 := w1_y
		w2 := w2_y
		for x := uint(boundsTL.X); x <= uint(boundsBR.X); x++ {
			if (w0 | w1 | w2) >= 0 {
				w0a := float32(w0) * invarea
				w1a := float32(w1) * invarea
				w2a := float32(w2) * invarea
				pz := w0a*v0f.Z + w1a*v1f.Z + w2a*v2f.Z
				if pz < fb.ZBuffer[x+y*fb.Width] {
					fb.ZBuffer[x+y*fb.Width] = pz
					fb.Data.Set(x, y, r, g, b)
				}
			}
			w0 += w0_xi
			w1 += w1_xi
			w2 += w2_xi
		}
		w0_y += w0_yi
		w1_y += w1_yi
		w2_y += w2_yi
	}
}

func TriangleTextured(fb *RenderBuffer, texture Framebuffer, intensity float32, v0v Vertex, v1v Vertex, v2v Vertex) {
	// min,      max
	boundsTLf, boundsBRf := ComputeBoundingBoxF(v0v.Pos, v1v.Pos, v2v.Pos)
	// The triangle is fully out of bounds; we don't have a proper clipper, so this
	// check still needs to be performed
	if boundsBRf.Y < 0 || boundsBRf.X < 0 || boundsTLf.X >= float32(fb.Width) || boundsTLf.Y >= float32(fb.Height) { //||
		return
	}
	v0 := v0v.Pos.ToVec2i()
	v1 := v1v.Pos.ToVec2i()
	v2 := v2v.Pos.ToVec2i()
	parea := EdgeFunctioni(v0, v1, v2)
	// Don't even bother with drawing backfaces or degenerate triangles;
	// don't even give the user the option
	if parea <= 0 {
		return
	}
	boundsTL := Vec2i{
		X: int(max(boundsTLf.X, 0)),
		Y: int(max(boundsTLf.Y, 0)),
	}
	boundsBR := Vec2i{
		X: int(min(boundsBRf.X, float32(fb.Width-1))),
		Y: int(min(boundsBRf.Y, float32(fb.Height-1))),
	}
	// Where to start our scanning
	pstart := Vec2i{boundsTL.X, boundsTL.Y}
	invarea := 1 / float32(parea)
	w0_y := EdgeFunctioni(v1, v2, pstart)
	w1_y := EdgeFunctioni(v2, v0, pstart)
	w2_y := EdgeFunctioni(v0, v1, pstart)
	w0_xi, w0_yi := EdgeIncrementi(v1, v2)
	w1_xi, w1_yi := EdgeIncrementi(v2, v0)
	w2_xi, w2_yi := EdgeIncrementi(v0, v1)

	for y := uint(boundsTL.Y); y <= uint(boundsBR.Y); y++ {
		w0 := w0_y
		w1 := w1_y
		w2 := w2_y
		for x := uint(boundsTL.X); x <= uint(boundsBR.X); x++ {
			if (w0 | w1 | w2) >= 0 {
				//if w0 >= 0 && w1 >= 0 && w2 >= 0 {
				w0a := float32(w0) * invarea
				w1a := float32(w1) * invarea
				w2a := float32(w2) * invarea
				pz := w0a*v0v.Pos.Z + w1a*v1v.Pos.Z + w2a*v2v.Pos.Z
				if pz < fb.ZBuffer[x+y*fb.Width] {
					fb.ZBuffer[x+y*fb.Width] = pz
					r, g, b := texture.GetUv(
						(w0a*v0v.Tex.X + w1a*v1v.Tex.X + w2a*v2v.Tex.X),
						(w0a*v0v.Tex.Y + w1a*v1v.Tex.Y + w2a*v2v.Tex.Y),
					)
					fb.Data.Set(x, y, byte(float32(r)*intensity), byte(float32(g)*intensity), byte(float32(b)*intensity))
				}
			}
			w0 += w0_xi
			w1 += w1_xi
			w2 += w2_xi
		}
		w0_y += w0_yi
		w1_y += w1_yi
		w2_y += w2_yi
	}
}

// Return true if the face should be culled
func BackfaceCull(v1, v2, v3 Vec3f) bool {
	// This is what it essentially is
	// e1 := v1.Sub(&v2)
	// e2 := v1.Sub(&v3)
	// // If viewing front face, it should be pointing in the positive z direction
	// return e1.CrossProduct(e2).Z <= 0
	// But we know we can just use x and y since this is post projection
	return (v1.X-v2.X)*(v3.Y-v2.Y)-(v1.Y-v2.Y)*(v3.X-v2.X) >= 0
}

func conditionalAddTriangle(sc Facef, w [3]float32, out []Facef) []Facef {
	// The triangle is fine
	for i := range 3 {
		if w[i] != 1 {
			sc[i].Pos.X /= w[i]
			sc[i].Pos.Y /= w[i]
			sc[i].Pos.Z /= w[i]
		}
	}
	// Backface culling: no need to do anything with triangles facing the wrong way
	if EdgeFunction(sc[0].Pos, sc[1].Pos, sc[2].Pos) <= 0 {
		out = append(out, sc)
	}

	return out
}

func PerspectiveAndClip(face Facef, matrix3d *Mat44f) []Facef {
	outfaces := make([]Facef, 0, 2)
	var sc Facef
	var w [3]float32
	var d [3]float32
	outers := make([]int, 0, 3)
	inners := make([]int, 0, 3)
	for i := range 3 {
		sc[i] = face[i]
		sc[i].Pos, w[i] = matrix3d.MultiplyPoint3(face[i].Pos)
		d[i] = sc[i].Pos.Z + w[i]
		if d[i] < 0.001 {
			outers = append(outers, i)
		} else {
			inners = append(inners, i)
		}
	}

	if len(outers) == 2 { // The one triangle thing
		ai := inners[0]
		bi := outers[0]
		ci := outers[1]

		// Calc how far along we are on each of these lines. These are the new points
		tab := d[ai] / (d[ai] - d[bi])
		tac := d[ai] / (d[ai] - d[ci])

		// The two points that aren't a need to be the interpolated values
		sc[bi].Pos = LerpVec3f(sc[ai].Pos, sc[bi].Pos, tab)
		sc[ci].Pos = LerpVec3f(sc[ai].Pos, sc[ci].Pos, tac)
		w[bi] = LerpF32(w[ai], w[bi], tab)
		w[ci] = LerpF32(w[ai], w[ci], tac)

		outfaces = conditionalAddTriangle(sc, w, outfaces)
	} else if len(outers) == 1 { // The two triangle thing, two new corners
		ai := outers[0]
		bi := inners[0]
		ci := inners[1]

		tab := d[ai] / (d[ai] - d[bi])
		tac := d[ai] / (d[ai] - d[ci])
		wa := w[ai]

		// This time, we're generating two new points.
		sct := sc

		// Only ONE point needs to be modified: the one outer. Remember that
		// tab and tac are the distance to that point itself, so a still needs
		// to be the first value here
		sct[ai].Pos = LerpVec3f(sc[ai].Pos, sc[bi].Pos, tab)
		w[ai] = LerpF32(w[ai], w[bi], tab)
		outfaces = conditionalAddTriangle(sct, w, outfaces)

		// Now that we've replaced the far point, we also need to replace
		// the original B point that we used, since that's part of the other
		// triangle. But simply replacing it will make the triangle invisible,
		// since it inverts the winding order (I think)
		sct[bi].Pos = LerpVec3f(sc[ai].Pos, sc[ci].Pos, tac)
		w[bi] = LerpF32(wa, w[ci], tac)
		// Now swap the a and b
		w[ai], w[bi] = w[bi], w[ai]
		sct[ai], sct[bi] = sct[bi], sct[ai]
		outfaces = conditionalAddTriangle(sct, w, outfaces)

		/*
			sc2[ai].Pos = LerpVec3f(sc2[ai].Pos, sc2[ci].Pos, tac)
			w[ai] = LerpF32(w[ai], w[ci], tac)
			//outfaces = conditionalAddTriangle(sc2, w, outfaces)
		*/

	} else if len(outers) != 3 { // Output the face itself, no modification
		outfaces = conditionalAddTriangle(sc, w, outfaces)
	}

	return outfaces

	// TODO: Now that we're here doing it like this, might as well remove faces
	// that are fully outside the other clipping zones. No need to do actual clipping...
	// just full rejections. This saves a BIT of processing... though not much
	// NOTE: Uh no... this is too much effort. Two points could be outside individual
	// planes and thus still intersect the screen.
}