; In order to call stbir_resize_float
;  I pass input_pixels in RDI, input_w in RSI, input_h in RDX, input_stride_in_bytes in RCX,
;   output_pixels in r8, output_w in r9
; For the stack:
;  From where RBP points to, there are first the previous RBP value, and then the return address
;  Then there is the first parameter, then the second, and so on

%include "linux_syscalls.s"
%include "linux_platform.s"
%include "render.s"
%include "string.s"

%define KB(x) (x * 1024)
%define MB(x) (KB(x) * 1024)

struc input_action_struct
    .is_down:               resb 1
    .was_down:              resb 1
endstruc
struc input_struct
    .move_left:             resb 2
    .move_right:            resb 2
    .toggle_editor:         resb 2
    .toggle_brick:          resb 2
    .start_round:           resb 2
endstruc
struc editor_struct
    .is_enabled:            resb 1
    .pad0:                  resb 7
    .selected_grid_cell:    resd 1
endstruc
struc grid_struct
    .num_x:resd 1
    .num_y:resd 1
    .size_x:resd 1
    .size_y:resd 1
    .pos_x:resd 1
    .pos_y:resd 1
    .bounds_x:resd 1
    .bounds_y:resd 1
    .data_x:resq 1
    .data_y:resq 1
    .data_visual:resq 1
    .data_color:resq 1
    .data_block:resq 1
endstruc
struc input_event_struct
    .time:  resq    2
    .type:  resw    1
    .code:  resw    1
    .value: resd    1
endstruc
struc buffer_struct
    .base:  resq    1
    .used:  resd    1
    .max:   resd    1
endstruc
struc image_data_struct
    .data:   resq       1
    .width:  resd       1
    .height: resd       1
    .type:   resb       1
    .image_data_struct_pad0 resb 7
endstruc

SECTION .text
    global _start
; rdi = float * input_pixels, esi = int input_w, edx = int input_ha, ecx = input_stride_in_bytes
; r8  = float * output_pixels, r9d = int output_w
; push on stack: int num_channels, int output_stride_in_bytes, int output_h
extern stbir_resize_float

; rdi = u64 idx
; xmm0 = rect_struct
grid_rect_from_idx:
    push rbp
    mov rbp, rsp

    mov rsi, [g_grid + grid_struct.data_x]
    mov eax, [rsi + rdi * 4]
    mov [rbp - 16], eax
    mov rsi, [g_grid + grid_struct.data_y]
    mov eax, [rsi + rdi * 4]
    mov [rbp - 12], eax
    mov eax, [g_grid + grid_struct.size_x]
    mov [rbp -  8], eax
    mov eax, [g_grid + grid_struct.size_y]
    mov [rbp -  4], eax
    movups xmm0, [rbp - 16]
    cvtdq2ps xmm0, xmm0

    pop rbp
    ret
; rdi = u8 *ptr, rsi = u8 val, rdx = u64 len
memset:
    mov rcx, rdx
    mov rax, rsi
    rep stosb
    ret
; rdi = char *filename, rsi = struc buffer_struc *mem
; rax = void *memory, rbx = u64 size
load_entire_file_to_memory:
    push rbp
    mov rbp, rsp
    sub rsp, 128

    mov r12d, [rsi + buffer_struct.used]
    mov r14, [rsi + buffer_struct.base]
    lea r14, [r14 + r12]
    mov r13, [rsi + buffer_struct.max]
    call platform_get_filesize
    add r12, rax
    cmp r12, r13
    jge load_entire_file_to_memory_error_not_enough_memory
    mov [rsi + buffer_struct.used], r12d
    mov r12, rax ; r12 = filesize
    mov rsi, PLATFORM_OPEN_READ
    call platform_open
    assert rax,jg,0
    mov r13, rax; r13 = FD
    mov rdi, r13
    mov rsi, r14
    mov rdx, r12
    call read
    assert rax,jge,0
    mov rbx, r12
    mov rax, r14

    add rsp, 128
    pop rbp
    ret
load_entire_file_to_memory_error_not_enough_memory:
    int3

; rdi = char *filename, rsi = struc buffer_struc *mem
; rax = void *memory, rbx = u32 width, rcx = u32 height
load_entire_farbfeld_to_memory:
    push rbp
    mov rbp, rsp
    sub rsp, 128

    ; Just allocate enough, so that it won't be an issue
    mov [rbp - 28], rsi
    mov eax, [rsi + buffer_struct.used]
    mov [rbp - 20], eax
    add eax, MB(40)
    mov [rsi + buffer_struct.used], eax
    mov rax, [rsi + buffer_struct.base]
    mov [rbp - 8], rax
    call load_entire_file_to_memory
    ; rbx is set as size now
    mov rsi, rax
    mov rax, [rsi + 8] ; r8 is height + width
    mov rbx, rax
    shr rbx, 32
    mov eax, eax
    bswap eax
    bswap ebx
    mov [rbp - 12], eax ; [rbp - 12] is width
    mov [rbp - 16], ebx ; [rbp - 16] is height
    add rsi, 16 ; rsi now points to beginning of data

    movaps xmm1, [g_move_16_to_32_shift_mask_1]; xmm1 is now our first mask
    movaps xmm2, [g_move_16_to_32_shift_mask_2]; xmm2 is now our first mask

    mov rax, [rbp - 12]
    mov rbx, [rbp - 16]
    xor rdx, rdx
    mul rbx
    shl rax, 3 ; multiply by 8, as in RGBA * 2
    mov rbx, rax

    mov rdi, [rbp - 8]
    xor rdx, rdx
    xor rcx, rcx
    movaps xmm0, [g_divisor]
    cvtdq2ps xmm0, xmm0
