perlin.nelua

global PERLIN_SIZE <comptime> = 256

global Perlin = @record{}

local perlin: record{
  rands: [PERLIN_SIZE]vec3,
  permx: [PERLIN_SIZE]integer,
  permy: [PERLIN_SIZE]integer,
  permz: [PERLIN_SIZE]integer
}

function Perlin.generate()
  for i=0,PERLIN_SIZE-1 do
    perlin.rands[i] = vec3.unit(vec3{2*math.random()-1, 2*math.random()-1, 2*math.random()-1})
  end
end

function Perlin.permute(perm: *[PERLIN_SIZE]integer)
  for i=0,PERLIN_SIZE-1 do
    perm[i] = i
  end
  for i=PERLIN_SIZE-1,1,-1 do
    local target = math.random(0, i)
    perm[i], perm[target] = perm[target], perm[i]
  end
end

local function trilinear_interp(c: [2][2][2]vec3, u: number, v: number, w: number)
  u, v, w = u*u*(3-2*u), v*v*(3-2*v), w*w*(3-2*w)
  local accum: number = 0
  for i=0,1 do
    for j=0,1 do
      for k=0,1 do
        local weight = vec3{u-i, v-j, w-k}
        accum = accum +
          ((i*u) + (1-i)*(1-u))*
          ((j*v) + (1-j)*(1-v))*
          ((k*w) + (1-k)*(1-w))*
          vec3.dot(c[i][j][k], weight)
      end
    end
  end
  return accum
end

function Perlin.noise(p: vec3): number
  local u, v, w = p.x - math.floor(p.x), p.y - math.floor(p.y), p.z - math.floor(p.z)
  local pi, pj, pk = (@integer)(math.floor(p.x)), (@integer)(math.floor(p.y)), (@integer)(math.floor(p.z))
  local c: [2][2][2]vec3
  for i=0,1 do
    for j=0,1 do
      for k=0,1 do
        c[i][j][k] = perlin.rands[
          perlin.permx[(pi+i) & 255] ~
          perlin.permy[(pj+j) & 255] ~
          perlin.permx[(pk+k) & 255]]
      end
    end
  end
  return trilinear_interp(c, u, v, w)
end

function Perlin.turb(p: vec3, depth: integer)
  local accum: number = 0
  local weight: number = 1
  for i=0,depth-1 do
    accum = accum + weight * Perlin.noise(p)
    weight = weight * 0.5
    p = p + p
  end
  return math.abs(accum)
end

Perlin.generate()
Perlin.permute(perlin.permx)
Perlin.permute(perlin.permy)
Perlin.permute(perlin.permz)