lunray.nelua

##[[
DENOISER = true
-- OPENMP = true
-- CARTOONIZED = true
-- EMSCRIPTEN = true
]]

require 'config'
require 'mathx'
require 'vec2'
require 'vec3'
require 'argbcolor'
require 'perlin'
require 'sdl2'
require 'ray'
require 'texture'
require 'material'
require 'sphere'
require 'camera'
require 'window'

local SCREEN_WIDTH <comptime> = 480
local SCREEN_HEIGHT <comptime> = 270
local NUMSAMPLES <comptime> = 1
local MAXDEPTH <comptime> = 8
local APERTURE <comptime> = 0.05
local SCREEN_SCALE <comptime> = 1

local worldsize
local Hitlist = @array(Sphere,500)
local world: Hitlist
local cam: Camera
local window: Window
local pixels: [SCREEN_HEIGHT][SCREEN_WIDTH]argbcolor
## if DENOISER then
local tempixels: [SCREEN_HEIGHT][SCREEN_WIDTH]vec3
local ntem = 0
## end
local lastticks = SDL_GetTicks()
local fps = 0
local quit = false

local function Hitlist_hit(self: *Hitlist, r: Ray, tmin: number, tmax: number): (boolean, Hit)
  local rec: Hit
  local tnear = tmax
  local hashit = false
  for i=0,<worldsize do
    local hitted, temprec = Sphere.hit(self[i], r, tmin, tnear)
    if hitted and temprec.t < tnear then
      hashit = true
      tnear = temprec.t
      rec = temprec
    end
  end
  return hashit, rec
end

local function sky_color(direction: vec3)
  local t = 0.5*(direction.y + 1)
  return vec3.lerp(vec3{1,1,1}, vec3{0.5, 0.7, 1}, t)
end

local function trace_ray(r: Ray, depth: integer): vec3 <noinline>
  local hitted, rec = Hitlist_hit(world, r, 0.001, 1e32)
  if hitted then
    local emitted = Material.emitted(rec.mat, rec.uv, rec.p)
    if depth > MAXDEPTH then
      return emitted
    end
    local forward, attenuation, scattered = Material.scatter(rec.mat, r, rec)
    if forward then
      return emitted + trace_ray(scattered, depth+1) * attenuation
    else
      return emitted
    end
  end
  return sky_color(r.direction)
end

local function draw() <noinline>
  ## if DENOISER then
    if ntem == 0 then
      for y=0,<SCREEN_HEIGHT do
        for x=0,<SCREEN_WIDTH do
          tempixels[y][x] = vec3{}
        end
      end
    end
    ntem = ntem + 1
  ## end
  local yoff = window.height - 1
  ##[[if OPENMP then
    cemit '#pragma omp parallel for schedule(dynamic)'
  end]]
  for y=0,<SCREEN_HEIGHT do
    for x=0,<SCREEN_WIDTH do
      ## if NUMSAMPLES.value:tonumber() == 1 then
        local v, u
        ## if DENOISER then
          v, u = (y + math.fastrand() - 0.5) / SCREEN_HEIGHT, (x + math.fastrand() - 0.5) / SCREEN_WIDTH
        ## else
          v, u =  y / SCREEN_HEIGHT, x / SCREEN_WIDTH
        ## end
        local col = trace_ray(Camera.getray(cam, u, v), 0)
      ## else
        local col: vec3
        for i=1,NUMSAMPLES do
          local v, u = (y + math.fastrand() - 0.5) / SCREEN_HEIGHT, (x + math.fastrand() - 0.5) / SCREEN_WIDTH
          col = col + trace_ray(Camera.getray(cam, u, v), 0)
        end
        col = col / NUMSAMPLES
      ## end
      col = vec3.sqrt(col) -- gamma correction
      col = vec3.min(col, vec3{1,1,1})
      ## if DENOISER then
        tempixels[y][x] = tempixels[y][x] + col
        pixels[yoff - y][x] = argbcolor.fromvec3(tempixels[y][x] / ntem)
      ## else
        pixels[yoff - y][x] = argbcolor.fromvec3(col)
      ## end
    end
  end
  window:uploadpixels(&pixels[0][0])
end

local function refresh()
  ## if DENOISER then
  ntem = 0
  ## end
end