load_entire_farbfeld_to_memory_loop_begin:
    movups xmm4, [rsi + rdx] ; We read 128 bits = 16 bytes
    ;movaps xmm4, [g_temp_128]
    movaps xmm5, xmm4
    ; 16 bytes is twice RGBA

    add rdx, 16
    pshufb xmm4, xmm1
    pshufb xmm5, xmm2
    cvtdq2ps xmm4, xmm4
    cvtdq2ps xmm5, xmm5
    divps xmm4, xmm0
    divps xmm5, xmm0
    movups [rdi + rcx], xmm4
    add rcx, 16
    movups [rdi + rcx], xmm5
    add rcx, 16

    cmp rdx, rbx
    jl load_entire_farbfeld_to_memory_loop_begin

    mov rax, rsi
    mov rsi, [rbp - 28]
    mov [rsi + buffer_struct.used], ecx

    mov rbx, [rbp - 12]
    mov rcx, [rbp - 16]

    add rsp, 128
    pop rbp
    ret
; rdi = image_data_struct *data, rsi = struct buffer_struc *mem
; rax = image_data_struct *new
convert_image_data_f32_to_u8:
    push rbp
    mov rbp, rsp
    sub rsp, 128

    mov al, [rdi + image_data_struct.type]
    assert al,je,IMAGE_DATA_F32
    mov eax, [rdi + image_data_struct.width]
    mov ebx, [rdi + image_data_struct.height]
    mul ebx
    shl rax, 2
    mov [rbp - 8], rax ; [rbp - 8] is now width * height * 4
    mov [rbp - 16], rdi

    ; TODO allocate space for the image_data_struc and the image data
    mov eax, [rsi + buffer_struct.used]
    mov rcx, [rsi + buffer_struct.base]
    add rcx, rax
    mov [rbp - 24], rcx ; [rbp - 24] is now NEW image_data_struct
    mov ebx, [rsi + buffer_struct.max]
    add rax, image_data_struct_size
    add rax, [rbp - 8] ; RAX is now the new used amount
    cmp rax, rbx
    jl convert_image_data_f32_to_u8_space_is_available
    int3 ; Space is NOT available
convert_image_data_f32_to_u8_space_is_available:
    mov [rsi + buffer_struct.used], eax
    mov rsi, [rbp - 24]
    mov rbx, rsi
    add rbx, image_data_struct_size
    mov [rsi + image_data_struct.data], rbx
    mov byte [rsi + image_data_struct.type], IMAGE_DATA_U8
    mov eax, [rdi + image_data_struct.width]
    mov [rsi + image_data_struct.width], eax
    mov eax, [rdi + image_data_struct.height]
    mov [rsi + image_data_struct.height], eax
    mov rsi, rbx ; RSI now points to beginning of new data
    mov rdi, [rdi + image_data_struct.data] ; RDI now points to beginning of old data

    movaps xmm0, [g_multiplicant] ; xmm0 is now multiplicant
    cvtdq2ps xmm0, xmm0
    movaps xmm1, [g_move_32_to_8_shift_mask] ; xmm1 is now mask

    xor rdx, rdx
    xor rcx, rcx
convert_image_data_f32_to_u8_loop_begin:
    movups xmm2, [rdi + rdx + 0]
    movups xmm3, [rdi + rdx + 16]
    movups xmm4, [rdi + rdx + 32]
    movups xmm5, [rdi + rdx + 48]
    add rdx, 64 ; 16 * 4 = 64
    mulps xmm2, xmm0
    mulps xmm3, xmm0
    mulps xmm4, xmm0
    mulps xmm5, xmm0
    cvttps2dq xmm2, xmm2
    cvttps2dq xmm3, xmm3
    cvttps2dq xmm4, xmm4
    cvttps2dq xmm5, xmm5
    pshufb xmm2, xmm1
    pshufb xmm3, xmm1
    pshufb xmm4, xmm1
    pshufb xmm5, xmm1
    psrldq xmm3, 4
    psrldq xmm4, 8
    psrldq xmm5, 12
    por xmm2, xmm3
    por xmm2, xmm4
    por xmm2, xmm5
    ; xmm2 is now packed 8bit RGBA
    movdqu [rsi + rcx], xmm2
    add rcx, 16 ; There are 16 8 bit values in 128 bit

    cmp rcx, r8
    jl convert_image_data_f32_to_u8_loop_begin

    mov rax, [rbp - 24]
    add rsp, 128
    pop rbp
    ret
