main.nelua

require "iterators"
require "string"
require "os"

local World = require "entropy.world"
local Storage = require "entropy.world.storage"
local P = require "entropy.world.pointer"
local Vec2 = require "entropy.math.vec2"
local Vec3 = require "entropy.math.vec3"
local Mat4 = require "entropy.math.mat4"

local world: World
-- register components
World.r("positions", Vec2)
World.r("velocities", Vec2)
##[[
function unroll(count, block)
  for i=1,count do
    block(i)
  end
end
]]
## unroll(10, function(i)
  World.r(#["_" .. tostring(i)]#, usize)
## end)

local Entity = @record{
  pos: P(Vec2),
  vel: P(Vec2),
}

World.r("entities", Entity)

local positions = world:s("positions", Vec2)
positions:reserve(10010)
local velocities = world:s("velocities", Vec2)
velocities:reserve(10010)
local entities = world:s("entities", Entity)
entities:reserve(10010)

for i=0,<10 do
  local pos = positions:create({ x = i, y = i })
  local vel = velocities:create({ x = i, y = i })
  local entity = entities:create({
    pos = pos,
    vel = vel,
  })
end

-- Initial State
print("===== Initial State =====")
for id, e in mpairs(entities) do
  print(id, e, positions[e.pos], velocities[e.vel])
end

-- Run "System"
for _, e in mpairs(entities) do
  positions[e.pos] = positions[e.pos] + velocities[e.vel]
end

-- Final State
print("===== Final State =====")
for id, e in mpairs(entities) do
  print(id, e, positions[e.pos], velocities[e.vel])
end

-- Benchmark
print("===== Benching with 10,000 Entities =====")

local now = os.now()
for i=0,<10000 do
  if i % 10 == 0 then
    entities:create({
      pos = positions:create({ x = i, y = i }),
      vel = velocities:create({ x = i, y = i }),
    })
  else
    entities:create({
      pos = positions:create({ x = i, y = i }),
    })
  end
end
print("Creation: ", (os.now() - now) * 1000000)

require "vector"
local times: vector(float64)

for i=0,<1000 do
  now = os.now()
  for id, e in mpairs(entities) do
    positions[e.pos] = positions[e.pos] + velocities[e.vel]
  end
  local time = os.now() - now

  times:push(time)
end

local avg: float64 = 0.0
for _, time in ipairs(times) do
  avg = avg + time
end
avg = avg / #times

print("Avg Iteration: ", avg * 1000000)

-- renderer
require "wgpu"
wgpuSetLogCallback((@WGPULogCallback)(function(level: WGPULogLevel, msg: cstring, ptr: pointer): void
  print("WGPU" .. level .. ": " .. msg)
end))
wgpuSetLogLevel(WGPULogLevel_Info)

local Render = require 'entropy.render'
local Context = require 'entropy.render.context.glfw'
local Renderer = require "entropy.render.renderer"
local MeshImpl = require "entropy.render.impl.mesh"
require "entropy.render.impl.compose"
local Camera = require "entropy.scene.camera"
local Mesh = require "entropy.scene.mesh"
local Event = require "entropy.defs.event"

local render: Render
render:init_default()

local context: Context
context:init("testing", 512, 512, true, render)

##[[
local Impl = ComposeImpl({
  MeshImpl,
})
]]
local ImplT = #[Impl]#
local renderer: Renderer(ImplT)
renderer:init(context.device, context.surface_config.format, context.surface_config.width, context.surface_config.height)

-- setup resize callback
context.user_pointer = &renderer
context.resize_callback = function(user: pointer, width: uint32, height: uint32): void
  local crenderer = (@*Renderer(ImplT))(user)
  crenderer:resize(width, height)
end

-- setup camera
local cameras = world:s("entropy.scene.cameras", Camera)
local camera_idx = cameras:create({
  pos = { 10, 10, 10 },
  rot = { 0, 0, 0 },

  fov = 90,

  z_near = 0.1,
  z_far = 10000,
})
cameras[camera_idx]:look_at({ 0, 0, 0 })

-- load meshes
local meshes = world:s("entropy.scene.meshes", Mesh)
local cube_mesh_idx = meshes:create(Mesh.load_from_obj_comptime("./cube.obj"))
local cube_mesh = &meshes[cube_mesh_idx]
cube_mesh:init(world, "cube")

local count: isize <const> = 20

