4coder/win32_4ed.cpp

/*
 * Mr. 4th Dimention - Allen Webster
 *
 * 12.12.2014
 *
 * Win32 layer for project codename "4ed"
 *
 */

// TOP

#include "4coder_default_bindings.cpp"

#include "4ed_meta.h"

#define FCPP_STRING_IMPLEMENTATION
#include "4coder_string.h"

#include "4ed_mem.cpp"
#include "4ed_math.cpp"

#include "4ed_system.h"
#include "4ed_rendering.h"
#include "4ed.h"

#include <windows.h>
#include <GL/gl.h>
#include <GL/glext.h>

#include "system_shared.h"

#define SUPPORT_DPI 1
#define USE_WIN32_FONTS 0
#define USE_FT_FONTS 1

#define FPS 60
#define frame_useconds (1000000 / FPS)

#define WM_4coder_ANIMATE (WM_USER + 1)

//
// Win32_Vars structs
//

#if FRED_INTERNAL
struct Debug_Log_Entry{
    u64 time;
    i64 message;
};
#endif

struct Thread_Context{
    u32 job_id;
    b32 running;
    b32 cancel;
    
    Work_Queue *queue;
    u32 id;
    u32 group_id;
    u32 windows_id;
    HANDLE handle;
};

struct Thread_Group{
    Thread_Context *threads;
    i32 count;
    
    i32 cancel_lock0;
    i32 cancel_cv0;
};

#define UseWinDll 1

#if UseWinDll == 0
#include "4ed_dll_reader.h"
#include "4ed_dll_reader.cpp"
#endif

struct Control_Keys{
    b8 l_ctrl;
    b8 r_ctrl;
    b8 l_alt;
    b8 r_alt;
};
inline Control_Keys
control_keys_zero(){
    Control_Keys result = {0};
    return(result);
}

struct Win32_Input_Chunk_Transient{
    Key_Input_Data key_data;
    b8 mouse_l_press, mouse_l_release;
    b8 mouse_r_press, mouse_r_release;
    b8 out_of_window;
    i8 mouse_wheel;
    b8 trying_to_kill;
};
inline Win32_Input_Chunk_Transient
win32_input_chunk_transient_zero(){
    Win32_Input_Chunk_Transient result = {0};
    return(result);
}

struct Win32_Input_Chunk_Persistent{
    i32 mouse_x, mouse_y;
    b8 mouse_l, mouse_r;
    
    Control_Keys controls;
    b8 control_keys[MDFR_INDEX_COUNT];
};

struct Win32_Input_Chunk{
    Win32_Input_Chunk_Transient trans;
    Win32_Input_Chunk_Persistent pers;
};

struct Win32_Coroutine{
    Coroutine coroutine;
    Win32_Coroutine *next;
    int done;
};

#if FRED_INTERNAL
struct Sys_Bubble : public Bubble{
    i32 line_number;
    char *file_name;
};
#endif

enum CV_ID{
    CANCEL_CV0,
    CANCEL_CV1,
    CANCEL_CV2,
    CANCEL_CV3,
    CANCEL_CV4,
    CANCEL_CV5,
    CANCEL_CV6,
    CANCEL_CV7,
    CV_COUNT
};

struct Win32_Vars{
    System_Functions system;
    App_Functions app;
    Custom_API custom_api;
#if UseWinDll
    HMODULE app_code;
    HMODULE custom;
#else
    DLL_Loaded app_dll;
    DLL_Loaded custom_dll;
#endif
    Plat_Settings settings;
    
    
    Work_Queue queues[THREAD_GROUP_COUNT];
    Thread_Group groups[THREAD_GROUP_COUNT];
    CRITICAL_SECTION locks[LOCK_COUNT];
    CONDITION_VARIABLE condition_vars[CV_COUNT];
    Thread_Memory *thread_memory;
    Win32_Coroutine coroutine_data[18];
    Win32_Coroutine *coroutine_free;
    
    
    Win32_Input_Chunk input_chunk;
    b32 lctrl_lalt_is_altgr;
    b32 got_useful_event;
    
    
    HCURSOR cursor_ibeam;
    HCURSOR cursor_arrow;
    HCURSOR cursor_leftright;
    HCURSOR cursor_updown;
    String clipboard_contents;
    b32 next_clipboard_is_self;
    DWORD clipboard_sequence;
    
    
    HWND window_handle;
    Render_Target target;
    Partition font_part;
#if SUPPORT_DPI
    i32 dpi_x, dpi_y;
#endif
    
    u64 count_per_usecond;
    b32 first;
    i32 running_cli;
    
    
#if FRED_INTERNAL
    CRITICAL_SECTION DEBUG_sysmem_lock;
    Sys_Bubble internal_bubble;
#endif
};

globalvar Win32_Vars win32vars;
globalvar Application_Memory memory_vars;


//
// Helpers
//

internal HANDLE
Win32Handle(Plat_Handle h){
    HANDLE result;
    memcpy(&result, &h, sizeof(result));
    return(result);
}

internal Plat_Handle
Win32Handle(HANDLE h){
    Plat_Handle result = {0};
    Assert(sizeof(Plat_Handle) >= sizeof(h));
    memcpy(&result, &h, sizeof(h));
    return(result);
}

internal void*
Win32Ptr(Plat_Handle h){
    void *result;
    memcpy(&result, &h, sizeof(result));
    return(result);
}

internal Plat_Handle
Win32Ptr(void *h){
    Plat_Handle result = {0};
    memcpy(&result, &h, sizeof(h));
    return(result);
}


//
// Memory (not exposed to application, but needed in system_shared.cpp)
//