; rdi = u8 *dst, rsi = u8 *src, rdx = u64 len
memcpy:
    mov rcx, rdx
    rep movsb
    ret
_start:
    mov byte [g_running], 1
    mov byte [g_input_thread_running], 1
    ; 16 bit align rsp
    mov rax, 16
    sub rsp, rax
    neg rax
    and rsp, rax

    rdtsc
    shl rdx, 4
    or rax, rdx
    mov [g_begin_time], rax

    mov rdi, g_keyboard_device_path
    mov rsi, PLATFORM_OPEN_READ
    call platform_open
    assert rax,jge,0
    mov [g_keyboard_device],eax

    mov rdi, 1280
    mov rsi, 720
    mov [render_width], rdi
    mov [render_height], rsi
    ;call platform_init_visuals

    ; xsize * ysize * 32
    ;mov ecx, dword [g_platform_visual_info + xsize]
    ;mov eax, dword [g_platform_visual_info + ysize]
    mov rcx, rdi
    mov rax, rsi
    ; We assume that we aren't overflowing 32 bit
    mul ecx
    mov ecx, 4
    mul ecx
    mov [g_buffer_size], rax
    mov r15, rax ; TODO(ian): check if rdi can be changed by the linux standard

    mov rbx, 0xF
    add rax, rbx
    neg rbx
    and rax, rbx ; 16 bit align rax
    mov [g_memory + buffer_struct.used],  rax
    add rax, MB(80)
    mov [g_memory + buffer_struct.max],   eax
    mov rdi, rax
    call platform_alloc
    assert rax,jg,0
    mov [g_memory + buffer_struct.base], rax
    mov [g_backbuffer], rax
    mov rdi, rax
    mov rsi, 0x0
    mov edx, [g_memory + buffer_struct.max]

    ; SETUP GRID
    ; GRID MEMORY
    mov eax, [g_grid + grid_struct.num_x]
    mov ebx, [g_grid + grid_struct.num_y]
    mul rbx
    mov ebx, [g_memory + buffer_struct.used]
    mov rdi, [g_memory + buffer_struct.base]
    xor rcx, rcx
    lea rdi, [rdi + rbx]
    mov [g_grid + grid_struct.data_x], rdi
    lea rcx, [rcx + rax*4]
    lea rdi, [rdi + rax*4]
    mov [g_grid + grid_struct.data_y], rdi
    lea rcx, [rcx + rax*4]
    lea rdi, [rdi + rax*4]
    mov [g_grid + grid_struct.data_visual], rdi
    lea rcx, [rcx + rax*4]
    lea rdi, [rdi + rax*4]
    mov [g_grid + grid_struct.data_color], rdi
    lea rcx, [rcx + rax*8]
    lea rcx, [rcx + rax*8]
    lea rdi, [rdi + rax*8]
    lea rdi, [rdi + rax*8]
    mov [g_grid + grid_struct.data_block], rdi
    lea rcx, [rcx + rax*4]
    lea rdi, [rdi + rax*4]
    add ebx, ecx
    mov [g_memory + buffer_struct.used], ebx
    ; GRID SIZE
    xor rdx, rdx
    mov eax, [g_grid + grid_struct.bounds_x]
    mov ebx, [g_grid + grid_struct.num_x]
    div rbx
    xor rdx, rdx
    mov [g_grid + grid_struct.size_x], eax
    mov eax, [g_grid + grid_struct.bounds_y]
    mov ebx, [g_grid + grid_struct.num_y]
    div rbx
    mov [g_grid + grid_struct.size_y], eax
    ; SET GRID MEMORY
    xor rcx, rcx ; Data iterator
    xor rdx, rdx
    mov eax, [g_grid + grid_struct.pos_x]
    mov rdi, [g_grid + grid_struct.data_x]
.GRID_SETUP_LOOP_X:
    lea rsi, [rdi + rcx * 4]
    mov [rsi], eax
    add eax, [g_grid + grid_struct.size_x]
    inc rcx
    inc rdx
    cmp edx, [g_grid + grid_struct.num_x]
    jl .GRID_SETUP_LOOP_X_DONT_BREAK
    xor rdx, rdx
    xor rax, rax
.GRID_SETUP_LOOP_X_DONT_BREAK:
    ;cmp rcx, [g_grid + grid_struct.num_x]
    cmp rcx, [rsp - 8]
    jl .GRID_SETUP_LOOP_X
    xor rcx, rcx
    xor rdx, rdx
    mov eax, [g_grid + grid_struct.pos_y]
    mov rdi, [g_grid + grid_struct.data_y]
.GRID_SETUP_LOOP_Y:
    lea rsi, [rdi + rcx * 4]
    mov [rsi], eax
    inc rcx
    inc rdx
    cmp edx, [g_grid + grid_struct.num_x]
    jl .GRID_SETUP_LOOP_Y_DONT_BREAK
    add eax, [g_grid + grid_struct.size_y]
    xor rdx, rdx
