package main

import "core:c"
import "core:fmt"
import "core:math"
import "core:mem"
import "core:os"
import "core:time"
import "core:path/filepath"
import "core:strings"
import "core:math/linalg"

import sdl "vendor:sdl3"

modelIndex := 0

Vec3 :: [3]f32
Mat4 :: [16]f32 // column-major

Camera :: struct {
	center:   Vec3,
	distance: f32,
	orientation: Rotor,
	fov_deg:  f32,
}

Debug_State :: struct {
	enabled: bool,
	accum:   f32,
}

Rotor :: struct {
	s, x, y, z: f32,
}

Cube_Instance :: struct {
	pos:   Vec3,
	scale: f32,
	color: Vec3,
}

Vertex :: struct {
	pos: Vec3,
}

Push_Constants :: struct {
	mvp:   matrix[4,4]f32,
	color: [4]f32,
}

mat4_identity :: proc() -> Mat4 {
	return Mat4{1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1}
}

mat4_mul :: proc(a, b: Mat4) -> Mat4 {
	r := Mat4{}
	for c in 0 ..< 4 {
		for row in 0 ..< 4 {
			r[c*4+row] =
				a[0*4+row] * b[c*4+0] +
				a[1*4+row] * b[c*4+1] +
				a[2*4+row] * b[c*4+2] +
				a[3*4+row] * b[c*4+3]
		}
	}
	return r
}

vec3_sub :: proc(a, b: Vec3) -> Vec3 {
	return Vec3{a[0] - b[0], a[1] - b[1], a[2] - b[2]}
}

vec3_add :: proc(a, b: Vec3) -> Vec3 {
	return Vec3{a[0] + b[0], a[1] + b[1], a[2] + b[2]}
}

vec3_scale :: proc(v: Vec3, s: f32) -> Vec3 {
	return Vec3{v[0] * s, v[1] * s, v[2] * s}
}

vec3_dot :: proc(a, b: Vec3) -> f32 {
	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}

vec3_cross :: proc(a, b: Vec3) -> Vec3 {
	return Vec3{
		a[1] * b[2] - a[2] * b[1],
		a[2] * b[0] - a[0] * b[2],
		a[0] * b[1] - a[1] * b[0],
	}
}

vec3_normalize :: proc(v: Vec3) -> Vec3 {
	len2 := vec3_dot(v, v)
	if len2 <= 0.000001 {
		return Vec3{0, 0, 0}
	}
	inv := 1.0 / math.sqrt(len2)
	return vec3_scale(v, inv)
}

rotor_identity :: proc() -> Rotor {
	return Rotor{1, 0, 0, 0}
}

rotor_normalize :: proc(r: Rotor) -> Rotor {
	len2 := r.s*r.s + r.x*r.x + r.y*r.y + r.z*r.z
	if len2 <= 0.000001 {
		return rotor_identity()
	}
	inv := 1.0 / math.sqrt(len2)
	return Rotor{r.s * inv, r.x * inv, r.y * inv, r.z * inv}
}

rotor_mul :: proc(a, b: Rotor) -> Rotor {
	return Rotor{
		a.s*b.s - a.x*b.x - a.y*b.y - a.z*b.z,
		a.s*b.x + a.x*b.s + a.y*b.z - a.z*b.y,
		a.s*b.y - a.x*b.z + a.y*b.s + a.z*b.x,
		a.s*b.z + a.x*b.y - a.y*b.x + a.z*b.s,
	}
}

rotor_from_axis_angle :: proc(axis: Vec3, angle: f32) -> Rotor {
	a := vec3_normalize(axis)
	h := angle * 0.5
	c := math.cos(h)
	s := math.sin(h)
	return Rotor{c, a[0] * s, a[1] * s, a[2] * s}
}

rotate_vec3 :: proc(r: Rotor, v: Vec3) -> Vec3 {
	u := Vec3{r.x, r.y, r.z}
	t := vec3_scale(vec3_cross(u, v), 2.0)
	return vec3_add(v, vec3_add(vec3_scale(t, r.s), vec3_cross(u, t)))
}