local instances = world:s("entropy.scene.meshes.cube", Mesh.Instance)
for y=-count,<count do
  for x=-count,<count do
    for z=-count,<count do
      local instance_idx = instances:create(cube_mesh:instance())
      instances[instance_idx].transform = Mat4.from_pos({ x * 5, z * 5, y * 5 }) * Mat4.from_scl({ 2, 2, 2 })
    end
  end
end

print("Total Instances: " .. tostring(#instances))

cube_mesh:prepare(renderer)

local fps_list: vector(float64)

local is_forward_pressed = false
local is_backward_pressed = false
local is_left_pressed = false
local is_right_pressed = false
local is_up_pressed = false
local is_down_pressed = false
local is_speed_pressed = false

local camera_yaw = 0.0
local camera_pitch = 0.0

local last_mouse_x = 0.0
local last_mouse_y = 0.0

while not context:should_close() do
  local now = world:now()

  -- get input
  local has_event, event_queue = context:poll_event()
  if has_event then
    while not event_queue:empty() do
      local event = event_queue:popfront()
      if event.type == Event.Type.Key then
        if event.data.Key.action == Event.Data.Key.Action.Press then
          if event.data.Key.key == 256 then
            context:close();
          end
        end

        local state: boolean = false
        if event.data.Key.action == Event.Data.Key.Action.Press or event.data.Key.action == Event.Data.Key.Action.Repeat then
          state = true
        elseif event.data.Key.action == Event.Data.Key.Action.Release then
          state = false
        end

        if event.data.Key.key == 87 then
          is_forward_pressed = state
        elseif event.data.Key.key == 83 then
          is_backward_pressed = state
        elseif event.data.Key.key == 65 then
          is_left_pressed = state
        elseif event.data.Key.key == 68 then
          is_right_pressed = state
        elseif event.data.Key.key == 32 then
          is_up_pressed = state
        elseif event.data.Key.key == 340 then
          is_down_pressed = state
        elseif event.data.Key.key == 341 then
          is_speed_pressed = state
        end
      elseif event.type == Event.Type.MouseMotion then
        local mouse_dx = event.data.MouseMotion.x - last_mouse_x
        local mouse_dy = event.data.MouseMotion.y - last_mouse_y

        local sensitivity = 0.2
        camera_yaw = camera_yaw + math.rad(mouse_dx) * sensitivity
        camera_pitch = math.clamp(camera_pitch + math.rad(mouse_dy) * sensitivity, (-math.pi / 2) + 0.0001, (math.pi / 2) - 0.0001)

        local camera = &cameras[camera_idx]
        camera.rot = (@Vec3)({ math.cos(camera_yaw) * math.cos(camera_pitch), -math.sin(camera_pitch), math.sin(camera_yaw) * math.cos(camera_pitch) }):norm()

        last_mouse_x = event.data.MouseMotion.x
        last_mouse_y = event.data.MouseMotion.y
      end
    end
  end

  -- update
  local speed = 1
  if is_speed_pressed then
    speed = 10
  end
  if is_forward_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos + cameras[camera_idx].rot * speed
  end
  if is_backward_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos - cameras[camera_idx].rot * speed
  end
  if is_left_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos - cameras[camera_idx].rot:cross({0, 1, 0}):norm() * speed
  end
  if is_right_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos + cameras[camera_idx].rot:cross({0, 1, 0}):norm() * speed
  end
  if is_up_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos + {0, speed, 0}
  end
  if is_down_pressed then
    cameras[camera_idx].pos = cameras[camera_idx].pos - {0, speed, 0}
  end

  for _, instance in mpairs(instances) do
    instance.transform = instance.transform * Mat4.from_pos({ (math.random() - 0.5) * speed, (math.random() - 0.5) * speed, (math.random() - 0.5) * speed }) * Mat4.from_rot(math.random() / 10, { math.random(), math.random(), math.random() })
  end

  for _, mesh in mpairs(meshes) do
    mesh:update(renderer)
  end

  -- render
  local view = context:view()
  renderer:render(view, &world)
  context:present()

  fps_list:push(1 / (world:now() - now))
  if #fps_list > 30 then
    local avg: float64 = 0.0
    for _, time in ipairs(fps_list) do
      avg = avg + time
    end
    avg = avg / #fps_list
    print("FPS: ", avg)
    fps_list:clear()
  end
end

renderer:cleanup()
context:cleanup()
render:cleanup()