.GRID_SETUP_LOOP_Y_DONT_BREAK:
    cmp rcx, [rsp - 8]
    jl .GRID_SETUP_LOOP_Y
    xor rcx, rcx
.GRID_SETUP_LOOP_COLOR:
    mov edi, 0x00FF00FF
    call byte_color_to_floating_point
    mov rsi, [g_grid + grid_struct.data_color]
    lea rsi, [rsi + rcx*8]
    lea rsi, [rsi + rcx*8]
    movups [rsi], xmm0
    inc rcx
    cmp rcx, [rsp - 8]
    jl .GRID_SETUP_LOOP_COLOR

    mov rdi, g_filename
    mov rsi, g_memory
    call load_entire_farbfeld_to_memory
    mov [g_test_image_f32 + image_data_struct.data],        rax
    mov [g_test_image_f32 + image_data_struct.width],       ebx
    mov [g_test_image_f32 + image_data_struct.height],      ecx
    mov byte [g_test_image_f32 + image_data_struct.type],   IMAGE_DATA_F32

    mov r10, rax
    mov rax, rbx
    mul rcx
    shl rax, 4

    mov r14, rax
    mov rdi, g_f32_filename
    mov rsi, PLATFORM_OPEN_WRITE
    call platform_open
    mov rdx, r14
    mov rdi, rax
    mov rsi, r10
    call write
    call close

    mov rdi, g_test_image_f32
    mov rsi, g_memory
    call convert_image_data_f32_to_u8
    mov [g_test_image_u8_ptr], rax

    mov rdi, g_u8_filename
    mov rsi, PLATFORM_OPEN_WRITE
    call platform_open
    mov rdi, rax
    mov rbp, [g_test_image_u8_ptr]
    mov rsi, [rbp + image_data_struct.data]
    mov eax, [rbp + image_data_struct.width]
    mov edx, [rbp + image_data_struct.height]
    mul rdx
    shl rax, 2
    mov rdx, rax
    call write
    call close

    mov rdi, g_frontbuffer_file
    mov rsi, PLATFORM_OPEN_RW
    call platform_open
    mov r8, rax
    mov rdi, rax
    mov rsi, r15
    call ftruncate
    mov rdi, r15
    ;mov esi, dword [g_platform_visual_info + fbdev]
    mov rsi, r8
    call platform_alloc_file
    mov [g_frontbuffer], rax
    assert rax,jg,0

    mov rdi, [g_backbuffer]
    mov rsi, 0x0
    mov rdx, r15
    call memset
    mov rdi, [g_frontbuffer]
    mov rsi, 0x30
    mov rdx, r15
    call memset

    ;mov eax, [g_player_rect + rect_struct.x]
    mov dword [rsp - 16], 10 ; x
    mov dword [rsp - 12], 560 ; y
    mov dword [rsp - 8], 64 ; width
    mov dword [rsp - 4], 32 ; height
    movdqa xmm0, [rsp - 16]
    cvtdq2ps xmm0, xmm0
    movdqa [g_player_rect], xmm0

    mov eax, [g_ball_start_pos]
    mov dword [rsp - 16], eax
    mov eax, [g_ball_start_pos + 4]
    mov dword [rsp - 12], eax
    mov dword [rsp - 8],  16
    mov dword [rsp - 4],  16
    movups xmm0, [rsp - 16]
    cvtdq2ps xmm0, xmm0
    movaps [g_ball_rect], xmm0

    xorps xmm0, xmm0
    xorps xmm1, xmm1
    mov dword [rsp - 8], 0x1
    mov dword [rsp - 4], 0x0
    movlps xmm0, [rsp - 8]
    mov dword [rsp - 8], 60
    mov dword [rsp - 4], 0x0
    movlps xmm1, [rsp - 8]
    divss xmm0, xmm1
    movlps [rsp - 8], xmm0
    mov eax, [rsp - 8]
    mov [g_fixed_delta_time_sec], eax

.L0:
    lea rdi, [g_frame_start_time]
    call platform_gettime

    mov byte [g_input + input_struct.move_left + input_action_struct.was_down], 0
    mov byte [g_input + input_struct.move_right + input_action_struct.was_down], 0
    mov byte [g_input + input_struct.toggle_editor + input_action_struct.was_down], 0
    mov byte [g_input + input_struct.toggle_brick + input_action_struct.was_down], 0
    mov byte [g_input + input_struct.start_round + input_action_struct.was_down], 0

    mov rdi, [g_keyboard_device]
    mov [rsp - 8], edi
    mov word [rsp - 4], POLLIN
    lea rdi, [rsp - 8]
    mov rsi, 1
    xor rdx, rdx
    call poll
    cmp rax, 0
    je .DONE_WITH_INPUT_POLLING
    jl .poll_error

    mov rdi, [g_keyboard_device]
    mov rax, 64
    mov rcx, input_event_struct_size
    mul rcx
    mov rdx, rax
    mov r13, rax

    sub rsp, r13
    mov rsi, rsp
    call read
    xor rdx, rdx
    mov rcx, input_event_struct_size
    div rcx
    mov r14, rax ; r14 is the number of events

    mov rbp, rsp
    xor rcx, rcx