internal
Sys_Get_Memory_Sig(system_get_memory_){
    void *ptr = 0;
    if (size > 0){
        
#if FRED_INTERNAL
        ptr = VirtualAlloc(0, size + sizeof(Sys_Bubble), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
        Sys_Bubble *bubble = (Sys_Bubble*)ptr;
        bubble->flags = MEM_BUBBLE_SYS_DEBUG;
        bubble->line_number = line_number;
        bubble->file_name = file_name;
        bubble->size = size;
        EnterCriticalSection(&win32vars.DEBUG_sysmem_lock);
        insert_bubble(&win32vars.internal_bubble, bubble);
        LeaveCriticalSection(&win32vars.DEBUG_sysmem_lock);
        ptr = bubble + 1;
#else
        ptr = VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#endif
    }
    return(ptr);
}
internal
Sys_Free_Memory_Sig(system_free_memory){
    if (block){
#if FRED_INTERNAL
        Sys_Bubble *bubble = ((Sys_Bubble*)block) - 1;
        Assert((bubble->flags & MEM_BUBBLE_DEBUG_MASK) == MEM_BUBBLE_SYS_DEBUG);
        EnterCriticalSection(&win32vars.DEBUG_sysmem_lock);
        remove_bubble(bubble);
        LeaveCriticalSection(&win32vars.DEBUG_sysmem_lock);
        VirtualFree(bubble, 0, MEM_RELEASE);
#else
        VirtualFree(block, 0, MEM_RELEASE);
#endif
    }
}

#define Win32GetMemory(size) system_get_memory_(size, __LINE__, __FILE__)
#define Win32FreeMemory(ptr) system_free_memory(ptr)

#define Win32ScratchPartition sysshared_scratch_partition
#define Win32ScratchPartitionGrow sysshared_partition_grow
#define Win32ScratchPartitionDouble sysshared_partition_double

#if FRED_INTERNAL
internal Bubble*
INTERNAL_system_sentinel(){
    return (&win32vars.internal_bubble);
}

internal void
INTERNAL_system_debug_message(char *message){
    OutputDebugStringA(message);
}
#endif


//
// Multithreading
//

internal
Sys_Acquire_Lock_Sig(system_acquire_lock){
    EnterCriticalSection(&win32vars.locks[id]);
}

internal
Sys_Release_Lock_Sig(system_release_lock){
    LeaveCriticalSection(&win32vars.locks[id]);
}

internal void
system_wait_cv(i32 crit_id, i32 cv_id){
    SleepConditionVariableCS(win32vars.condition_vars + cv_id,
                             win32vars.locks + crit_id,
                             INFINITE);
}

internal void
system_signal_cv(i32 crit_id, i32 cv_id){
    AllowLocal(crit_id);
    WakeConditionVariable(win32vars.condition_vars + cv_id);
}

internal DWORD
JobThreadProc(LPVOID lpParameter){
    Thread_Context *thread = (Thread_Context*)lpParameter;
    Work_Queue *queue = win32vars.queues + thread->group_id;
    Thread_Group *group = win32vars.groups + thread->group_id;
    
    i32 thread_index = thread->id - 1;
    
    i32 cancel_lock = group->cancel_lock0 + thread_index;
    i32 cancel_cv = group->cancel_cv0 + thread_index;
    
    Thread_Memory *thread_memory = win32vars.thread_memory + thread_index;
    
    if (thread_memory->size == 0){
        i32 new_size = Kbytes(64);
        thread_memory->data = Win32GetMemory(new_size);
        thread_memory->size = new_size;
    }
    
    for (;;){
        u32 read_index = queue->read_position;
        u32 write_index = queue->write_position;
        
        if (read_index != write_index){
            u32 next_read_index = (read_index + 1) % JOB_ID_WRAP;
            u32 safe_read_index =
                InterlockedCompareExchange(&queue->read_position,
                                           next_read_index, read_index);
            
            if (safe_read_index == read_index){
                Full_Job_Data *full_job = queue->jobs + (safe_read_index % QUEUE_WRAP);
                // NOTE(allen): This is interlocked so that it plays nice
                // with the cancel job routine, which may try to cancel this job
                // at the same time that we try to run it
                
                i32 safe_running_thread =
                    InterlockedCompareExchange(&full_job->running_thread,
                                               thread->id, THREAD_NOT_ASSIGNED);
                
                if (safe_running_thread == THREAD_NOT_ASSIGNED){
                    thread->job_id = full_job->id;
                    thread->running = 1;
                    
                    full_job->job.callback(&win32vars.system,
                                           thread, thread_memory, full_job->job.data);
                    PostMessage(win32vars.window_handle, WM_4coder_ANIMATE, 0, 0);
                    full_job->running_thread = 0;
                    thread->running = 0;
                    
                    system_acquire_lock(cancel_lock);
                    if (thread->cancel){
                        thread->cancel = 0;
                        system_signal_cv(cancel_lock, cancel_cv);
                    }
                    system_release_lock(cancel_lock);
                }
            }
        }
        else{
            WaitForSingleObject(Win32Handle(queue->semaphore), INFINITE);
        }
    }
}

internal
Sys_Post_Job_Sig(system_post_job){
    Work_Queue *queue = win32vars.queues + group_id;
    
    Assert((queue->write_position + 1) % QUEUE_WRAP != queue->read_position % QUEUE_WRAP);
    
    b32 success = 0;
    u32 result = 0;
    while (!success){
        u32 write_index = queue->write_position;
        u32 next_write_index = (write_index + 1) % JOB_ID_WRAP;
        u32 safe_write_index =
            InterlockedCompareExchange(&queue->write_position,
                                       next_write_index, write_index);
        if (safe_write_index  == write_index){
            result = write_index;
            write_index = write_index % QUEUE_WRAP;
            queue->jobs[write_index].job = job;
            queue->jobs[write_index].running_thread = THREAD_NOT_ASSIGNED;
            queue->jobs[write_index].id = result;
            success = 1;
        }
    }
    
    ReleaseSemaphore(Win32Handle(queue->semaphore), 1, 0);
    
    return result;
}

// NOTE(allen): New job cancelling system:
//
//  Jobs are expected to periodically check their cancelation
// state, especially if they are taking a while.
//
//  When the main thread asks to cancel a job it sets the cancel
// state and does not resume until the thread running the job
// signals that it is okay.
//
//  Don't hold the frame lock while sleeping, as this can dead-lock
// the job thread and the main thread, and since main is sleeping
// they won't collide anyway.
internal
Sys_Cancel_Job_Sig(system_cancel_job){
    Work_Queue *queue = win32vars.queues + group_id;
    Thread_Group *group = win32vars.groups + group_id;
    
    u32 job_index;
    u32 thread_id;
    Full_Job_Data *full_job;
    
    job_index = job_id % QUEUE_WRAP;
    full_job = queue->jobs + job_index;
    
    Assert(full_job->id == job_id);
    thread_id =
        InterlockedCompareExchange(&full_job->running_thread,
                                   0, THREAD_NOT_ASSIGNED);
    
    if (thread_id != THREAD_NOT_ASSIGNED && thread_id != 0){
        i32 thread_index = thread_id - 1;
        
        i32 cancel_lock = group->cancel_lock0 + thread_index;
        i32 cancel_cv = group->cancel_cv0 + thread_index;
        Thread_Context *thread = group->threads + thread_index;
        
        
        system_acquire_lock(cancel_lock);
        
        thread->cancel = 1;
        
        system_release_lock(FRAME_LOCK);
        do{
            system_wait_cv(cancel_lock, cancel_cv);
        }while (thread->cancel == 1);
        system_acquire_lock(FRAME_LOCK);
        
        system_release_lock(cancel_lock);
    }
}

internal
Sys_Check_Cancel_Sig(system_check_cancel){
    b32 result = 0;
    
    Thread_Group *group = win32vars.groups + thread->group_id;
    i32 thread_index = thread->id - 1;
    i32 cancel_lock = group->cancel_lock0 + thread_index;
    
    system_acquire_lock(cancel_lock);
    if (thread->cancel){
        result = 1;
    }
    system_release_lock(cancel_lock);
    
    return(result);
}

internal
Sys_Grow_Thread_Memory_Sig(system_grow_thread_memory){
    void *old_data;
    i32 old_size, new_size;
    
    system_acquire_lock(CANCEL_LOCK0 + memory->id - 1);
    old_data = memory->data;
    old_size = memory->size;
    new_size = LargeRoundUp(memory->size*2, Kbytes(4));
    memory->data = system_get_memory(new_size);
    memory->size = new_size;
    if (old_data){
        memcpy(memory->data, old_data, old_size);
        system_free_memory(old_data);
    }
    system_release_lock(CANCEL_LOCK0 + memory->id - 1);
}

#if FRED_INTERNAL
internal void
INTERNAL_get_thread_states(Thread_Group_ID id, bool8 *running, i32 *pending){
    Work_Queue *queue = win32vars.queues + id;
    u32 write = queue->write_position;
    u32 read = queue->read_position;
    if (write < read) write += JOB_ID_WRAP;
    *pending = (i32)(write - read);
    
    Thread_Group *group = win32vars.groups + id;
    for (i32 i = 0; i < group->count; ++i){
        running[i] = (group->threads[i].running != 0);
    }
}
#endif


//
// Coroutines
//

internal Win32_Coroutine*
Win32AllocCoroutine(){
    Win32_Coroutine *result = win32vars.coroutine_free;
    Assert(result != 0);
    win32vars.coroutine_free = result->next;
    return(result);
}

internal void
Win32FreeCoroutine(Win32_Coroutine *data){
    data->next = win32vars.coroutine_free;
    win32vars.coroutine_free = data;
}

internal void
Win32CoroutineMain(void *arg_){
    Win32_Coroutine *c = (Win32_Coroutine*)arg_;
    c->coroutine.func(&c->coroutine);
    c->done = 1;
    Win32FreeCoroutine(c);
    SwitchToFiber(c->coroutine.yield_handle);
}

internal
Sys_Create_Coroutine_Sig(system_create_coroutine){
    Win32_Coroutine *c;
    Coroutine *coroutine;
    void *fiber;
    
    c = Win32AllocCoroutine();
    c->done = 0;
    
    coroutine = &c->coroutine;
    
    fiber = CreateFiber(0, Win32CoroutineMain, coroutine);
    
    coroutine->plat_handle = Win32Handle(fiber);
    coroutine->func = func;
    
    return(coroutine);
}

internal
Sys_Launch_Coroutine_Sig(system_launch_coroutine){
    Win32_Coroutine *c = (Win32_Coroutine*)coroutine;
    void *fiber;
    
    fiber = Win32Handle(coroutine->plat_handle);
    coroutine->yield_handle = GetCurrentFiber();
    coroutine->in = in;
    coroutine->out = out;
    
    SwitchToFiber(fiber);
    
    if (c->done){
        DeleteFiber(fiber);
        Win32FreeCoroutine(c);
        coroutine = 0;
    }
    
    return(coroutine);
}

Sys_Resume_Coroutine_Sig(system_resume_coroutine){
    Win32_Coroutine *c = (Win32_Coroutine*)coroutine;
    void *fiber;
    
    Assert(c->done == 0);
    
    coroutine->yield_handle = GetCurrentFiber();
    coroutine->in = in;
    coroutine->out = out;
    
    fiber = Win32Ptr(coroutine->plat_handle);
    
    SwitchToFiber(fiber);
    
    if (c->done){
        DeleteFiber(fiber);
        Win32FreeCoroutine(c);
        coroutine = 0;
    }
    
    return(coroutine);
}

Sys_Yield_Coroutine_Sig(system_yield_coroutine){
    SwitchToFiber(coroutine->yield_handle);
}


//
// Files
//

internal
Sys_File_Can_Be_Made_Sig(system_file_can_be_made){
    HANDLE file;
    file = CreateFile((char*)filename, FILE_APPEND_DATA, 0, 0,
                      OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    
    if (!file || file == INVALID_HANDLE_VALUE){
        return 0;
    }
    
    CloseHandle(file);
    
    return(1);
}

internal
Sys_File_Load_Begin_Sig(system_file_load_begin){
    File_Loading loading = {0};
    HANDLE file = 0;
    
    String fname_str = make_string_slowly(filename);
    if (fname_str.size < 1024){
        char fixed_space[1024];
        String fixed_str = make_fixed_width_string(fixed_space);
        copy(&fixed_str, fname_str);
        terminate_with_null(&fixed_str);
        
        replace_char(fixed_str, '/', '\\');
        
        file = CreateFile(fixed_str.str, GENERIC_READ, 0, 0,
                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        
        if (file && file != INVALID_HANDLE_VALUE){
            DWORD lo, hi;
            lo = GetFileSize(file, &hi);
            
            if (hi == 0){
                loading.handle = Win32Handle(file);
                loading.size = lo;
                loading.exists = 1;
            }
            else{
                CloseHandle(file);
            }
        }
    }
    
    return(loading);
}

internal
Sys_File_Load_End_Sig(system_file_load_end){
    b32 success = 0;
    HANDLE file = Win32Handle(loading.handle);
    
    DWORD read_size = 0;
    BOOL read_result = 0;
    
    if (loading.exists && file != INVALID_HANDLE_VALUE){
        read_result = 
            ReadFile(file,
                     buffer, loading.size,
                     &read_size, 0);
        
        if (read_result && read_size == (DWORD)loading.size){
            success = 1;
        }
        
        CloseHandle(file);
    }
    
    return(success);
}

internal
Sys_File_Save_Sig(system_file_save){
    b32 success = 0;
    
    HANDLE file =
        CreateFile((char*)filename, GENERIC_WRITE, 0, 0,
                   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    
	if (!file || file == INVALID_HANDLE_VALUE){
        success = 0;
	}
    else{
        BOOL write_result = 0;
        DWORD bytes_written = 0;
        
        if (buffer){
            write_result = WriteFile(file, buffer, size, &bytes_written, 0);
        }
        
        CloseHandle(file);
        
        if (!write_result || bytes_written != (u32)size){
            success = 0;
        }
    }
    
    return(success);
}

internal
Sys_File_Time_Stamp_Sig(system_file_time_stamp){
    u64 result = 0;
    
    FILETIME last_write;
    WIN32_FILE_ATTRIBUTE_DATA data;
    if (GetFileAttributesEx((char*)filename, GetFileExInfoStandard, &data)){
        last_write = data.ftLastWriteTime;
        
        result = ((u64)last_write.dwHighDateTime << 32) | (last_write.dwLowDateTime);
    }
    
    return(result);
}

internal
Sys_Now_Time_Stamp_Sig(system_now_time_stamp){
	u64 result = 0;
    FILETIME filetime;
    GetSystemTimeAsFileTime(&filetime);
    result = ((u64)filetime.dwHighDateTime << 32) | (filetime.dwLowDateTime);
    return(result);
}

internal
Sys_Set_File_List_Sig(system_set_file_list){
    if (directory.size > 0){
        char dir_space[MAX_PATH + 32];
        String dir = make_string(dir_space, 0, MAX_PATH + 32);
        append(&dir, directory);
        char trail_str[] = "\\*";
        append(&dir, trail_str);
        
        char *c_str_dir = make_c_str(dir);
        
        WIN32_FIND_DATA find_data;
        HANDLE search;
        search = FindFirstFileA(c_str_dir, &find_data);
        
        if (search != INVALID_HANDLE_VALUE){            
            i32 count = 0;
            i32 file_count = 0;
            BOOL more_files = 1;
            do{
                if (!match(find_data.cFileName, ".") &&
                    !match(find_data.cFileName, "..")){
                    ++file_count;
                    i32 size = 0;
                    for(;find_data.cFileName[size];++size);
                    count += size + 1;
                }
                more_files = FindNextFile(search, &find_data);
            }while(more_files);
            FindClose(search);

            i32 required_size = count + file_count * sizeof(File_Info);
            if (file_list->block_size < required_size){
                Win32FreeMemory(file_list->block);
                file_list->block = Win32GetMemory(required_size);
                file_list->block_size = required_size;
            }
            
            file_list->infos = (File_Info*)file_list->block;
            char *name = (char*)(file_list->infos + file_count);
            if (file_list->block){
                search = FindFirstFileA(c_str_dir, &find_data);
                
                if (search != INVALID_HANDLE_VALUE){
                    File_Info *info = file_list->infos;
                    more_files = 1;
                    do{
                        if (!match(find_data.cFileName, ".") &&
                            !match(find_data.cFileName, "..")){
                            info->folder = (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
                            info->filename.str = name;
                            
                            i32 i = 0;
                            for(;find_data.cFileName[i];++i) *name++ = find_data.cFileName[i];
                            info->filename.size = i;
                            info->filename.memory_size = info->filename.size + 1;
                            *name++ = 0;
                            replace_char(info->filename, '\\', '/');
                            ++info;
                        }
                        more_files = FindNextFile(search, &find_data);
                    }while(more_files);
                    FindClose(search);
                    
                    file_list->count = file_count;
                    
                }else{
                    Win32FreeMemory(file_list->block);
                    file_list->block = 0;
                    file_list->block_size = 0;
                }
            }
        }
    }
    else{
        if (directory.str == 0){
            Win32FreeMemory(file_list->block);
            file_list->block = 0;
            file_list->block_size = 0;
        }
        file_list->infos = 0;
        file_list->count = 0;
    }
}

internal
Sys_File_Track_Sig(system_file_track){}

internal
Sys_File_Untrack_Sig(system_file_untrack){}

internal
Sys_File_Unique_Hash_Sig(system_file_unique_hash){
    Unique_Hash hash = {0};
    BY_HANDLE_FILE_INFORMATION info;
    HANDLE handle;
    char space[1024];
    String str;
    
    if (filename.size < sizeof(space)){
        str = make_fixed_width_string(space);
        copy(&str, filename);
        terminate_with_null(&str);
        
        handle = CreateFile(str.str, GENERIC_READ, 0, 0,
                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        
        *success = 0;
        if (handle && handle != INVALID_HANDLE_VALUE){
            if (GetFileInformationByHandle(handle, &info)){
                hash.d[2] = info.dwVolumeSerialNumber;
                hash.d[1] = info.nFileIndexHigh;
                hash.d[0] = info.nFileIndexLow;
                *success = 1;
            }
            
            CloseHandle(handle);
        }
    }
    
    return(hash);
}

// NOTE(allen): Exposed to the custom layer.
internal
FILE_EXISTS_SIG(system_file_exists)/*
DOC_PARAM(filename, the full path to a file)
DOC_PARAM(len, the number of characters in the filename string)
DOC_RETURN(returns non-zero if the file exists, returns zero if the file does not exist)
*/{
    char full_filename_space[1024];
    String full_filename;
    HANDLE file;
    b32 result;
    
    result = 0;
    
    if (len < sizeof(full_filename_space)){
        full_filename = make_fixed_width_string(full_filename_space);
        copy(&full_filename, make_string(filename, len));
        terminate_with_null(&full_filename);
        
        file = CreateFile(full_filename.str, GENERIC_READ, 0, 0,
                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        
        if (file != INVALID_HANDLE_VALUE){
            CloseHandle(file);
            result = 1;
        }
    }
    
    return(result);
}

b32 Win32DirectoryExists(char *path){
    DWORD attrib = GetFileAttributesA(path);
    return (attrib != INVALID_FILE_ATTRIBUTES &&
            (attrib & FILE_ATTRIBUTE_DIRECTORY));
}

// NOTE(allen): Exposed to the custom layer.
internal
DIRECTORY_CD_SIG(system_directory_cd)/*
DOC_PARAM(dir, a string buffer containing a directory)
DOC_PARAM(len, the length of the string in the string buffer)
DOC_PARAM(capacity, the maximum size of the string buffer)
DOC_PARAM(rel_path, the path to change to, may include '.' or '..')
DOC_PARAM(rel_len, the length of the rel_path string)
DOC_RETURN(returns non-zero if the call succeeds, returns zero otherwise)
DOC
(
This call succeeds if the directory exists and the new directory fits inside the dir buffer.
If the call succeeds the dir buffer is filled with the new directory and len contains the
length of the string in the buffer.

For instance if dir contains "C:/Users/MySelf" and rel is "Documents" the buffer will contain
"C:/Users/MySelf/Documents" and len will contain the length of that string.  This call can
also be used with rel as ".." to traverse to parent folders.
)
*/{
    String directory = make_string(dir, *len, capacity);
    b32 result = 0;
    i32 old_size;
    
    char rel_path_space[1024];
    String rel_path_string = make_fixed_width_string(rel_path_space);
    copy(&rel_path_string, make_string(rel_path, rel_len));
    terminate_with_null(&rel_path_string);
    
    if (rel_path[0] != 0){
        if (rel_path[0] == '.' && rel_path[1] == 0){
            result = 1;
        }
        else if (rel_path[0] == '.' && rel_path[1] == '.' && rel_path[2] == 0){
            result = remove_last_folder(&directory);
            terminate_with_null(&directory);
        }
        else{
            if (directory.size + rel_len + 1 > directory.memory_size){
                old_size = directory.size;
                append_partial(&directory, rel_path);
                append_partial(&directory, "\\");
                if (Win32DirectoryExists(directory.str)){
                    result = 1;
                }
                else{
                    directory.size = old_size;
                }
            }
        }
    }
    
    *len = directory.size;
    
    return(result);
}

internal
Sys_Get_Binary_Path_Sig(system_get_binary_path){
    i32 result = 0;
    i32 size = GetModuleFileName(0, out->str, out->memory_size);
    if (size < out->memory_size-1){
        out->size = size;
        remove_last_folder(out);
        terminate_with_null(out);
        result = out->size;
    }
    return(result);
}

// NOTE(allen): Exposed to the custom layer.
GET_4ED_PATH_SIG(system_get_4ed_path)/*
DOC_PARAM(out, a buffer that receives the path to the 4ed executable file)
DOC_PARAM(capacity, the maximum capacity of the output buffer)
DOC_RETURN(returns non-zero on success, returns zero on failure)
*/{
    String str = make_string(out, 0, capacity);
    return(system_get_binary_path(&str));
}


//
// Clipboard
//

internal
Sys_Post_Clipboard_Sig(system_post_clipboard){
	if (OpenClipboard(win32vars.window_handle)){
		EmptyClipboard();
		HANDLE memory_handle;
		memory_handle = GlobalAlloc(GMEM_MOVEABLE, str.size+1);
		if (memory_handle){
			char *dest = (char*)GlobalLock(memory_handle);
            copy_fast_unsafe(dest, str);
			GlobalUnlock(memory_handle);
			SetClipboardData(CF_TEXT, memory_handle);
			win32vars.next_clipboard_is_self = 1;
		}
		CloseClipboard();
	}
}

internal b32
Win32ReadClipboardContents(){
    b32 result = 0;
    
    if (IsClipboardFormatAvailable(CF_TEXT)){
        result = 1;
        if (OpenClipboard(win32vars.window_handle)){
            HANDLE clip_data;
            clip_data = GetClipboardData(CF_TEXT);
            if (clip_data){
                win32vars.clipboard_contents.str = (char*)GlobalLock(clip_data);
                if (win32vars.clipboard_contents.str){
                    win32vars.clipboard_contents.size = str_size((char*)win32vars.clipboard_contents.str);
                    GlobalUnlock(clip_data);
                }
            }
            CloseClipboard();
        }
    }
    
    return(result);
}


//
// Command Line Exectuion
//

internal
Sys_CLI_Call_Sig(system_cli_call){
    char cmd[] = "c:\\windows\\system32\\cmd.exe";
    char *env_variables = 0;
    char command_line[2048];
    
    b32 success = 1;
    String s = make_fixed_width_string(command_line);
    copy(&s, make_lit_string("/C "));
    append_partial(&s, script_name);
    success = terminate_with_null(&s);
    
    if (success){
        success = 0;
        
		SECURITY_ATTRIBUTES sec_attributes = {};
        HANDLE out_read;
        HANDLE out_write;
        
        sec_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
        sec_attributes.bInheritHandle = TRUE;
        
        if (CreatePipe(&out_read, &out_write, &sec_attributes, 0)){
            if (SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)){
                STARTUPINFO startup = {};
                startup.cb = sizeof(STARTUPINFO);
                startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
                startup.hStdError = out_write;
                startup.hStdOutput = out_write;
                startup.wShowWindow = SW_HIDE;

                PROCESS_INFORMATION info = {};

                Assert(sizeof(Plat_Handle) >= sizeof(HANDLE));
                if (CreateProcess(cmd, command_line,
                        0, 0, TRUE, 0,
                        env_variables, path,
                        &startup, &info)){
                    success = 1;
                    CloseHandle(info.hThread);
                    *(HANDLE*)&cli_out->proc = info.hProcess;
                    *(HANDLE*)&cli_out->out_read = out_read;
                    *(HANDLE*)&cli_out->out_write = out_write;
                    
                    ++win32vars.running_cli;
                }
                else{
                    CloseHandle(out_read);
                    CloseHandle(out_write);
                    *(HANDLE*)&cli_out->proc = INVALID_HANDLE_VALUE;
                    *(HANDLE*)&cli_out->out_read = INVALID_HANDLE_VALUE;
                    *(HANDLE*)&cli_out->out_write = INVALID_HANDLE_VALUE;
                }
            }
            else{
                // TODO(allen): failed SetHandleInformation
                CloseHandle(out_read);
                CloseHandle(out_write);
                *(HANDLE*)&cli_out->proc = INVALID_HANDLE_VALUE;
                *(HANDLE*)&cli_out->out_read = INVALID_HANDLE_VALUE;
                *(HANDLE*)&cli_out->out_write = INVALID_HANDLE_VALUE;
            }
        }
        else{
            // TODO(allen): failed CreatePipe
        }
    }

    return success;
}

struct CLI_Loop_Control{
    u32 remaining_amount;
};

internal
Sys_CLI_Begin_Update_Sig(system_cli_begin_update){
    Assert(sizeof(cli->scratch_space) >= sizeof(CLI_Loop_Control));
    CLI_Loop_Control *loop = (CLI_Loop_Control*)cli->scratch_space;
    loop->remaining_amount = 0;
}

internal
Sys_CLI_Update_Step_Sig(system_cli_update_step){
    HANDLE handle = *(HANDLE*)&cli->out_read;
    CLI_Loop_Control *loop = (CLI_Loop_Control*)cli->scratch_space;
    b32 has_more = 0;
    DWORD remaining = loop->remaining_amount;
    u32 pos = 0;
    DWORD read_amount = 0;

    for (;;){
        if (remaining == 0){
            if (!PeekNamedPipe(handle, 0, 0, 0, &remaining, 0)) break;
            if (remaining == 0) break;
        }

        if (remaining + pos < max){
            has_more = 1;
            ReadFile(handle, dest + pos, remaining, &read_amount, 0);
            TentativeAssert(remaining == read_amount);
            pos += remaining;
            remaining = 0;
        }
        else{
            has_more = 1;
            ReadFile(handle, dest + pos, max - pos, &read_amount, 0);
            TentativeAssert(max - pos == read_amount);
            loop->remaining_amount = remaining - (max - pos);
            pos = max;
            break;
        }
    }
    *amount = pos;

    return has_more;
}

internal
Sys_CLI_End_Update_Sig(system_cli_end_update){
    b32 close_me = 0;
    HANDLE proc = *(HANDLE*)&cli->proc;
    DWORD result = 0;

    if (WaitForSingleObject(proc, 0) == WAIT_OBJECT_0){
        if (GetExitCodeProcess(proc, &result) == 0)
            cli->exit = -1;
        else
            cli->exit = (i32)result;

        close_me = 1;
        CloseHandle(*(HANDLE*)&cli->proc);
        CloseHandle(*(HANDLE*)&cli->out_read);
        CloseHandle(*(HANDLE*)&cli->out_write);
        
        --win32vars.running_cli;
    }
    return close_me;
}

#include "system_shared.cpp"
#include "4ed_rendering.cpp"

#if USE_WIN32_FONTS
# include "win32_font.cpp"
#elif USE_FT_FONTS
# include "win32_ft_font.cpp"
#endif

internal f32
size_change(i32 dpi_x, i32 dpi_y){
    // TODO(allen): We're just hoping dpi_x == dpi_y for now I guess.
    f32 size_x = dpi_x / 96.f;
    f32 size_y = dpi_y / 96.f;
    f32 size_max = Max(size_x, size_y);
    return(size_max);
}

internal
Font_Load_Sig(system_draw_font_load){
    if (win32vars.font_part.base == 0){
        win32vars.font_part = Win32ScratchPartition(Mbytes(8));
    }
    
    i32 oversample = 2;
    AllowLocal(oversample);
    
#if SUPPORT_DPI
    pt_size = ROUND32(pt_size * size_change(win32vars.dpi_x, win32vars.dpi_y));
#endif
    
    for (b32 success = 0; success == 0;){
#if USE_WIN32_FONTS
        
        success = win32_font_load(&win32vars.font_part,
                                  font_out,
                                  filename,
                                  fontname,
                                  pt_size,
                                  tab_width,
                                  oversample,
                                  store_texture);
        
#elif USE_FT_FONTS
        
        success = win32_ft_font_load(&win32vars.font_part,
                                     font_out,
                                     filename,
                                     pt_size,
                                     tab_width);
        
#else
        
        success = font_load(&win32vars.font_part,
                            font_out,
                            filename,
                            pt_size,
                            tab_width,
                            oversample,
                            store_texture);
        
#endif
        
        // TODO(allen): Make the growable partition something
        // that can just be passed directly to font load and
        // let it be grown there.
        if (!success){
            Win32ScratchPartitionDouble(&win32vars.font_part);
        }
    }
    
    return(1);
}

//
// Linkage to Custom and Application
//

internal b32
Win32LoadAppCode(){
    b32 result = 0;
    App_Get_Functions *get_funcs = 0;

#if UseWinDll
    
    win32vars.app_code = LoadLibraryA("4ed_app.dll");
    if (win32vars.app_code){
        get_funcs = (App_Get_Functions*)
            GetProcAddress(win32vars.app_code, "app_get_functions");
    }
    
#else
    
    File_Data file = system_load_file("4ed_app.dll");

    if (file.got_file){
        i32 error;
        DLL_Data dll_data;
        if (dll_parse_headers(file.data, &dll_data, &error)){
            Data img;
            img.size = dll_total_loaded_size(&dll_data);
            img.data = (byte*)
                VirtualAlloc((LPVOID)Tbytes(3), img.size,
                MEM_COMMIT | MEM_RESERVE,
                PAGE_READWRITE);

            dll_load(img, &win32vars.app_dll, file.data, &dll_data);

            DWORD extra_;
            VirtualProtect(img.data + win32vars.app_dll.text_start,
                win32vars.app_dll.text_size,
                PAGE_EXECUTE_READ,
                &extra_);

            get_funcs = (App_Get_Functions*)
                dll_load_function(&win32vars.app_dll, "app_get_functions", 17);
        }
        else{
            // TODO(allen): file loading error
        }

        Win32FreeMemory(file.data.data);
    }
    else{
        // TODO(allen): file loading error
    }

#endif

    if (get_funcs){
        result = 1;
        win32vars.app = get_funcs();        
    }

    return result;
}

internal void
Win32LoadSystemCode(){
    win32vars.system.file_time_stamp = system_file_time_stamp;
    win32vars.system.now_time_stamp = system_now_time_stamp;
    win32vars.system.file_unique_hash = system_file_unique_hash;
    win32vars.system.set_file_list = system_set_file_list;
    win32vars.system.file_track = system_file_track;
    win32vars.system.file_untrack = system_file_untrack;
    win32vars.system.file_load_begin = system_file_load_begin;
    win32vars.system.file_load_end = system_file_load_end;
    win32vars.system.file_save = system_file_save;

    win32vars.system.file_exists = system_file_exists;
    win32vars.system.directory_cd = system_directory_cd;
    win32vars.system.get_4ed_path = system_get_4ed_path;

    win32vars.system.post_clipboard = system_post_clipboard;

    win32vars.system.create_coroutine = system_create_coroutine;
    win32vars.system.launch_coroutine = system_launch_coroutine;
    win32vars.system.resume_coroutine = system_resume_coroutine;
    win32vars.system.yield_coroutine = system_yield_coroutine;

    win32vars.system.cli_call = system_cli_call;
    win32vars.system.cli_begin_update = system_cli_begin_update;
    win32vars.system.cli_update_step = system_cli_update_step;
    win32vars.system.cli_end_update = system_cli_end_update;

    win32vars.system.post_job = system_post_job;
    win32vars.system.cancel_job = system_cancel_job;
    win32vars.system.check_cancel = system_check_cancel;
    win32vars.system.grow_thread_memory = system_grow_thread_memory;
    win32vars.system.acquire_lock = system_acquire_lock;
    win32vars.system.release_lock = system_release_lock;

#if FRED_INTERNAL
    win32vars.system.internal_sentinel = INTERNAL_system_sentinel;
    win32vars.system.internal_get_thread_states = INTERNAL_get_thread_states;
    win32vars.system.internal_debug_message = INTERNAL_system_debug_message;
#endif

    win32vars.system.slash = '/';
}

internal void
Win32LoadRenderCode(){
    win32vars.target.push_clip = draw_push_clip;
    win32vars.target.pop_clip = draw_pop_clip;
    win32vars.target.push_piece = draw_push_piece;

    //win32vars.target.font_set.font_info_load = draw_font_info_load;
    win32vars.target.font_set.font_load = system_draw_font_load;
    win32vars.target.font_set.release_font = draw_release_font;
}

//
// Helpers
//

globalvar u8 keycode_lookup_table[255];

internal void
Win32KeycodeInit(){
    keycode_lookup_table[VK_BACK] = key_back;
    keycode_lookup_table[VK_DELETE] = key_del;
    keycode_lookup_table[VK_UP] = key_up;
    keycode_lookup_table[VK_DOWN] = key_down;
    keycode_lookup_table[VK_LEFT] = key_left;
    keycode_lookup_table[VK_RIGHT] = key_right;
    keycode_lookup_table[VK_INSERT] = key_insert;
    keycode_lookup_table[VK_HOME] = key_home;
    keycode_lookup_table[VK_END] = key_end;
    keycode_lookup_table[VK_PRIOR] = key_page_up;
    keycode_lookup_table[VK_NEXT] = key_page_down;
    keycode_lookup_table[VK_ESCAPE] = key_esc;
    
    keycode_lookup_table[VK_F1] = key_f1;
    keycode_lookup_table[VK_F2] = key_f2;
    keycode_lookup_table[VK_F3] = key_f3;
    keycode_lookup_table[VK_F4] = key_f4;
    keycode_lookup_table[VK_F5] = key_f5;
    keycode_lookup_table[VK_F6] = key_f6;
    keycode_lookup_table[VK_F7] = key_f7;
    keycode_lookup_table[VK_F8] = key_f8;
    keycode_lookup_table[VK_F9] = key_f9;
    
    keycode_lookup_table[VK_F10] = key_f10;
    keycode_lookup_table[VK_F11] = key_f11;
    keycode_lookup_table[VK_F12] = key_f12;
    keycode_lookup_table[VK_F13] = key_f13;
    keycode_lookup_table[VK_F14] = key_f14;
    keycode_lookup_table[VK_F15] = key_f15;
    keycode_lookup_table[VK_F16] = key_f16;
}

internal void
Win32RedrawScreen(HDC hdc){
    launch_rendering(&win32vars.target);
    glFlush();
    SwapBuffers(hdc);
}

internal void
Win32Resize(i32 width, i32 height){
    if (width > 0 && height > 0){
        glViewport(0, 0, width, height);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0, width, height, 0, -1, 1);
        glScissor(0, 0, width, height);
        
        win32vars.target.width = width;
        win32vars.target.height = height;
    }
}

internal void
Win32SetCursorFromUpdate(Application_Mouse_Cursor cursor){
    switch (cursor){
        case APP_MOUSE_CURSOR_ARROW:
        SetCursor(win32vars.cursor_arrow); break;
        
        case APP_MOUSE_CURSOR_IBEAM:
        SetCursor(win32vars.cursor_ibeam); break;
        
        case APP_MOUSE_CURSOR_LEFTRIGHT:
        SetCursor(win32vars.cursor_leftright); break;
        
        case APP_MOUSE_CURSOR_UPDOWN:
        SetCursor(win32vars.cursor_updown); break;
    }
}

internal u64
Win32HighResolutionTime(){
    u64 result = 0;
    LARGE_INTEGER t;
    if (QueryPerformanceCounter(&t)){
        result = (u64)t.QuadPart / win32vars.count_per_usecond;
    }
    return(result);
}



internal LRESULT
Win32Callback(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
    LRESULT result = 0;
    switch (uMsg){
        case WM_MENUCHAR:
        case WM_SYSCHAR:break;
        
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
        case WM_KEYDOWN:
        case WM_KEYUP:
        {
            win32vars.got_useful_event = 1;
            switch (wParam){
                case VK_CONTROL:case VK_LCONTROL:case VK_RCONTROL:
                case VK_MENU:case VK_LMENU:case VK_RMENU:
                case VK_SHIFT:case VK_LSHIFT:case VK_RSHIFT:
                {
                    Control_Keys *controls = 0;
                    b8 *control_keys = 0;
                    controls = &win32vars.input_chunk.pers.controls;
                    control_keys = win32vars.input_chunk.pers.control_keys;
                    
                    b8 down = ((lParam & Bit_31)?(0):(1));
                    b8 is_right = ((lParam & Bit_24)?(1):(0));
                    
                    if (wParam != 255){
                        switch (wParam){
                            case VK_SHIFT:
                            {
                                control_keys[MDFR_SHIFT_INDEX] = down;
                            }break;
                            
                            case VK_CONTROL:
                            {
                                if (is_right) controls->r_ctrl = down;
                                else controls->l_ctrl = down;
                            }break;
                            
                            case VK_MENU:
                            {
                                if (is_right) controls->r_alt = down;
                                else controls->l_alt = down;
                            }break;
                        }
                        
                        b8 ctrl, alt;
                        ctrl = (controls->r_ctrl || (controls->l_ctrl && !controls->r_alt));
                        alt = (controls->l_alt || (controls->r_alt && !controls->l_ctrl));
                        
                        if (win32vars.lctrl_lalt_is_altgr){
                            if (controls->l_alt && controls->l_ctrl){
                                ctrl = 0;
                                alt = 0;
                            }
                        }
                        
                        control_keys[MDFR_CONTROL_INDEX] = ctrl;
                        control_keys[MDFR_ALT_INDEX] = alt;
                    }
                }break;
                
                default:
                b8 previous_state, current_state;
                previous_state = ((lParam & Bit_30)?(1):(0));
                current_state = ((lParam & Bit_31)?(0):(1));
                
                if (current_state){
                    u8 key = keycode_lookup_table[(u8)wParam];
                    
                    i32 *count = 0;
                    Key_Event_Data *data = 0;
                    b8 *control_keys = 0;
                    i32 control_keys_size = 0;
                    
                    if (!previous_state){
                        count = &win32vars.input_chunk.trans.key_data.press_count;
                        data = win32vars.input_chunk.trans.key_data.press;
                    }
                    else{
                        count = &win32vars.input_chunk.trans.key_data.hold_count;
                        data = win32vars.input_chunk.trans.key_data.hold;
                    }
                    control_keys = win32vars.input_chunk.pers.control_keys;
                    control_keys_size = sizeof(win32vars.input_chunk.pers.control_keys);
                    
                    if (*count < KEY_INPUT_BUFFER_SIZE){
                        if (!key){
                            UINT vk = (UINT)wParam;
                            UINT scan = (UINT)((lParam >> 16) & 0x7F);
                            BYTE state[256];
                            BYTE control_state = 0;
                            WORD x1 = 0, x2 = 0, x = 0, junk_x;
                            int result1 = 0, result2 = 0, result = 0;
                            
                            GetKeyboardState(state);
                            x1 = 0;
                            result1 = ToAscii(vk, scan, state, &x1, 0);
                            if (result1 < 0){
                                ToAscii(vk, scan, state, &junk_x, 0);
                            }
                            result1 = (result1 == 1);
                            if (!usable_ascii((char)x1)){
                                result1 = 0;
                            }
                            
                            control_state = state[VK_CONTROL];
                            state[VK_CONTROL] = 0;
                            x2 = 0;
                            result2 = ToAscii(vk, scan, state, &x2, 0);
                            if (result2 < 0){
                                ToAscii(vk, scan, state, &junk_x, 0);
                            }
                            result2 = (result2 == 1);
                            if (!usable_ascii((char)x2)){
                                result2 = 0;
                            }
                            
                            // TODO(allen): This is becoming a really major issue.
                            // Apparently control + i outputs a '\t' which is VALID ascii
                            // according to this system. So it reports the key as '\t'.
                            // This wasn't an issue before because we were ignoring control
                            // when computing character_no_caps_lock which is what is used
                            // for commands. But that is incorrect for some keyboard layouts
                            // where control+alt is used to signal AltGr for important keys.
                            if (result1 && result2){
                                char c1 = char_to_upper((char)x1);
                                char cParam = char_to_upper((char)wParam);
                                
                                if ((c1 == '\n' || c1 == '\r') && cParam != VK_RETURN){
                                    result1 = 0;
                                }
                                if (c1 == '\t' && cParam != VK_TAB){
                                    result1 = 0;
                                }
                            }
                            
                            if (result1){
                                x = x1;
                                state[VK_CONTROL] = control_state;
                                result = 1;
                            }
                            else if (result2){
                                x = x2;
                                result = 1;
                            }
                            
                            if (result == 1 && x < 128){
                                key = (u8)x;
                                if (key == '\r') key = '\n';
                                data[*count].character = key;
                                
                                state[VK_CAPITAL] = 0;
                                x = 0;
                                result = ToAscii(vk, scan, state, &x, 0);
                                if (result < 0){
                                    ToAscii(vk, scan, state, &junk_x, 0);
                                }
                                result = (result == 1);
                                if (!usable_ascii((char)x)){
                                    result = 0;
                                }
                                
                                if (result){
                                    key = (u8)x;
                                    if (key == '\r') key = '\n';
                                    data[*count].character_no_caps_lock = key;
                                    data[*count].keycode = key;
                                }
                            }
                            if (result != 1 || x >= 128){
                                data[*count].character = 0;
                                data[*count].character_no_caps_lock = 0;
                                data[*count].keycode = 0;
                            }
                        }
                        else{
                            data[*count].character = 0;
                            data[*count].character_no_caps_lock = 0;
                            data[*count].keycode = key;
                        }
                        memcpy(data[*count].modifiers, control_keys, control_keys_size);
                        data[*count].modifiers[MDFR_HOLD_INDEX] = previous_state;
                        ++(*count);
                    }
                }
                
                result = DefWindowProc(hwnd, uMsg, wParam, lParam);
            }
        }break;
        
        case WM_MOUSEMOVE:
        {
            i32 new_x = LOWORD(lParam);
            i32 new_y = HIWORD(lParam);
            
            if (new_x != win32vars.input_chunk.pers.mouse_x
                || new_y != win32vars.input_chunk.pers.mouse_y){
                win32vars.input_chunk.pers.mouse_x = new_x;
                win32vars.input_chunk.pers.mouse_y = new_y;
                
                win32vars.got_useful_event = 1;
            }
        }break;
        
        case WM_MOUSEWHEEL:
        {
            win32vars.got_useful_event = 1;
            i16 rotation = GET_WHEEL_DELTA_WPARAM(wParam);
            if (rotation > 0){
                win32vars.input_chunk.trans.mouse_wheel = 1;
            }
            else{
                win32vars.input_chunk.trans.mouse_wheel = -1;
            }
        }break;
        
        case WM_LBUTTONDOWN:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.trans.mouse_l_press = 1;
            win32vars.input_chunk.pers.mouse_l = 1;
        }break;
        
        case WM_RBUTTONDOWN:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.trans.mouse_r_press = 1;
            win32vars.input_chunk.pers.mouse_r = 1;
        }break;
        
        case WM_LBUTTONUP:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.trans.mouse_l_release = 1;
            win32vars.input_chunk.pers.mouse_l = 0;
        }break;
        
        case WM_RBUTTONUP:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.trans.mouse_r_release = 1;
            win32vars.input_chunk.pers.mouse_r = 0;
        }break;
        
        case WM_KILLFOCUS:
        case WM_SETFOCUS:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.pers.mouse_l = 0;
            win32vars.input_chunk.pers.mouse_r = 0;
            
            b8 *control_keys = win32vars.input_chunk.pers.control_keys;
            for (int i = 0; i < MDFR_INDEX_COUNT; ++i) control_keys[i] = 0;
            win32vars.input_chunk.pers.controls = control_keys_zero();
        }break;
        
        case WM_SIZE:
        {
            win32vars.got_useful_event = 1;
            if (win32vars.target.handle){
                i32 new_width = LOWORD(lParam);
                i32 new_height = HIWORD(lParam);
                
                Win32Resize(new_width, new_height);
            }
        }break;
        
        case WM_PAINT:
        {
            win32vars.got_useful_event = 1;
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            Win32RedrawScreen(hdc);
            EndPaint(hwnd, &ps);
        }break;
        
        case WM_CLOSE:
        case WM_DESTROY:
        {
            win32vars.got_useful_event = 1;
            win32vars.input_chunk.trans.trying_to_kill = 1;
        }break;
        
        case WM_4coder_ANIMATE:
        win32vars.got_useful_event = 1;
        break;
        
        default:
        {
            result = DefWindowProc(hwnd, uMsg, wParam, lParam);
        }break;
    }
    return(result);
}