mat4_translate :: proc(p: Vec3) -> Mat4 {
	m := mat4_identity()
	m[12] = p[0]
	m[13] = p[1]
	m[14] = p[2]
	return m
}

mat4_scale_uniform :: proc(s: f32) -> Mat4 {
	m := mat4_identity()
	m[0] = s
	m[5] = s
	m[10] = s
	return m
}

mat4_perspective :: proc(fov_deg, aspect, z_near, z_far: f32) -> Mat4 {
	f := 1.0 / math.tan((fov_deg * 0.5) * (math.PI / 180.0))
	m := Mat4{}
	m[0] = f / aspect
	m[5] = f
	m[10] = (z_far + z_near) / (z_near - z_far)
	m[11] = -1
	m[14] = (2.0 * z_far * z_near) / (z_near - z_far)
	return m
}

mat4_look_at :: proc(eye, target, up: Vec3) -> Mat4 {
	fwd := vec3_normalize(vec3_sub(target, eye))
	right := vec3_normalize(vec3_cross(fwd, up))
	real_up := vec3_cross(right, fwd)

	m := mat4_identity()
	m[0] = right[0]
	m[1] = real_up[0]
	m[2] = -fwd[0]
	m[4] = right[1]
	m[5] = real_up[1]
	m[6] = -fwd[1]
	m[8] = right[2]
	m[9] = real_up[2]
	m[10] = -fwd[2]
	m[12] = -vec3_dot(right, eye)
	m[13] = -vec3_dot(real_up, eye)
	m[14] = vec3_dot(fwd, eye)
	return m
}

camera_forward :: proc(c: Camera) -> Vec3 {
	return vec3_normalize(rotate_vec3(c.orientation, Vec3{0, 0, -1}))
}

camera_right :: proc(c: Camera) -> Vec3 {
	return vec3_normalize(rotate_vec3(c.orientation, Vec3{1, 0, 0}))
}

camera_up :: proc(c: Camera) -> Vec3 {
	return vec3_normalize(rotate_vec3(c.orientation, Vec3{0, 1, 0}))
}

camera_position :: proc(c: Camera) -> Vec3 {
	return vec3_sub(c.center, vec3_scale(camera_forward(c), c.distance))
}

read_file_or_fail :: proc(path: string) -> []u8 {
	file_bytes, err := os.read_entire_file(path, context.allocator)
	if err != nil {
		fmt.println("failed to read file:", path, "error:", err)
		return nil
	}
	return file_bytes
}

create_gpu_shader :: proc(device: ^sdl.GPUDevice, path: string, stage: sdl.GPUShaderStage) -> ^sdl.GPUShader {
	bytes := read_file_or_fail(path)
	if len(bytes) == 0 {
		return nil
	}

	ci := sdl.GPUShaderCreateInfo{
		code_size = uint(len(bytes)),
		code = raw_data(bytes),
		entrypoint = cstring("main"),
		format = sdl.GPUShaderFormat{.SPIRV},
		stage = stage,
		num_samplers = 0,
		num_storage_textures = 0,
		num_storage_buffers = 0,
		num_uniform_buffers = 1,
		props = 0,
	}

	shader := sdl.CreateGPUShader(device, ci)
	delete(bytes)
	if shader == nil {
		fmt.println("CreateGPUShader failed:", path, "error:", sdl.GetError())
	}
	return shader
}