.L1:
    xor rax, rax
    mov ax, [rbp + input_event_struct.type]
    cmp ax, EV_SYN
    je .SYN
    cmp ax, EV_KEY
    je .KEY
    jmp .L2
.SYN:
    jmp .L2
.KEY:
    xor rax, rax
    mov ax, [rbp + input_event_struct.code]
    mov ebx, [rbp + input_event_struct.value]
    mov rdi, 0
    cmp rax, KEY_LEFT
    je .KEY_LEFT
    cmp rax, KEY_RIGHT
    je .KEY_RIGHT
    cmp rax, KEY_E
    je .KEY_E
    cmp rax, KEY_R
    je .KEY_R
    cmp rax, KEY_SPACE
    je .KEY_SPACE
    jmp .L2
.KEY_LEFT:
    cmp rbx, 0
    je .KEY_LEFT_UP
    mov byte [g_input + input_struct.move_left + input_action_struct.is_down], 0xFF
    jmp .L2
.KEY_LEFT_UP:
    xor rax, rax
    mov al, [g_input + input_struct.move_left + input_action_struct.is_down]
    mov byte [g_input + input_struct.move_left + input_action_struct.was_down], al
    mov byte [g_input + input_struct.move_left + input_action_struct.is_down], 0x0
    jmp .L2
.KEY_RIGHT:
    cmp rbx, 0
    je .KEY_RIGHT_UP
    mov byte [g_input + input_struct.move_right + input_action_struct.is_down], 0xFF
    jmp .L2
.KEY_RIGHT_UP:
    xor rax, rax
    mov al,  [g_input + input_struct.move_right + input_action_struct.is_down]
    mov byte [g_input + input_struct.move_right + input_action_struct.was_down], al
    mov byte [g_input + input_struct.move_right + input_action_struct.is_down], 0x0
    jmp .L2
.KEY_E:
    cmp rbx, 0
    je .KEY_E_UP
    mov byte [g_input + input_struct.toggle_editor + input_action_struct.is_down], 0xFF
    jmp .L2
.KEY_E_UP:
    xor rax, rax
    mov al,  [g_input + input_struct.toggle_editor + input_action_struct.is_down]
    mov byte [g_input + input_struct.toggle_editor + input_action_struct.was_down], al
    mov byte [g_input + input_struct.toggle_editor + input_action_struct.is_down], 0x0
    jmp .L2
.KEY_R:
    cmp rbx, 0
    je .KEY_R_UP
    mov byte [g_input + input_struct.toggle_brick + input_action_struct.is_down], 0xFF
    jmp .L2
.KEY_R_UP:
    xor rax, rax
    mov al,  [g_input + input_struct.toggle_brick + input_action_struct.is_down]
    mov byte [g_input + input_struct.toggle_brick + input_action_struct.was_down], al
    mov byte [g_input + input_struct.toggle_brick + input_action_struct.is_down], 0x0
    jmp .L2
.KEY_SPACE:
    cmp rbx, 0
    je .KEY_SPACE_UP
    mov byte [g_input + input_struct.start_round + input_action_struct.is_down], 0xFF
    jmp .L2
.KEY_SPACE_UP:
    xor rax, rax
    mov al,  [g_input + input_struct.start_round + input_action_struct.is_down]
    mov byte [g_input + input_struct.start_round + input_action_struct.was_down], al
    mov byte [g_input + input_struct.start_round + input_action_struct.is_down], 0x0
    jmp .L2
.L2:
    inc rcx
    add rbp, input_event_struct_size
    cmp rcx, r14
    jl .L1
    add rsp, r13

.DONE_WITH_INPUT_POLLING:

    xor rax, rax
    mov al, [g_input + input_struct.toggle_editor + input_action_struct.is_down]
    not al
    and al, [g_input + input_struct.toggle_editor + input_action_struct.was_down]
    cmp al, 0x0
    je .EDITOR_NO_TOGGLE
    xor rax, rax
    mov al, [g_editor + editor_struct.is_enabled]
    not al
    mov [g_editor + editor_struct.is_enabled], al
.EDITOR_NO_TOGGLE:

    mov al, [g_editor + editor_struct.is_enabled]
    cmp al, 0x0
    jne .EDITOR_ENABLED_0

    xor rax, rax
    mov al, [g_input + input_struct.start_round + input_action_struct.is_down]
    not al
    and al, [g_input + input_struct.start_round + input_action_struct.was_down]
    and al, 0x1
    cmp al, 0x0
    je .DONT_START_ROUND
    xorps xmm0, xmm0
    mov dword [rsp - 8], 0x4
    mov dword [rsp - 4], -0x4
    movlps xmm0, [rsp - 8]
    cvtdq2ps xmm0, xmm0
    movlps [g_ball_vel], xmm0