#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
#define GL_DEBUG_OUTPUT 0x92E0

//typedef void GLDEBUGPROC_TYPE(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char * message, const GLvoid * userParam);
//typedef GLDEBUGPROC_TYPE * GLDEBUGPROC;
typedef void glDebugMessageControl_type(GLenum source, GLenum type, GLenum severity, GLsizei count, GLuint * ids, GLboolean enabled);
typedef void glDebugMessageCallback_type(GLDEBUGPROC callback, void * userParam);

internal void
OpenGLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam)
{
    OutputDebugStringA(message);
    OutputDebugStringA("\n");
}

int
WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow){
    
    int argc = __argc;
    char **argv = __argv;
    
    memset(&win32vars, 0, sizeof(win32vars));
    
    
    //
    // Threads and Coroutines
    //
    
    // NOTE(allen): These should come before threads are started!
    // Threads now get memory right away and so they use
    // the internal_bubble and DEBUG_sysmem_lock
    
#if FRED_INTERNAL
    win32vars.internal_bubble.next = &win32vars.internal_bubble;
    win32vars.internal_bubble.prev = &win32vars.internal_bubble;
    win32vars.internal_bubble.flags = MEM_BUBBLE_SYS_DEBUG;
    
    InitializeCriticalSection(&win32vars.DEBUG_sysmem_lock);
#endif
    
    for (i32 i = 0; i < LOCK_COUNT; ++i){
        InitializeCriticalSection(&win32vars.locks[i]);
    }
    
    for (i32 i = 0; i < CV_COUNT; ++i){
        InitializeConditionVariable(&win32vars.condition_vars[i]);
    }
    
    
    Thread_Context background[4];
    memset(background, 0, sizeof(background));
    win32vars.groups[BACKGROUND_THREADS].threads = background;
    win32vars.groups[BACKGROUND_THREADS].count = ArrayCount(background);
    win32vars.groups[BACKGROUND_THREADS].cancel_lock0 = CANCEL_LOCK0;
    win32vars.groups[BACKGROUND_THREADS].cancel_cv0 = CANCEL_CV0;
    
    Thread_Memory thread_memory[ArrayCount(background)];
    win32vars.thread_memory = thread_memory;
    
    win32vars.queues[BACKGROUND_THREADS].semaphore =
        Win32Handle(CreateSemaphore(0, 0,
                                    win32vars.groups[BACKGROUND_THREADS].count,
                                    0));
    
    u32 creation_flag = 0;
    for (i32 i = 0; i < win32vars.groups[BACKGROUND_THREADS].count; ++i){
        Thread_Context *thread = win32vars.groups[BACKGROUND_THREADS].threads + i;
        thread->id = i + 1;
        thread->group_id = BACKGROUND_THREADS;
        
        Thread_Memory *memory = win32vars.thread_memory + i;
        *memory = thread_memory_zero();
        memory->id = thread->id;
        
        thread->queue = &win32vars.queues[BACKGROUND_THREADS];
        thread->handle = CreateThread(0, 0, JobThreadProc, thread, creation_flag, (LPDWORD)&thread->windows_id);
    }
    
    ConvertThreadToFiber(0);
    win32vars.coroutine_free = win32vars.coroutine_data;
    for (i32 i = 0; i+1 < ArrayCount(win32vars.coroutine_data); ++i){
        win32vars.coroutine_data[i].next = win32vars.coroutine_data + i + 1;
    }
    
    
    //
    // Memory Initialization
    //
    
    LPVOID base;
#if FRED_INTERNAL
    base = (LPVOID)Tbytes(1);
#else
    base = (LPVOID)0;
#endif
    
    memory_vars.vars_memory_size = Mbytes(2);
    memory_vars.vars_memory = VirtualAlloc(base, memory_vars.vars_memory_size,
                                           MEM_COMMIT | MEM_RESERVE,
                                           PAGE_READWRITE);
    
#if FRED_INTERNAL
    base = (LPVOID)Tbytes(2);
#else
    base = (LPVOID)0;
#endif
    memory_vars.target_memory_size = Mbytes(512);
    memory_vars.target_memory =
        VirtualAlloc(base, memory_vars.target_memory_size,
                     MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    
    base = (LPVOID)0;
    memory_vars.user_memory_size = Mbytes(2);
    memory_vars.user_memory =
        VirtualAlloc(base, memory_vars.target_memory_size,
                     MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    
    if (!memory_vars.vars_memory){
        exit(1);
    }
    
    win32vars.target.max = Mbytes(1);
    win32vars.target.push_buffer = (byte*)system_get_memory(win32vars.target.max);
    
    
    //
    // System and Application Layer Linkage
    //
    
    if (!Win32LoadAppCode()){
        exit(1);
    }
    
    Win32LoadSystemCode();
    
    Win32LoadRenderCode();
    
    
    //
    // Read Command Line
    //
    
    DWORD required = (GetCurrentDirectory(0, 0)*4) + 1;
    char *current_directory_mem = (char*)system_get_memory(required);
    DWORD written = GetCurrentDirectory(required, current_directory_mem);
    
    String current_directory = make_string(current_directory_mem, written, required);
    terminate_with_null(&current_directory);
    replace_char(current_directory, '\\', '/');
    
    Command_Line_Parameters clparams;
    clparams.argv = argv;
    clparams.argc = argc;
    
    char **files = 0;
    i32 *file_count = 0;
    
    win32vars.app.read_command_line(&win32vars.system,
                                    &memory_vars,
                                    current_directory,
                                    &win32vars.settings,
                                    &files, &file_count,
                                    clparams);
    
    sysshared_filter_real_files(files, file_count);
    
    
    //
    // Custom Layer Linkage
    //
    
#ifdef FRED_SUPER
    char *custom_file_default = "4coder_custom.dll";
    char *custom_file = 0;
    if (win32vars.settings.custom_dll) custom_file = win32vars.settings.custom_dll;
    else custom_file = custom_file_default;
    
    win32vars.custom = LoadLibraryA(custom_file);
    if (!win32vars.custom && custom_file != custom_file_default){
        if (!win32vars.settings.custom_dll_is_strict){
            win32vars.custom = LoadLibraryA(custom_file_default);
        }
    }
    
    if (win32vars.custom){
        win32vars.custom_api.get_alpha_4coder_version = (_Get_Version_Function*)
            GetProcAddress(win32vars.custom, "get_alpha_4coder_version");
        
        if (win32vars.custom_api.get_alpha_4coder_version == 0 ||
                win32vars.custom_api.get_alpha_4coder_version(MAJOR, MINOR, PATCH) == 0){
            OutputDebugStringA("Error: application and custom version numbers don't match\n");
            exit(1);
        }
        win32vars.custom_api.get_bindings = (Get_Binding_Data_Function*)
            GetProcAddress(win32vars.custom, "get_bindings");
        
        // NOTE(allen): I am temporarily taking the view routine
        // back out, it will be back soon.
#if 0
        win32vars.custom_api.view_routine = (View_Routine_Function*)
            GetProcAddress(win32vars.custom, "view_routine");
#endif
        
    }
#endif
    
    if (win32vars.custom_api.get_bindings == 0){
        win32vars.custom_api.get_bindings = (Get_Binding_Data_Function*)get_bindings;
    }
    
    win32vars.custom_api.view_routine = (View_Routine_Function*)0;
    
#if 0
    if (win32vars.custom_api.view_routine == 0){
        win32vars.custom_api.view_routine = (View_Routine_Function*)view_routine;
    }
#endif

    
    //
    // Window and GL Initialization
    //
    
    WNDCLASS window_class = {};
    window_class.style = CS_HREDRAW|CS_VREDRAW;
    window_class.lpfnWndProc = Win32Callback;
    window_class.hInstance = hInstance;
    window_class.lpszClassName = "4coder-win32-wndclass";
    window_class.hIcon = LoadIcon(hInstance, "main");
    
    if (!RegisterClass(&window_class)){
        exit(1);
    }
    
    RECT window_rect = {};
    
    if (win32vars.settings.set_window_size){
        window_rect.right = win32vars.settings.window_w;
        window_rect.bottom = win32vars.settings.window_h;
    }
    else{
        window_rect.right = 800;
        window_rect.bottom = 600;
    }
    
    if (!AdjustWindowRect(&window_rect, WS_OVERLAPPEDWINDOW, false)){
        // TODO(allen): non-fatal diagnostics
    }
    
#define WINDOW_NAME "4coder-window: " VERSION
    
    i32 window_x;
    i32 window_y;
    i32 window_style;
    
    if (win32vars.settings.set_window_pos){
        window_x = win32vars.settings.window_x;
        window_y = win32vars.settings.window_y;
    }
    else{
        window_x = CW_USEDEFAULT;
        window_y = CW_USEDEFAULT;
    }
    
    window_style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
    if (win32vars.settings.maximize_window){
        window_style |= WS_MAXIMIZE;
    }
    
    win32vars.window_handle =
        CreateWindowA(window_class.lpszClassName,
                      WINDOW_NAME, window_style,
                      window_x, window_y,
                      window_rect.right - window_rect.left,
                      window_rect.bottom - window_rect.top,
                      0, 0, hInstance, 0);
    
    if (win32vars.window_handle == 0){
        exit(1);
    }
    
    HDC hdc = GetDC(win32vars.window_handle);
    
#if SUPPORT_DPI
    // TODO(allen): not Windows XP compatible, how do I handle that?
    SetProcessDPIAware();
    
    win32vars.dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
    win32vars.dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
#else
    win32vars.dpi_x = 1;
    win32vars.dpi_y = 1;
#endif
    
    GetClientRect(win32vars.window_handle, &window_rect);
    
    static PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        32,
        0, 0, 0, 0, 0, 0,
        0,
        0,
        0,
        0, 0, 0, 0,
        16,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0, 0, 0 };
    
    {
        i32 pixel_format;
        pixel_format = ChoosePixelFormat(hdc, &pfd);
        SetPixelFormat(hdc, pixel_format, &pfd);
        
        win32vars.target.handle = hdc;
        win32vars.target.context = wglCreateContext(hdc);
        wglMakeCurrent(hdc, (HGLRC)win32vars.target.context);
    }
    ReleaseDC(win32vars.window_handle, hdc);
    
#if FRED_INTERNAL
    // NOTE(casey): This slows down GL but puts error messages to
    // the debug console immediately whenever you do something wrong
    glDebugMessageCallback_type *glDebugMessageCallback =
        (glDebugMessageCallback_type *)wglGetProcAddress("glDebugMessageCallback");
    glDebugMessageControl_type *glDebugMessageControl =
        (glDebugMessageControl_type *)wglGetProcAddress("glDebugMessageControl");
    if(glDebugMessageCallback && glDebugMessageControl)
    {
        glDebugMessageCallback(OpenGLDebugCallback, 0);
        glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
    }
#endif
    
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_SCISSOR_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    Win32Resize(window_rect.right - window_rect.left, window_rect.bottom - window_rect.top);
    
    
    //
    // Misc System Initializations
    //
    
    win32vars.clipboard_sequence = GetClipboardSequenceNumber();
    if (win32vars.clipboard_sequence == 0){
        system_post_clipboard(make_lit_string(""));
        
        win32vars.clipboard_sequence = GetClipboardSequenceNumber();
        win32vars.next_clipboard_is_self = 0;
        
        if (win32vars.clipboard_sequence == 0){
            OutputDebugStringA("Failure while initializing clipboard\n");
        }
    }
    else{
        Win32ReadClipboardContents();
    }
    
    Win32KeycodeInit();
    
    win32vars.cursor_ibeam = LoadCursor(NULL, IDC_IBEAM);
    win32vars.cursor_arrow = LoadCursor(NULL, IDC_ARROW);
    win32vars.cursor_leftright = LoadCursor(NULL, IDC_SIZEWE);
    win32vars.cursor_updown = LoadCursor(NULL, IDC_SIZENS);
    
    LARGE_INTEGER f;
    if (QueryPerformanceFrequency(&f)){
        win32vars.count_per_usecond = (u64)f.QuadPart / 1000000;
    }
    else{
        // NOTE(allen): Just guess.
        win32vars.count_per_usecond = 1;
    }
    
    
    //
    // Main Loop
    //
    
    win32vars.app.init(&win32vars.system,
                       &win32vars.target,
                       &memory_vars,
                       win32vars.clipboard_contents,
                       current_directory,
                       win32vars.custom_api);
    
    system_free_memory(current_directory.str);
    
    b32 keep_playing = 1;
    win32vars.first = 1;
    timeBeginPeriod(1);
    
    
    SetForegroundWindow(win32vars.window_handle);
    SetActiveWindow(win32vars.window_handle);
    
    u64 timer_start = Win32HighResolutionTime();
    system_acquire_lock(FRAME_LOCK);
    MSG msg;
    for (;keep_playing;){
        // TODO(allen): Find a good way to wait on a pipe
        // without interfering with the reading process
        //  Looks like we can ReadFile with a size of zero
        // in an IOCP for this effect.
        
        system_release_lock(FRAME_LOCK);
        
        if (win32vars.running_cli == 0){
            win32vars.got_useful_event = 0;
            for (;win32vars.got_useful_event == 0;){
                if (GetMessage(&msg, 0, 0, 0)){
                    if (msg.message == WM_QUIT){
                        keep_playing = 0;
                    }else{
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                    }
                }
            }
        }
        
        while (PeekMessage(&msg, 0, 0, 0, 1)){
            if (msg.message == WM_QUIT){
                keep_playing = 0;
            }else{
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        
        system_acquire_lock(FRAME_LOCK);
        
        POINT mouse_point;
        if (GetCursorPos(&mouse_point) &&
            ScreenToClient(win32vars.window_handle, &mouse_point)){
            
            i32_Rect screen =
                i32R(0, 0, win32vars.target.width, win32vars.target.height);
            
            if (!hit_check(mouse_point.x, mouse_point.y, screen)){
                win32vars.input_chunk.trans.out_of_window = 1;
            }
            
            win32vars.input_chunk.pers.mouse_x = mouse_point.x;
            win32vars.input_chunk.pers.mouse_y = mouse_point.y;
        }
        else{
            win32vars.input_chunk.trans.out_of_window = 1;
        }
        
        Win32_Input_Chunk input_chunk = win32vars.input_chunk;
        win32vars.input_chunk.trans = win32_input_chunk_transient_zero();
        
        input_chunk.pers.control_keys[MDFR_CAPS_INDEX] = GetKeyState(VK_CAPITAL) & 0x1;
        
        win32vars.clipboard_contents = string_zero();
        if (win32vars.clipboard_sequence != 0){
            DWORD new_number = GetClipboardSequenceNumber();
            if (new_number != win32vars.clipboard_sequence){
                win32vars.clipboard_sequence = new_number;
                if (win32vars.next_clipboard_is_self){
                    win32vars.next_clipboard_is_self = 0;
                }
                else{
                    Win32ReadClipboardContents();
                }
            }
        }
        
        Application_Step_Input input = {0};
        
        input.first_step = win32vars.first;
        
        // NOTE(allen): The expected dt given the frame limit in seconds.
        input.dt = frame_useconds / 1000000.f;
        
        input.keys = input_chunk.trans.key_data;
        memcpy(input.keys.modifiers, input_chunk.pers.control_keys, sizeof(input_chunk.pers.control_keys));
        
        input.mouse.out_of_window = input_chunk.trans.out_of_window;
        
        input.mouse.l = input_chunk.pers.mouse_l;
        input.mouse.press_l = input_chunk.trans.mouse_l_press;
        input.mouse.release_l = input_chunk.trans.mouse_l_release;
        
        input.mouse.r = input_chunk.pers.mouse_r;
        input.mouse.press_r = input_chunk.trans.mouse_r_press;
        input.mouse.release_r = input_chunk.trans.mouse_r_release;
        
        input.mouse.wheel = input_chunk.trans.mouse_wheel;
        input.mouse.x = input_chunk.pers.mouse_x;
        input.mouse.y = input_chunk.pers.mouse_y;
        
        input.clipboard = win32vars.clipboard_contents;
        
        
        Application_Step_Result result = {(Application_Mouse_Cursor)0};
        result.mouse_cursor_type = APP_MOUSE_CURSOR_DEFAULT;
        result.lctrl_lalt_is_altgr = win32vars.lctrl_lalt_is_altgr;
        result.trying_to_kill = input_chunk.trans.trying_to_kill;
        result.perform_kill = 0;
        
        win32vars.app.step(&win32vars.system,
                           &win32vars.target,
                           &memory_vars,
                           &input,
                           &result);
        
        if (result.perform_kill){
            keep_playing = 0;
        }
        
        Win32SetCursorFromUpdate(result.mouse_cursor_type);
        win32vars.lctrl_lalt_is_altgr = result.lctrl_lalt_is_altgr;
        
        HDC hdc = GetDC(win32vars.window_handle);
        Win32RedrawScreen(hdc);
        ReleaseDC(win32vars.window_handle, hdc);

        win32vars.first = 0;
        
        if (result.animating){
            PostMessage(win32vars.window_handle, WM_4coder_ANIMATE, 0, 0);
        }
        
        u64 timer_end = Win32HighResolutionTime();
        u64 end_target = timer_start + frame_useconds;
        
        system_release_lock(FRAME_LOCK);
        while (timer_end < end_target){
            DWORD samount = (DWORD)((end_target - timer_end) / 1000);
            if (samount > 0) Sleep(samount);
            timer_end = Win32HighResolutionTime();
        }
        system_acquire_lock(FRAME_LOCK);
        timer_start = Win32HighResolutionTime();
    }
    
    return(0);
}

#if 0
// NOTE(allen): In case I want to switch back to a console
// application at some point.
int main(int argc, char **argv){
    HINSTANCE hInstance = GetModuleHandle(0);
}
#endif

// BOTTOM