loadModel :: proc(device: ^sdl.GPUDevice, model: ^RSM_Model, vertices: ^[dynamic]Vertex, indices: ^[dynamic]u16) -> (vbuf: ^sdl.GPUBuffer, ibuf: ^sdl.GPUBuffer) {
	clear(vertices)
	clear(indices)
	for node in model.nodes {
		fmt.println(node.offset_matrix)
		fmt.println(node.translation1)
		fmt.println(node.translation2)
		fmt.println(node.scale)
		fmt.println(node.rotation_angle)
		fmt.println(node.rotation_axis)
		fmt.println(node.rotation_keyframes[:])
		
		for face in node.faces {
			for i in 0..<3 {
				v_idx := face.vertex_position_indices[i]
				t_idx := face.texture_coordinate_indices[i]
				pos := node.vertex_positions[v_idx]
				uv := node.texture_coordinates[t_idx].coordinates
				
				append(vertices, Vertex{
					pos = pos
					// uv = uv,
				})

				append(indices, u16(len(vertices)-1))
			}
		}
	}

	vbuf_info := sdl.GPUBufferCreateInfo{
		usage = sdl.GPUBufferUsageFlags{.VERTEX},
		size = u32(len(vertices) * size_of(vertices[0])),
		props = 0,
	}
	vbuf = sdl.CreateGPUBuffer(device, vbuf_info)
	if vbuf == nil {
		fmt.println("CreateGPUBuffer failed:", sdl.GetError())
		return
	}

	ibuf_info := sdl.GPUBufferCreateInfo{
		usage = sdl.GPUBufferUsageFlags{.INDEX},
		size = u32(len(indices) * size_of(indices[0])),
		props = 0,
	}
	ibuf = sdl.CreateGPUBuffer(device, ibuf_info)
	if ibuf == nil {
		fmt.println("CreateGPUBuffer failed:", sdl.GetError())
		return
	}
	

	{
		setup_cmd := sdl.AcquireGPUCommandBuffer(device)
		if setup_cmd == nil {
			fmt.println("AcquireGPUCommandBuffer failed:", sdl.GetError())
			return
		}
		if !copy_data_to_gpu(device, setup_cmd, vertices[:], vbuf, indices[:], ibuf) {
			_ = sdl.CancelGPUCommandBuffer(setup_cmd)
			return
		}
		if !sdl.SubmitGPUCommandBuffer(setup_cmd) {
			fmt.println("SubmitGPUCommandBuffer (setup) failed:", sdl.GetError())
			return
		}
	}

	return vbuf, ibuf
}

copy_data_to_gpu :: proc(device: ^sdl.GPUDevice, cmd: ^sdl.GPUCommandBuffer, vertices: []Vertex, vert_buf: ^sdl.GPUBuffer, indices: []u16, ind_buf: ^sdl.GPUBuffer) -> bool {
	vert_byte_count := len(vertices) * size_of(vertices[0])
	ind_byte_count := len(indices) * size_of(indices[0])
	tb_info := sdl.GPUTransferBufferCreateInfo{
		usage = .UPLOAD,
		size = u32(vert_byte_count + ind_byte_count),
		props = 0,
	}
	tb := sdl.CreateGPUTransferBuffer(device, tb_info)
	if tb == nil {
		fmt.println("CreateGPUTransferBuffer failed:", sdl.GetError())
		return false
	}
	defer sdl.ReleaseGPUTransferBuffer(device, tb)

	mapped := transmute([^]byte)sdl.MapGPUTransferBuffer(device, tb, false)
	if mapped == nil {
		fmt.println("MapGPUTransferBuffer failed:", sdl.GetError())
		return false
	}
	mem.copy_non_overlapping(mapped, raw_data(vertices), vert_byte_count)
	mem.copy_non_overlapping(mapped[vert_byte_count:], raw_data(indices), ind_byte_count)
	sdl.UnmapGPUTransferBuffer(device, tb)

	cp := sdl.BeginGPUCopyPass(cmd)
	if cp == nil {
		fmt.println("BeginGPUCopyPass failed:", sdl.GetError())
		return false
	}

	vert_src := sdl.GPUTransferBufferLocation{transfer_buffer = tb, offset = 0}
	vert_dst := sdl.GPUBufferRegion{buffer = vert_buf, offset = 0, size = u32(vert_byte_count)}
	sdl.UploadToGPUBuffer(cp, vert_src, vert_dst, false)

	ind_src := sdl.GPUTransferBufferLocation{transfer_buffer = tb, offset = u32(vert_byte_count)}
	ind_dst := sdl.GPUBufferRegion{buffer = ind_buf, offset = 0, size = u32(ind_byte_count)}
	sdl.UploadToGPUBuffer(cp, ind_src, ind_dst, false)
	sdl.EndGPUCopyPass(cp)
	return true
}