.DONT_START_ROUND:

    movaps xmm0, [g_player_rect]
    xor rax, rax
    mov byte al, [g_input + input_struct.move_left + input_action_struct.is_down]
    shr rax, 4
    movd xmm1, eax
    cvtdq2ps xmm1, xmm1
    subps xmm0, xmm1

    xor rax, rax
    mov byte al, [g_input + input_struct.move_right + input_action_struct.is_down]
    shr rax, 4
    movd xmm1, eax
    cvtdq2ps xmm1, xmm1
    addps xmm0, xmm1

    xorps xmm1, xmm1
    movhlps xmm1, xmm0
    movups [rsp - 16], xmm1
    mov dword [rsp - 12], 0x0
    mov dword [rsp -  8], 0x0
    mov dword [rsp -  4], 0x0
    movups xmm1, [rsp - 16]
    movaps xmm2, xmm0
    addps xmm2, xmm1
    movups [rsp - 20], xmm0
    movups [rsp - 16], xmm2
    mov dword [rsp - 12], 0x0
    mov dword [rsp -  8], 0x0
    movups xmm1, [rsp - 20]
    mov dword [rsp - 16], 0x0
    mov eax, [render_width]
    mov [rsp - 12], eax
    mov dword [rsp -  8], 0x0
    mov dword [rsp -  4], 0x0
    movups xmm2, [rsp - 16]
    cvtdq2ps xmm2, xmm2
    cmpps xmm2, xmm1, 0xE
    movups [rsp - 16], xmm2
    cmp dword [rsp - 16], 0x0
    je .PLAYER_BOUNDS_X1_OK
    movups [rsp - 32], xmm0
    mov dword [rsp - 32], 0x0
    movups xmm0, [rsp - 32]
.PLAYER_BOUNDS_X1_OK:
    cmp dword [rsp - 12], 0x0
    jne .PLAYER_BOUNDS_X2_OK
    xorps xmm1, xmm1
    movlhps xmm1, xmm0
    addps xmm1, xmm0
    mov dword [rsp - 16], 0x0
    mov dword [rsp - 12], 0x0
    mov eax, [render_width]
    mov dword [rsp -  8], eax
    mov dword [rsp -  6], 0x0
    movups xmm2, [rsp - 16]
    cvtdq2ps xmm2, xmm2
    subps xmm1, xmm2
    movups [rsp - 16], xmm1
    mov eax, [rsp - 8]
    mov dword [rsp - 16], eax
    mov dword [rsp - 12], 0x0
    mov dword [rsp -  8], 0x0
    mov dword [rsp -  4], 0x0
    movups xmm1, [rsp - 16]
    subps xmm0, xmm1
.PLAYER_BOUNDS_X2_OK:

    movaps [g_player_rect], xmm0

    xorps xmm0, xmm0
    movlps xmm0, [g_ball_vel]
    movaps xmm1, [g_ball_rect]
    addps xmm1, xmm0
    movaps xmm0, xmm1
    xorps xmm2, xmm2
    movlhps xmm2, xmm0
    addps xmm0, xmm2 ; XMM0 is now in quad form
    mov dword [rsp - 16], 0x0
    mov dword [rsp - 12], 0x0
    mov eax, [render_width]
    mov dword [rsp -  8], eax
    mov eax, [render_height]
    mov dword [rsp -  4], eax
    movups xmm2, [rsp - 16]
    cvtdq2ps xmm2, xmm2
    cmpps xmm2, xmm0, 0xE ; XMM2 > XMM0
    movups [rsp - 16], xmm2
    mov eax, [rsp - 16]
    cmp eax, 0x0
    je .BALL_SCREEN_BOUNDS_X1_OK
    movups xmm1, [g_ball_rect]
    movlps xmm3, [g_ball_vel]
    xorps xmm4, xmm4
    mov dword [rsp - 24], -1
    mov dword [rsp - 20],  1
    movlps xmm4, [rsp - 24]
    cvtdq2ps xmm4, xmm4
    mulps xmm3, xmm4
    movlps [g_ball_vel], xmm3 ; x value of ball velocity has been negated
.BALL_SCREEN_BOUNDS_X1_OK:
    mov eax, [rsp - 12]
    cmp eax, 0x0
    je .BALL_SCREEN_BOUNDS_Y1_OK
    movups xmm1, [g_ball_rect]
    movlps xmm3, [g_ball_vel]
    xorps xmm4, xmm4
    mov dword [rsp - 24],  1
    mov dword [rsp - 20], -1
    movlps xmm4, [rsp - 24]
    cvtdq2ps xmm4, xmm4
    mulps xmm3, xmm4
    movlps [g_ball_vel], xmm3 ; x value of ball velocity has been negated