local function world_init()
  world[1] = Sphere{center={ 0,-1000,0}, radius=1000, mat={MATERIALS.LAMBERTIAN, albedo={TEXTURES.CHECKER, diffuse_color={0.1, 0.1, 0.1}, scale=10}}}
  world[3] = Sphere{center={ 0,    1,0}, radius=1, mat={MATERIALS.DIELECTRIC, fuzz=1.5}}
  world[2] = Sphere{
    center={-3,1,0},
    radius=1,
    mat={
      MATERIALS.LAMBERTIAN,
      albedo={
        TEXTURES.NOISE,
        diffuse_color={0.9, 0.1, 0.1},
        scale=10
      }
    }
  }
  world[4] = Sphere{center={ 3,    1,0}, radius=1, mat={MATERIALS.METAL, albedo={TEXTURES.COLOR, {0.7, 0.6, 0.5}}}}

  local i = 5
  local NUMSPHERES <comptime> = 3
  for a=-NUMSPHERES,<NUMSPHERES do
    for b=-NUMSPHERES,<NUMSPHERES do
      local choosemat = math.random()
      local center = vec3{-4+8*math.random(), 0.2, -4+8*math.random()}
      if choosemat < 0.8 then --diffuse
        world[i] = Sphere{center=center, radius=0.2, mat={MATERIALS.LAMBERTIAN, albedo={TEXTURES.COLOR, {math.random()*math.random(), math.random()*math.random(), math.random()*math.random()}}}}
      elseif choosemat < 0.95 then -- metal
        world[i] = Sphere{center=center, radius=0.2, mat={MATERIALS.METAL, albedo={TEXTURES.COLOR, {0.5*(1+math.random()), 0.5*(1+math.random()), 0.5*(1+math.random())}}, fuzz=0.5*math.random()}}
      else -- glass
        world[i] = Sphere{center=center, radius=0.2, mat={MATERIALS.DIELECTRIC, fuzz=1.5}}
      end
      i = i + 1
    end
  end
  worldsize = i

  for i=0,<worldsize do
    Sphere.update(world[i])
  end

  local lookfrom = vec3{5.1,1.2,2.4}
  local lookat = vec3{2.0,1,0.8}
  local vup = vec3{0,1,0}
  local vfov = 59
  local aspect = SCREEN_WIDTH/SCREEN_HEIGHT
  local aperture: number = APERTURE
  local focusdist: number = 4
  cam = Camera.create(lookfrom, lookat, vup, vfov, aspect, aperture, focusdist)
end

local function poll_events() <noinline>
  local event: SDL_Event
  while SDL_PollEvent(&event) ~= 0 do
    switch event.type
    case SDL_QUIT then
      quit = true
    case SDL_KEYDOWN then
      local kevent = (@*SDL_KeyboardEvent)(&event)
      switch kevent.keysym.sym
      case SDLK_UP then
        cam:rotate(0.05, 0)
        refresh()
      case SDLK_DOWN then
        cam:rotate(-0.05, 0)
        refresh()
      case SDLK_RIGHT then
        cam:rotate(0, -0.05)
        refresh()
      case SDLK_LEFT then
        cam:rotate(0, 0.05)
        refresh()
      case SDLK_ESCAPE then
        quit = true
      case SDLK_w then
        cam:translate(0, 0, 0.05)
        refresh()
      case SDLK_s then
        cam:translate(0, 0, -0.05)
        refresh()
      case SDLK_a then
        cam:translate(-0.05, 0, 0)
        refresh()
      case SDLK_d then
        cam:translate(0.05, 0, 0)
        refresh()
      case SDLK_e then
        cam:translate(0, 0.05, 0)
        refresh()
      case SDLK_q then
        cam:translate(0, -0.05, 0)
        refresh()
      end
    end
  end
end

local function frame()
  local ticks = SDL_GetTicks()
  if ticks - lastticks >= 1000 then
    print('FPS', fps)
    lastticks = ticks
    fps = 0
  end

  poll_events()
  draw()
  fps = fps + 1
end

local function emframe(context: pointer) <codename 'emframe'>
  frame()
end

local function go()
  world_init()
  window = Window.create(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_SCALE)

  ## if not EMSCRIPTEN then
    repeat
      frame()
    until quit

    window:destroy()
  ## else
    ## cemit 'emscripten_set_main_loop_arg(emframe, 0, -1, 1);'
  ## end
end

go()