GPU_Vertex :: struct {
	position: [3]f32,
	uv: [2]f32,
}

main :: proc() {
	if !sdl.Init(sdl.INIT_VIDEO) {
		fmt.println("SDL init failed:", sdl.GetError())
		return
	}
	defer sdl.Quit()

	window := sdl.CreateWindow("Odin + SDL3 GPU Cubes", 1280, 720, sdl.WINDOW_RESIZABLE)
	if window == nil {
		fmt.println("window create failed:", sdl.GetError())
		return
	}
	defer sdl.DestroyWindow(window)

	device := sdl.CreateGPUDevice(sdl.GPUShaderFormat{.SPIRV}, false, cstring("vulkan"))
	if device == nil {
		fmt.println("CreateGPUDevice failed:", sdl.GetError())
		return
	}
	defer sdl.DestroyGPUDevice(device)

	if !sdl.ClaimWindowForGPUDevice(device, window) {
		fmt.println("ClaimWindowForGPUDevice failed:", sdl.GetError())
		return
	}
	defer sdl.ReleaseWindowFromGPUDevice(device, window)

	driver_name := sdl.GetGPUDeviceDriver(device)
	fmt.println("SDL GPU driver:", string(driver_name))
        if string(driver_name) != "vulkan" {
		fmt.println("expected Vulkan driver, got:", string(driver_name))
		return
	}

	vertex_shader := create_gpu_shader(device, "shaders/cubes.vert.spv", .VERTEX)
	if vertex_shader == nil {
		return
	}
	defer sdl.ReleaseGPUShader(device, vertex_shader)

	fragment_shader := create_gpu_shader(device, "shaders/cubes.frag.spv", .FRAGMENT)
	if fragment_shader == nil {
		return
	}
	defer sdl.ReleaseGPUShader(device, fragment_shader)

	color_format := sdl.GetGPUSwapchainTextureFormat(device, window)
	if color_format == .INVALID {
		fmt.println("invalid swapchain format:", sdl.GetError())
		return
	}

	vb_descs := [1]sdl.GPUVertexBufferDescription{
		{slot = 0, pitch = size_of(Vertex), input_rate = .VERTEX, instance_step_rate = 0},
	}
	vattrs := [1]sdl.GPUVertexAttribute{
		{location = 0, buffer_slot = 0, format = .FLOAT3, offset = 0},
	}

	blend := sdl.GPUColorTargetBlendState{
		src_color_blendfactor = .ONE,
		dst_color_blendfactor = .ZERO,
		color_blend_op = .ADD,
		src_alpha_blendfactor = .ONE,
		dst_alpha_blendfactor = .ZERO,
		alpha_blend_op = .ADD,
		color_write_mask = sdl.GPUColorComponentFlags{.R, .G, .B, .A},
		enable_blend = false,
		enable_color_write_mask = true,
	}
	color_targets := [1]sdl.GPUColorTargetDescription{
		{format = color_format, blend_state = blend},
	}

	pipeline_ci := sdl.GPUGraphicsPipelineCreateInfo{
		vertex_shader = vertex_shader,
		fragment_shader = fragment_shader,
		vertex_input_state = sdl.GPUVertexInputState{
			vertex_buffer_descriptions = &vb_descs[0],
			num_vertex_buffers = 1,
			vertex_attributes = &vattrs[0],
			num_vertex_attributes = 1,
		},
		primitive_type = .TRIANGLELIST,
		rasterizer_state = sdl.GPURasterizerState{
			fill_mode = .FILL,
			cull_mode = .BACK,
			front_face = .COUNTER_CLOCKWISE,
			depth_bias_constant_factor = 0,
			depth_bias_clamp = 0,
			depth_bias_slope_factor = 0,
			enable_depth_bias = false,
			enable_depth_clip = true,
		},
		multisample_state = sdl.GPUMultisampleState{
			sample_count = ._1,
			sample_mask = 0,
			enable_mask = false,
			enable_alpha_to_coverage = false,
		},
		depth_stencil_state = sdl.GPUDepthStencilState{
			compare_op = .LESS,
			back_stencil_state = sdl.GPUStencilOpState{fail_op = .KEEP, pass_op = .KEEP, depth_fail_op = .KEEP, compare_op = .ALWAYS},
			front_stencil_state = sdl.GPUStencilOpState{fail_op = .KEEP, pass_op = .KEEP, depth_fail_op = .KEEP, compare_op = .ALWAYS},
			compare_mask = 0,
			write_mask = 0,
			enable_depth_test = false,
			enable_depth_write = false,
			enable_stencil_test = false,
		},
		target_info = sdl.GPUGraphicsPipelineTargetInfo{
			color_target_descriptions = &color_targets[0],
			num_color_targets = 1,
			depth_stencil_format = .INVALID,
			has_depth_stencil_target = false,
		},
		props = 0,
	}

	pipeline := sdl.CreateGPUGraphicsPipeline(device, pipeline_ci)
	if pipeline == nil {
		fmt.println("CreateGPUGraphicsPipeline failed:", sdl.GetError())
		return
	}
	defer sdl.ReleaseGPUGraphicsPipeline(device, pipeline)

	
	pipeline_create_info := sdl.GPUGraphicsPipelineCreateInfo{
		primitive_type = .TRIANGLELIST,
		rasterizer_state = {
			fill_mode = .LINE,
			cull_mode = .NONE,
		}
	}

	models: [dynamic]RSM_Model

	walk("/home/pavel/neoragnarok_backup/kro_client/data", &models)

	vertices: [dynamic]Vertex
	indices: [dynamic]u16

	vbuf, ibuf := loadModel(device, &models[modelIndex], &vertices, &indices)
	defer sdl.ReleaseGPUBuffer(device, ibuf)
	defer sdl.ReleaseGPUBuffer(device, vbuf)

	init_yaw := rotor_from_axis_angle(Vec3{0, 1, 0}, 0.9)
	init_right := rotate_vec3(init_yaw, Vec3{1, 0, 0})
	init_pitch := rotor_from_axis_angle(init_right, -0.45)

	camera := Camera{
		center = Vec3{0, 0.5, 0},
		distance = 8,
		orientation = rotor_normalize(rotor_mul(init_pitch, init_yaw)),
		fov_deg = 60,
	}

	cubes := []Cube_Instance{
		{pos = Vec3{0, 0, 0}, scale = 1.0, color = Vec3{0.95, 0.45, 0.20}},
		{pos = Vec3{2, 0.5, -1}, scale = 0.8, color = Vec3{0.20, 0.70, 0.95}},
		{pos = Vec3{-2, -0.2, 1.5}, scale = 1.2, color = Vec3{0.85, 0.85, 0.30}},
		{pos = Vec3{1.0, 1.4, 2.0}, scale = 0.6, color = Vec3{0.40, 0.95, 0.60}},
	}

	running := true
	last := time.tick_now()
	left_down := false
	middle_down := false
	debug := Debug_State{}

	for running {
		now := time.tick_now()
		dt := f32(time.duration_seconds(time.tick_diff(last, now)))
		last = now

		event: sdl.Event
		for sdl.PollEvent(&event) {
			#partial switch event.type {
			case .QUIT:
				running = false
			case .MOUSE_BUTTON_DOWN:
				switch event.button.button {
				case sdl.BUTTON_LEFT:
					left_down = true
				case sdl.BUTTON_MIDDLE:
					middle_down = true
				}
			case .MOUSE_BUTTON_UP:
				switch event.button.button {
				case sdl.BUTTON_LEFT:
					left_down = false
				case sdl.BUTTON_MIDDLE:
					middle_down = false
				}
			case .MOUSE_WHEEL:
				camera.distance = math.clamp(camera.distance - event.wheel.y * 0.7, 1.5, 80.0)
			case .KEY_DOWN:
				if event.key.key == sdl.K_ESCAPE {
					running = false
				} else if event.key.scancode == sdl.Scancode.F1 && !event.key.repeat {
					debug.enabled = !debug.enabled
					fmt.println("debug:", debug.enabled)
				} else if event.key.key == sdl.K_N {
					modelIndex += 1
					sdl.ReleaseGPUBuffer(device, ibuf)
					sdl.ReleaseGPUBuffer(device, vbuf)
					vbuf, ibuf = loadModel(device, &models[modelIndex], &vertices, &indices)
				}
			}
		}

		x_rel: f32 = 0
		y_rel: f32 = 0
		_ = sdl.GetRelativeMouseState(&x_rel, &y_rel)

		if left_down {
			yaw_r := rotor_from_axis_angle(Vec3{0, 1, 0}, -x_rel * 0.006)
			q1 := rotor_normalize(rotor_mul(yaw_r, camera.orientation))

			right_axis := vec3_normalize(rotate_vec3(q1, Vec3{1, 0, 0}))
			pitch_r := rotor_from_axis_angle(right_axis, -y_rel * 0.006)
			q2 := rotor_normalize(rotor_mul(pitch_r, q1))

			fwd2 := camera_forward(Camera{center = camera.center, distance = camera.distance, orientation = q2, fov_deg = camera.fov_deg})
			if math.abs(vec3_dot(fwd2, Vec3{0, 1, 0})) < 0.98 {
				camera.orientation = q2
			} else {
				camera.orientation = q1
			}
		}

		if middle_down {
			right := camera_right(camera)
			up := camera_up(camera)
			pan_speed := 0.008 * camera.distance
			camera.center = vec3_add(camera.center, vec3_scale(right, -x_rel * pan_speed))
			camera.center = vec3_add(camera.center, vec3_scale(up, y_rel * pan_speed))
		}

		keys := sdl.GetKeyboardState(nil)
		forward := camera_forward(camera)
		right := camera_right(camera)
		up := camera_up(camera)
		move_speed := camera.distance * dt * 1.4

		if keys[sdl.Scancode.W] {
			camera.center = vec3_add(camera.center, vec3_scale(forward, move_speed))
		}
		if keys[sdl.Scancode.S] {
			camera.center = vec3_add(camera.center, vec3_scale(forward, -move_speed))
		}
		if keys[sdl.Scancode.A] {
			camera.center = vec3_add(camera.center, vec3_scale(right, -move_speed))
		}
		if keys[sdl.Scancode.D] {
			camera.center = vec3_add(camera.center, vec3_scale(right, move_speed))
		}

		if debug.enabled {
			debug.accum += dt
			if debug.accum >= 0.2 {
				debug.accum = 0
				eye := camera_position(camera)
				fmt.println("cam eye:", eye,
					"center:", camera.center,
					"fwd:", forward,
					"right:", right,
					"up:", up)
			}
		}

		w: c.int = 0
		h: c.int = 0
		sdl.GetWindowSize(window, &w, &h)
		if w <= 0 || h <= 0 {
			continue
		}

		cmd := sdl.AcquireGPUCommandBuffer(device)
		if cmd == nil {
			fmt.println("AcquireGPUCommandBuffer failed:", sdl.GetError())
			break
		}

		swap_tex: ^sdl.GPUTexture
		swap_w: sdl.Uint32 = 0
		swap_h: sdl.Uint32 = 0
		if !sdl.WaitAndAcquireGPUSwapchainTexture(cmd, window, &swap_tex, &swap_w, &swap_h) {
			fmt.println("WaitAndAcquireGPUSwapchainTexture failed:", sdl.GetError())
			_ = sdl.CancelGPUCommandBuffer(cmd)
			break
		}

		if swap_tex == nil {
			if !sdl.SubmitGPUCommandBuffer(cmd) {
				fmt.println("SubmitGPUCommandBuffer failed:", sdl.GetError())
				break
			}
			continue
		}

		clear := sdl.FColor{0.08, 0.09, 0.12, 1.0}
		cti := sdl.GPUColorTargetInfo{
			texture = swap_tex,
			mip_level = 0,
			layer_or_depth_plane = 0,
			clear_color = clear,
			load_op = .CLEAR,
			store_op = .STORE,
			resolve_texture = nil,
			resolve_mip_level = 0,
			resolve_layer = 0,
			cycle = false,
			cycle_resolve_texture = false,
		}

		rp := sdl.BeginGPURenderPass(cmd, &cti, 1, nil)
		if rp == nil {
			fmt.println("BeginGPURenderPass failed:", sdl.GetError())
			_ = sdl.CancelGPUCommandBuffer(cmd)
			break
		}

		vp := sdl.GPUViewport{x = 0, y = 0, w = f32(swap_w), h = f32(swap_h), min_depth = 0, max_depth = 1}
		sdl.SetGPUViewport(rp, vp)
		sdl.BindGPUGraphicsPipeline(rp, pipeline)
		vb_binding := sdl.GPUBufferBinding{buffer = vbuf, offset = 0}
		sdl.BindGPUVertexBuffers(rp, 0, &vb_binding, 1)
		ib_binding := sdl.GPUBufferBinding{buffer = ibuf, offset = 0}
		sdl.BindGPUIndexBuffer(rp, ib_binding, ._16BIT)

		aspect := f32(swap_w) / f32(swap_h)
		proj := linalg.matrix4_perspective(camera.fov_deg, aspect, 0.1, 300.0)
		view := linalg.matrix4_look_at(camera_position(camera), camera.center, camera_up(camera))
		vp_mat := proj * view

		for node in models[modelIndex].nodes {
			rotation := linalg.quaternion_angle_axis(node.rotation_angle, node.rotation_axis)
			if (len(node.rotation_keyframes) > 0) {
				q := node.rotation_keyframes[0].quaternion
				rotation = quaternion(imag=q[0], jmag=q[1], kmag=q[2], real=q[3])
			}

			rotation = linalg.quaternion_normalize(rotation)

			r := linalg.matrix3_from_quaternion(rotation)

			s := matrix[3,3]f32{
				node.scale[0], 0,        0       ,
				0,        node.scale[1], 0       ,
				0,        0,        node.scale[2],
			}

			a3 := r * node.offset_matrix * s

			t := node.translation1 + node.translation2

			// 4x4 affine matrix
			model := matrix[4,4]f32{
				a3[0][0], a3[0][1], a3[0][2], t[0],
				a3[1][0], a3[1][1], a3[1][2], t[1],
				a3[2][0], a3[2][1], a3[2][2], t[2],
				0,        0,        0,        1   ,
			}

			
			// append(vertices, Vertex{
			// 	pos = linalg.matrix3_from_quaternion(rotation) * node.offset_matrix * (node.scale * pos) + node.translation1 + node.translation2
			// 	// uv = uv,
			// })

			// model := mat4_mul(node., mat4_scale_uniform(1))
			
			pc := Push_Constants{}
			pc.mvp = vp_mat * model
			pc.color = [4]f32{1, 0, 0, 1.0}
			sdl.PushGPUVertexUniformData(cmd, 0, &pc, u32(size_of(Push_Constants)))
			sdl.PushGPUFragmentUniformData(cmd, 0, &pc, u32(size_of(Push_Constants)))
			sdl.DrawGPUIndexedPrimitives(rp, u32(len(indices)), 1, 0, 0, 0)
		}

		sdl.EndGPURenderPass(rp)

		if !sdl.SubmitGPUCommandBuffer(cmd) {
			fmt.println("SubmitGPUCommandBuffer failed:", sdl.GetError())
			break
		}
	}

	_ = sdl.WaitForGPUIdle(device)
}

walk :: proc(dir: string, models: ^[dynamic]RSM_Model) {
	f, _ := os.open(dir)
	entries, ok := os.read_dir(f, 0, context.allocator)
	for entry in entries {
		path, _ := filepath.join({dir, entry.name})
		if entry.type == .Directory {
			walk(path, models)
		}
		if strings.contains(entry.name, ".rsm") {
			data, _ := os.read_entire_file(path, context.allocator)
			parsed, err := parse_rsm(data)
			if err != nil {
				fmt.printfln("%v", err)
			} else {
				append_elem(models, parsed)
			}
		}
	}
}