.BALL_SCREEN_BOUNDS_Y1_OK:
    mov eax, [rsp -  8]
    cmp eax, 0x0
    jne .BALL_SCREEN_BOUNDS_X2_OK
    movups xmm1, [g_ball_rect]
    movlps xmm3, [g_ball_vel]
    xorps xmm4, xmm4
    mov dword [rsp - 24], -1
    mov dword [rsp - 20],  1
    movlps xmm4, [rsp - 24]
    cvtdq2ps xmm4, xmm4
    mulps xmm3, xmm4
    movlps [g_ball_vel], xmm3 ; x value of ball velocity has been negated
.BALL_SCREEN_BOUNDS_X2_OK:
    mov eax, [rsp -  4]
    cmp eax, 0x0
    jne .BALL_SCREEN_BOUNDS_Y2_OK
    movups xmm1, [g_ball_rect]
    movlps xmm3, [g_ball_vel]
    xorps xmm4, xmm4
    mov dword [rsp - 24],  1
    mov dword [rsp - 20], -1
    movlps xmm4, [rsp - 24]
    cvtdq2ps xmm4, xmm4
    mulps xmm3, xmm4
    movlps [g_ball_vel], xmm3 ; x value of ball velocity has been negated
.BALL_SCREEN_BOUNDS_Y2_OK:

    movaps [g_ball_rect], xmm1

.EDITOR_ENABLED_0:
    mov rax, [g_test_image_u8_ptr]
    mov rax, [rax + image_data_struct.data]
    mov rdi, [g_backbuffer]
    mov rsi, rax
    mov rdx, [g_buffer_size]
    call memcpy

    mov edi, 0x0000FFFF
    call byte_color_to_floating_point
    movaps xmm1, xmm0
    movaps xmm0, [g_player_rect]
    mov rdx, [g_backbuffer]
    mov ecx, 0x2
    call render_color_rect

    lea rdi, [g_grid]
    mov rsi, [g_backbuffer]
    call render_grid

    mov al, [g_editor + editor_struct.is_enabled]
    cmp al, 0x0
    je .EDITOR_DISABLED_0

    xor rax, rax
    mov al, [g_input + input_struct.move_right + input_action_struct.is_down]
    not al
    and al, [g_input + input_struct.move_right + input_action_struct.was_down]
    and al, 0x1
    mov edi, [g_editor + editor_struct.selected_grid_cell]
    mov ecx, edi
    add edi, eax
    mov eax, [g_grid + grid_struct.num_x]
    mov ebx, [g_grid + grid_struct.num_y]
    mul ebx
    cmp edi, eax
    cmovb ecx, edi
    mov [g_editor + editor_struct.selected_grid_cell], ecx

    xor rax, rax
    mov al, [g_input + input_struct.move_left + input_action_struct.is_down]
    not al
    and al, [g_input + input_struct.move_left + input_action_struct.was_down]
    and al, 0x1
    mov edi, [g_editor + editor_struct.selected_grid_cell]
    mov ecx, edi
    sub edi, eax
    cmp edi, 0x0
    cmovge ecx, edi
    mov [g_editor + editor_struct.selected_grid_cell], ecx

    xor rax, rax
    mov al, [g_input + input_struct.toggle_brick + input_action_struct.is_down]
    not al
    and al, [g_input + input_struct.toggle_brick + input_action_struct.was_down]
    and al, 0x1
    cmp al, 0x0
    je .DONT_TOGGLE_BRICK
    mov edi, [g_editor + editor_struct.selected_grid_cell]
    mov rsi, [g_grid + grid_struct.data_visual]
    lea rsi, [rsi + rdi*4]
    mov ecx, [rsi]
    not ecx
    and ecx, 0x1
    mov [rsi], ecx
    mov rsi, [g_grid + grid_struct.data_block]
    lea rsi, [rsi + rdi*4]
    mov ecx, [rsi]
    not ecx
    and ecx, 0x1
    mov [rsi], ecx

    lea rdi, [g_grid]
    mov rsi, [g_backbuffer]
    call render_grid
.DONT_TOGGLE_BRICK:

    mov edi, 0xFF00FFFF
    call byte_color_to_floating_point
    movaps xmm1, xmm0
    mov edi, [g_editor + editor_struct.selected_grid_cell]
    call grid_rect_from_idx
    mov rdx, [g_backbuffer]
    mov ecx, 0x2
    call render_outline_rect

.EDITOR_DISABLED_0:

    mov edi, 0xFF0000FF
    call byte_color_to_floating_point
    movaps xmm1, xmm0
    movaps xmm0, [g_ball_rect]
    mov rdx, [g_backbuffer]
    call render_color_rect

    mov rdi, [g_frontbuffer]
    mov rsi, [g_backbuffer]
    mov rdx, [g_buffer_size]
    call memcpy

    sub rsp, 16
    mov rdi, rsp
    call platform_gettime
    mov rax, [rsp + tv_sec]
    sub rax, [g_frame_start_time + tv_sec]
    mov [rsp + tv_sec], rax
    mov rax, [rsp + tv_nsec]
    sub rax, [g_frame_start_time + tv_nsec]
    mov [rsp + tv_nsec], rax
    add rsp, 16

    mov rsi, 16000000 ; 16 ms
    sub rsi, [rsp - 16 + tv_nsec]
    xor rdi, rdi
    call platform_nanosleep

    jmp .L0

    mov byte [g_running], 0
    call platform_exit
