285 lines
8.0 KiB
Go
285 lines
8.0 KiB
Go
package main
|
|
|
|
import (
|
|
"image"
|
|
"image/color"
|
|
"log"
|
|
"math"
|
|
"math/rand"
|
|
"renderer4/hrend"
|
|
)
|
|
|
|
func Checkerboard(cols []color.Color, size int) image.Image {
|
|
result := image.NewRGBA(image.Rect(0, 0, size, size))
|
|
for y := range size {
|
|
for x := range size {
|
|
result.Set(x, y, cols[(x+y)%len(cols)])
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Returns a sizexsize*3 texture where the top is the top color,
|
|
// bottom is bottom color, middle is gradient
|
|
func Gradient(bottom color.Color, top color.Color, size int) image.Image {
|
|
result := image.NewRGBA(image.Rect(0, 0, size, size*3))
|
|
br, bg, bb, ba := bottom.RGBA()
|
|
tr, tg, tb, ta := top.RGBA()
|
|
for y := range size {
|
|
for x := range size {
|
|
lerp := float32(y) / float32(size-1)
|
|
result.Set(x, y, top)
|
|
result.Set(x, y+size, color.RGBA{
|
|
R: byte(float32(tr>>8)*(1-lerp) + float32(br>>8)*lerp),
|
|
G: byte(float32(tg>>8)*(1-lerp) + float32(bg>>8)*lerp),
|
|
B: byte(float32(tb>>8)*(1-lerp) + float32(bb>>8)*lerp),
|
|
A: byte(float32(ta>>8)*(1-lerp) + float32(ba>>8)*lerp),
|
|
})
|
|
result.Set(x, y+size*2, bottom)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Returns a 1px wide gradient where top is top color, bottom is bottom color
|
|
func Gradient1px(bottom color.Color, top color.Color, size int) image.Image {
|
|
result := image.NewRGBA(image.Rect(0, 0, 1, size))
|
|
br, bg, bb, ba := bottom.RGBA()
|
|
tr, tg, tb, ta := top.RGBA()
|
|
for y := range size {
|
|
lerp := float32(y) / float32(size-1)
|
|
result.Set(0, y, color.RGBA{
|
|
R: byte(float32(tr>>8)*(1-lerp) + float32(br>>8)*lerp),
|
|
G: byte(float32(tg>>8)*(1-lerp) + float32(bg>>8)*lerp),
|
|
B: byte(float32(tb>>8)*(1-lerp) + float32(bb>>8)*lerp),
|
|
A: byte(float32(ta>>8)*(1-lerp) + float32(ba>>8)*lerp),
|
|
})
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Skybox for now assumes a 1px gradient
|
|
func Skybox() *hrend.ObjModel {
|
|
v := make([]hrend.Vec3f, 8)
|
|
vt := make([]hrend.Vec3f, 2)
|
|
f := make([]hrend.Facei, 12)
|
|
// Assuming 1px gradient, these are the only two texture points you need
|
|
vt[0] = hrend.Vec3f{X: 0, Y: 0.001, Z: 0}
|
|
vt[1] = hrend.Vec3f{X: 0, Y: 1, Z: 0}
|
|
vvt := []uint16{
|
|
0, 0, 0, 0, 1, 1, 1, 1,
|
|
//vt[0], vt[0], vt[0], vt[0], vt[1], vt[1], vt[1], vt[1],
|
|
}
|
|
// Cube faces are weird, I guess just manually do them? ugh
|
|
// First 4 are the bottom vertices. We can make two faces out of these
|
|
v[0] = hrend.Vec3f{X: float32(-1), Y: float32(-1), Z: float32(-1)}
|
|
v[1] = hrend.Vec3f{X: float32(1), Y: float32(-1), Z: float32(-1)}
|
|
v[2] = hrend.Vec3f{X: float32(1), Y: float32(-1), Z: float32(1)}
|
|
v[3] = hrend.Vec3f{X: float32(-1), Y: float32(-1), Z: float32(1)}
|
|
// Now the top 4 vertices, same order as bottom
|
|
v[4] = hrend.Vec3f{X: float32(-1), Y: float32(1), Z: float32(-1)}
|
|
v[5] = hrend.Vec3f{X: float32(1), Y: float32(1), Z: float32(-1)}
|
|
v[6] = hrend.Vec3f{X: float32(1), Y: float32(1), Z: float32(1)}
|
|
v[7] = hrend.Vec3f{X: float32(-1), Y: float32(1), Z: float32(1)}
|
|
// These are our 12 faces
|
|
fv := [][3]uint16{
|
|
{0, 2, 1}, // bottom
|
|
{0, 3, 2},
|
|
{4, 5, 6}, // top
|
|
{6, 7, 4},
|
|
{0, 1, 5}, // south
|
|
{5, 4, 0},
|
|
{1, 2, 6}, // east
|
|
{6, 5, 1},
|
|
{2, 3, 7}, // North
|
|
{7, 6, 2},
|
|
{3, 0, 4}, // west
|
|
{4, 7, 3},
|
|
}
|
|
for i, face := range fv {
|
|
for j := range 3 {
|
|
f[i][j].Posi = face[j] //= hrend.Vertex{Pos: face[j], Tex: vvt[face[j]]}
|
|
f[i][j].Texi = vvt[face[j]] //= hrend.Vertex{Pos: face[j], Tex: vvt[face[j]]}
|
|
}
|
|
}
|
|
// Ugh and now the sides... so complicated
|
|
return &hrend.ObjModel{
|
|
Vertices: v,
|
|
VTexture: vt,
|
|
Faces: f,
|
|
}
|
|
}
|
|
|
|
// Reset all faces and regenerate them using the vertices as a square mesh
|
|
func RegenerateSquareMesh(size int, obj *hrend.ObjModel) {
|
|
obj.VTexture = make([]hrend.Vec3f, 4)
|
|
// For the simple square terrain, there aren't a lot of texture coords...
|
|
// If you want something more complicated, replace this
|
|
obj.VTexture[0] = hrend.Vec3f{X: 0, Y: 0, Z: 0}
|
|
obj.VTexture[1] = hrend.Vec3f{X: 1, Y: 0, Z: 0}
|
|
obj.VTexture[2] = hrend.Vec3f{X: 0, Y: 1, Z: 0}
|
|
obj.VTexture[3] = hrend.Vec3f{X: 1, Y: 1, Z: 0}
|
|
obj.Faces = nil // Clear old faces
|
|
width := size + size + 1
|
|
// Faces are slightly different; we generate two for every "cell" inside the vertices
|
|
for z := 0; z < width-1; z++ {
|
|
for x := 0; x < width-1; x++ {
|
|
topleft := uint16(x + z*width)
|
|
topright := uint16(x + 1 + z*width)
|
|
bottomleft := uint16(x + (z+1)*width)
|
|
bottomright := uint16(x + 1 + (z+1)*width)
|
|
// remember to wind counter-clockwise
|
|
obj.Faces = append(obj.Faces, hrend.Facei{
|
|
{Posi: topleft, Texi: 0},
|
|
{Posi: bottomleft, Texi: 2},
|
|
{Posi: topright, Texi: 1},
|
|
}, hrend.Facei{
|
|
{Posi: topright, Texi: 1},
|
|
{Posi: bottomleft, Texi: 2},
|
|
{Posi: bottomright, Texi: 3},
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func FlatTerrain(size int) *hrend.ObjModel {
|
|
result := hrend.ObjModel{
|
|
Vertices: make([]hrend.Vec3f, 0),
|
|
VTexture: make([]hrend.Vec3f, 4),
|
|
Faces: make([]hrend.Facei, 0),
|
|
}
|
|
// Generate all the simple vertices along the plane at y=0
|
|
for z := -size; z <= size; z++ {
|
|
for x := -size; x <= size; x++ {
|
|
result.Vertices = append(result.Vertices, hrend.Vec3f{X: float32(x), Y: 0, Z: float32(z)})
|
|
}
|
|
}
|
|
RegenerateSquareMesh(size, &result)
|
|
return &result
|
|
}
|
|
|
|
func DiamondSquareTerrain(size int, roughness float32, scale float32) *hrend.ObjModel {
|
|
result := hrend.ObjModel{
|
|
Vertices: make([]hrend.Vec3f, 0),
|
|
VTexture: make([]hrend.Vec3f, 4),
|
|
Faces: make([]hrend.Facei, 0),
|
|
}
|
|
dsterra := DiamondSquare(size+size+1, float64(roughness))
|
|
// Generate all the simple vertices along the plane at y=0
|
|
for z := -size; z <= size; z++ {
|
|
for x := -size; x <= size; x++ {
|
|
//result.Vertices = append(result.Vertices, hrend.Vec3f{X: float32(x), Y: float32(float64(scale) * dsterra[0][0]), Z: float32(z)})
|
|
result.Vertices = append(result.Vertices, hrend.Vec3f{X: float32(x), Y: float32(float64(scale) * dsterra[z+size][x+size]), Z: float32(z)})
|
|
}
|
|
}
|
|
RegenerateSquareMesh(size, &result)
|
|
return &result
|
|
}
|
|
|
|
// CHATGPT -----------------------------------------
|
|
|
|
func DiamondSquare(size int, roughness float64) [][]float64 {
|
|
// Initialize the array
|
|
terrain := make([][]float64, size)
|
|
for i := range terrain {
|
|
terrain[i] = make([]float64, size)
|
|
}
|
|
|
|
// Seed the corners
|
|
terrain[0][0] = rand.Float64()
|
|
terrain[0][size-1] = rand.Float64()
|
|
terrain[size-1][0] = rand.Float64()
|
|
terrain[size-1][size-1] = rand.Float64()
|
|
log.Print("DS Seeded corners")
|
|
|
|
// Size of the step
|
|
stepSize := size - 1
|
|
for stepSize > 1 {
|
|
halfStep := stepSize / 2
|
|
|
|
// Diamond step
|
|
for y := halfStep; y < size; y += stepSize {
|
|
for x := halfStep; x < size; x += stepSize {
|
|
diamondStep(terrain, x, y, halfStep, roughness)
|
|
}
|
|
}
|
|
|
|
// Square step
|
|
for y := 0; y < size; y += halfStep {
|
|
for x := (y + halfStep) % stepSize; x < size; x += stepSize {
|
|
squareStep(terrain, x, y, halfStep, roughness)
|
|
}
|
|
}
|
|
|
|
stepSize = halfStep
|
|
}
|
|
|
|
log.Printf("DS finished squares and diamonds")
|
|
|
|
// Normalize to [0, 1]
|
|
normalize(terrain)
|
|
|
|
log.Printf("DS normalize (complete)")
|
|
|
|
return terrain
|
|
}
|
|
|
|
// Diamond step of the algorithm
|
|
func diamondStep(terrain [][]float64, x, y, halfStep int, roughness float64) {
|
|
sum := terrain[y-halfStep][x-halfStep] +
|
|
terrain[y-halfStep][x+halfStep] +
|
|
terrain[y+halfStep][x-halfStep] +
|
|
terrain[y+halfStep][x+halfStep]
|
|
|
|
avg := sum / 4
|
|
terrain[y][x] = avg + (rand.Float64()*2-1)*roughness
|
|
}
|
|
|
|
// Square step of the algorithm
|
|
func squareStep(terrain [][]float64, x, y, halfStep int, roughness float64) {
|
|
avg := 0.0
|
|
count := 0
|
|
|
|
if x-halfStep >= 0 {
|
|
avg += terrain[y][x-halfStep]
|
|
count++
|
|
}
|
|
if x+halfStep < len(terrain) {
|
|
avg += terrain[y][x+halfStep]
|
|
count++
|
|
}
|
|
if y-halfStep >= 0 {
|
|
avg += terrain[y-halfStep][x]
|
|
count++
|
|
}
|
|
if y+halfStep < len(terrain) {
|
|
avg += terrain[y+halfStep][x]
|
|
count++
|
|
}
|
|
|
|
avg /= float64(count)
|
|
terrain[y][x] = avg + (rand.Float64()*2-1)*roughness
|
|
}
|
|
|
|
// Normalize the array to range [0, 1]
|
|
func normalize(terrain [][]float64) {
|
|
minVal, maxVal := math.Inf(1), math.Inf(-1)
|
|
for _, row := range terrain {
|
|
for _, value := range row {
|
|
if value < minVal {
|
|
minVal = value
|
|
}
|
|
if value > maxVal {
|
|
maxVal = value
|
|
}
|
|
}
|
|
}
|
|
|
|
rangeVal := maxVal - minVal
|
|
for i, row := range terrain {
|
|
for j := range row {
|
|
terrain[i][j] = (terrain[i][j] - minVal) / rangeVal
|
|
}
|
|
}
|
|
}
|