# Boids/Nim

Translation of: C
Library: OpenGL
import math, os, random, strformat, times
import opengl, opengl/glut, opengl/glu

const
MaxMountainHeight = 25
MountainRatio = 500

IdealHeight = 1     # how high a boid prefers to stay above ground.
IdealDistance = 5   # how far boids prefer to stay away from each other.
MoveSpeed = 1e-2
N = 100
WorldSize = 40

####################################################################################################
# Vector.

type Vec = tuple[x, y, z: float32]

func `*=`(a: var Vec; r: float32) =
a.x *= r
a.y *= r
a.z *= r

func muladd(a: var Vec; b: Vec; r: float32) =
a.x += r * b.x
a.y += r * b.y
a.z += r * b.z

func `+=`(a: var Vec; b: Vec) =
a.x += b.x
a.y += b.y
a.z += b.z

func `+`(a, b: Vec): Vec =
(a.x + b.x, a.y + b.y, a.z + b.z)

func `-`(a, b: Vec): Vec =
(a.x - b.x, a.y - b.y, a.z - b.z)

func len2(a: Vec): float32 =
a.x * a.x + a.y * a.y + a.z * a.z

func normalize(a: var Vec) =
let r = sqrt(a.len2)
if r == 0: return
a.x /= r
a.y /= r
a.z /= r

####################################################################################################

type

Boid = ref object
position: Vec
speed: float32

Mountain = ref object
x, y, h: int
r: float64
next: Mountain

World = object
x, y: array[2, int]   # mgroupingDrivein/max coords of world.
ground: seq[float32]
groundNormal: seq[Vec]
hills: Mountain

Camera = object
pitch: float
yaw: float
distance: float64
target: Vec

var
world: World
boids: array[N, Boid]
winWidth, winHeight: int
camera = Camera(pitch: -PI / 4, yaw: 0, distance: 100, target: (0f32, 0f32, 0f32))
cursorX, cursorY: int
updateTime: int

func hashXY(x, y: int): uint32 =
func ror(a: uint32; d: int): uint32 = a shl d or a shr (32 - d)

var h = 0x12345678u32
h += ror(h, 15) xor ror(x.uint32, 5)
h += ror(h, 15) xor ror(y.uint32, 5)

h = h xor ror(h, 7)
h += ror(h, 23)

h = h xor ror(h, 19)
h += ror(h, 11)

func hillHeight[T: SomeFloat](m: Mountain; x, y: T): T =
let x = x - T(m.x)
let y = y - T(m.y)
result = T(m.h) * exp(-(x * x + y * y) / (m.r * m.r))

proc groundHeight(x, y: float32): float32 =
var p = world.hills
while not p.isNil:
result += hillHeight(p, x, y)
p = p.next

proc calcNormal(x, y: float32): Vec =
var p = world.hills
while not p.isNil:
let h = hillHeight(p, float64(x), float64(y))
let t: float32 = 2 / (p.r * p.r)
result.x += (x - float32(p.x)) * t * h
result.y += (y - float32(p.y)) * t * h
p = p.next
result.z = 1
result.normalize()

proc resize(w, h: cint) {.cdecl.} =
(winWidth, winHeight) = (w, h)
glViewport(0, 0, w, h)

proc setProjection(w, h: int) =
var hor, ver: float64
if w > h:
hor = 0.05
ver = hor * float64(h) / float64(w)
else:
ver = 0.05
hor = ver * float64(w) / float64(h)

glMatrixMode(GL_PROJECTION)
glFrustum(-hor, hor, -ver, ver, 0.1, 1000)

func clamp(x: var float64; min, max: float64) =
if x < min: x = min
elif x > max: x = max

proc makeTerrain(cx, cy: int) =
if cx * 2 == world.x[0] + world.x[1] and cy * 2 == world.y[0] + world.y[1]:
return

world.x[0] = cx - WorldSize
world.x[1] = cx + WorldSize
world.y[0] = cy - WorldSize
world.y[1] = cy + WorldSize
let nx = world.x[1] - world.x[0] + 1
let ny = world.y[1] - world.y[0] + 1
world.hills = nil
for x in world.x[0]..world.x[1]:
for y in world.y[0]..world.y[1]:
let h = hashXY(x, y) mod MountainRatio
if h != 0: continue
let m = Mountain(x: x,
y: y,
r: MinMountainRadius + float64(hashXY(y, x) mod 100) / 100 *
h: int(hashXY((y + x) div 2, (y - x) div 2) mod MaxMountainHeight),
next: world.hills)
world.hills = m

if world.ground.len == 0:
world.ground = newSeq[float32](nx * ny)
if world.groundNormal.len == 0:
world.groundNormal = newSeq[Vec](nx * ny)

for x in 0..<nx:
let xx = x + world.x[0]
for y in 0..<ny:
let yy = y + world.y[0]
world.ground[x * ny + y] = groundHeight(float32(xx), float32(yy))
world.groundNormal[x * ny + y] = calcNormal(float32(xx), float32(yy))

proc setLighting() =
var
lightAmbient = [float32 0.3, 0.3, 0.3, 1]
lightDiffuse = [float32 1, 1, 1, 1]
lightPosition = [float32 0, 1, 2, 1]

glEnable(GL_LIGHTING)
glEnable(GL_LIGHT1)
glEnable(GL_COLOR_MATERIAL)

proc boidThink(boid: Boid) =
let g = groundHeight(boid.position.x, boid.position.y)
let migrationDrive: Vec = (0f32, 0.5f32, 0f32)
var heightDrive, crowdingDrive, groupingDrive: Vec
heightDrive.z = (IdealHeight + g - boid.position.z) * 0.3

# Follow the ground surface normal.
let terrainDrive = calcNormal(boid.position.x, boid.position.y)
var totalWeight = 0f32
for other in boids:
if other == boid: continue
var diff = other.position - boid.position
let d2 = diff.len2
let weight = 1 / (d2 * d2)
diff.normalize()
crowdingDrive.muladd(diff, if d2 > IdealDistance * IdealDistance: weight else: -weight)
totalWeight += weight

groupingDrive *= 1 / totalWeight
boid.newheading = migrationDrive + heightDrive + terrainDrive + crowdingDrive + groupingDrive

let cx = float32(world.x[0] + world.x[1]) / 2
let cy = float32(world.y[0] + world.y[1]) / 2
boid.newheading.x += (cx - boid.position.x) / 400
boid.newheading.y += (cy - boid.position.y) / 400

proc runBoids(msec: int) =
for boid in boids:
var average: Vec
for boid in boids:
average += boid.position
average *= 1 / N
camera.target = average
makeTerrain(average.x.toInt, average.y.toInt)
for boid in boids:
boidThink(boid)
for boid in boids:

proc drawTerrain() =
let nx = world.x[1] - world.x[0] + 1
let ny = world.y[1] - world.y[0] + 1
glColor3f(0.1, 0.25, 0.35)
for x in 0..<(nx-1):
let xx = x + world.x[0]
for y in 0..<ny:
let yy = y + world.y[0]
glVertex3f(float32(xx), float32(yy), world.ground[x*ny+y])
glVertex3f(float32(xx+1), float32(yy), world.ground[(1+x)*ny+y])
glEnd()

proc draw(boid: Boid) =
glColor3f(0.6, 0.3, 0.3)
glPushMatrix()
glTranslatef(boid.position.x, boid.position.y, boid.position.z)
let (x, y, z) = boid.heading
let yaw: float32 = arctan2(float64(y), float64(x)) / PI * 180 - 90
glRotatef(yaw, 0, 0, 1)
let rxy = sqrt(float64(x * x + y * y))
let pitch: float32 = arctan2(float64(z), rxy) / PI * 180
glRotatef(pitch, 1, 0, 0)

glBegin(GL_TRIANGLES)

glNormal3f(-0.8, 0, 0.6)
glVertex3f(0, 0.5, 0)
glVertex3f(-0.5, -0.5, 0)
glVertex3f(0, 0, 0.1)

glNormal3f(0.8, 0, 0.6)
glVertex3f(0, 0.5, 0)
glVertex3f(0.5, -0.5, 0)
glVertex3f(0, 0, 0.1)

glNormal3f(-0.8, 0, -0.6)
glVertex3f(0, 0.5, 0)
glVertex3f(-0.5, -0.5, 0)
glVertex3f(0, 0, -0.1)

glNormal3f(0.8, 0, -0.6)
glVertex3f(0, 0.5, 0)
glVertex3f(0.5, -0.5, 0)
glVertex3f(0, 0, -0.1)

glNormal3f(1, -1, 0)
glVertex3f(-0.5, -0.5, 0)
glVertex3f(0, 0, 0.1)
glVertex3f(0, 0, -0.1)

glNormal3f(-1, -1, 0)
glVertex3f(0.5, -0.5, 0)
glVertex3f(0, 0, 0.1)
glVertex3f(0, 0, -0.1)

glEnd()
glPopMatrix()

proc render() {.cdecl.} =
let msec = (epochTime() * 1000).toInt
if msec < updateTime + 16:
sleep updateTime + 16 - msec

runBoids(msec - updateTime)
updateTime = msec
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
glEnable(GL_DEPTH_TEST)
setProjection(winWidth, winHeight)
clamp(camera.distance, 1, 1000)
clamp(camera.pitch, -PI / 2.1, PI / 2.1)
let rz = camera.distance * sin(camera.pitch)
let rxy = camera.distance * cos(camera.pitch)
glMatrixMode(GL_MODELVIEW)
setLighting()
stdout.write &"{camera.target.x:.5f} {camera.target.y:.5f}\r"
stdout.flushFile()
gluLookAt(camera.target.x - rxy * cos(camera.yaw),
camera.target.y - rxy * sin(camera.yaw),
camera.target.z - rz,
camera.target.x,
camera.target.y,
camera.target.z,
0, 0, 1)
drawTerrain()
for boid in boids:
boid.draw()
glFlush()
glutSwapBuffers()

proc keyDown(key: int8; x, y: cint) {.cdecl.} =
echo &"key down: {chr(key)} ({x} {y})"
if key == ord('q'):
quit QuitSuccess

proc mouseButton(button, state, x, y: cint) {.cdecl.} =
if state == GLUT_UP: return
if button == 3:
camera.distance /= 1.2
elif button == 4:
camera.distance *= 1.2
cursorX = x
cursorY = y

proc mouseMove(x, y: cint) {.cdecl.} =
let ext = max(winWidth, winHeight) div 4
camera.yaw -= (x - cursorX) / ext
camera.pitch -= (y - cursorY) / ext
cursorX = x
cursorY = y

proc initGL() =
updateTime = (epochTime() * 1000).toInt
glutInit()
glutInitDisplayMode(GLUT_RGB or GLUT_DOUBLE)
glutInitWindowSize(600, 400)
glutIgnoreKeyRepeat(1)
glutKeyboardFunc(keyDown)
glutReshapeFunc(resize)
glutIdleFunc(render)
glutDisplayFunc(render)
glutMouseFunc(mouseButton)
glutMotionFunc(mouseMove)