.poll_error:
    int3
SECTION .bss
    g_backbuffer:       resq    1
    g_frontbuffer:      resq    1
    g_buffer_size:      resq    1
    g_begin_time:       resq    1
    g_memory:
        istruc buffer_struct
            at buffer_struct.base,    resq    1
            at buffer_struct.used,    resd    1
            at buffer_struct.max,     resd    1
        iend
    g_test_image_u8_ptr:    resq    1
    g_test_image_f32:
        istruc image_data_struct
            at image_data_struct.data,      resq    1
            at image_data_struct.width,     resd    1
            at image_data_struct.height,    resd    1
            at image_data_struct.type,      resb    1
            at image_data_struct.image_data_struct_pad0,      resb    7
    g_input:
        istruc input_struct
            at input_struct.move_left,              resb 2
            at input_struct.move_right,             resb 2
            at input_struct.toggle_editor,          resb 2
            at input_struct.toggle_brick,           resb 2
            at input_struct.start_round,            resb 2
    g_last_time:        resq    1
    g_keyboard_device:  resd    1
    g_running:          resb    1
    g_input_thread_running: resb 1
    g_frame_start_time: resq    2
    g_fixed_delta_time_sec: resd    1
SECTION .data
    g_color_array:      db      0x80,0x30,0xFF,0xAA
    g_filename:         db      "test.ff",0
    g_f32_filename:     db      "image.f32",0
    g_u8_filename:     db      "image.u8",0
    align 16
    g_ball_rect:        dd    0x0,0x0,0x0,0x0
    g_move_16_to_32_shift_mask_1:     dq    0xFFFF0302FFFF0100,0xFFFF0706FFFF0504
    g_move_16_to_32_shift_mask_2:     dq    0xFFFF0B0AFFFF0908,0xFFFF0F0EFFFF0D0C
    ;g_move_32_to_8_shift_mask:        dq    0xFFFFFFFFFFFFFFFF,0x0C080400FFFFFFFF ; RGBA
    g_move_32_to_8_shift_mask:        dq    0xFFFFFFFFFFFFFFFF,0x0C000408FFFFFFFF  ; BGRA (correct)
    ;g_move_32_to_8_shift_mask:        dq    0xFFFFFFFFFFFFFFFF,0x0004080CFFFFFFFF  ; ABGR
    ;g_move_32_to_8_shift_mask:        dq    0xFFFFFFFFFFFFFFFF,0x0804000CFFFFFFFF ; ARGB
    g_temp_128:                       dq    0xFFFFFFFFFFFFFFFF,0xFFFF00000000FFFF
    g_divisor:                        dq    0x0000FFFF0000FFFF,0x0000FFFF0000FFFF ; Max for 16 bit
    g_multiplicant:                   dq    0x000000FF000000FF,0x000000FF000000FF ; Max for  8 bit
    g_frontbuffer_file:               db    "/tmp/nasm_screen",0
    g_keyboard_device_path:           db    "/dev/input/event3",0
    g_input_thread_stack_size:        dq    0x1000000
    g_input_key_left_down:            db    0
    g_input_key_right_down:           db    0
    align 16
    g_player_rect:
        istruc rect_struct
            at rect_struct.x,   dd      0x0
            at rect_struct.y,   dd      0x0
            at rect_struct.w,   dd      0x0
            at rect_struct.h,   dd      0x0
    g_grid:
        istruc grid_struct
            at grid_struct.num_x,               dd 0xA
            at grid_struct.num_y,               dd 0x8
            at grid_struct.size_x,              dd 0x0
            at grid_struct.size_y,              dd 0x0
            at grid_struct.pos_x,               dd 0x0
            at grid_struct.pos_y,               dd 0x0
            at grid_struct.bounds_x,            dd 1280
            at grid_struct.bounds_y,            dd 540
            at grid_struct.data_x,              dq 0x0
            at grid_struct.data_y,              dq 0x0
            at grid_struct.data_visual,         dq 0x0
            at grid_struct.data_color,          dq 0x0
            at grid_struct.data_block,          dq 0x0
    g_editor:
        istruc editor_struct
            at editor_struct.is_enabled,                db 0x0
            at editor_struct.pad0,                      db 0x0
            at editor_struct.selected_grid_cell,        dd 0x0
    g_ball_start_pos: dd 100,500
    g_ball_vel: dd 0x0, 0x0

    IMAGE_DATA_F32:     equ     0x0
    IMAGE_DATA_U8:      equ     0x1

    EV_SYN:             equ     0x00
    EV_KEY:             equ     0x01
    KEY_LEFT:           equ     105
    KEY_RIGHT:          equ     106
    KEY_UP:             equ     103
    KEY_DOWN:           equ     108
    KEY_E:              equ     18
    KEY_R:              equ     19
    KEY_SPACE:          equ     57

; vim: set ts=4 sw=4 tw=0 et: