/*
* Mr. 4th Dimention - Allen Webster
*
* 12.12.2014
*
* Win32 layer for project codename "4ed"
*
*/
// TOP
// TODO(allen):
//
// Fix the OwnDC thing.
//
#ifdef FRED_NOT_PACKAGE
#define FRED_INTERNAL 1
#define FRED_SLOW 1
#define FRED_PRINT_DEBUG 1
#define FRED_PRINT_DEBUG_FILE_LINE 0
#define FRED_PROFILING 1
#define FRED_PROFILING_OS 0
#define FRED_FULL_ERRORS 0
#else
#define FRED_SLOW 0
#define FRED_INTERNAL 0
#define FRED_PRINT_DEBUG 0
#define FRED_PRINT_DEBUG_FILE_LINE 0
#define FRED_PROFILING 0
#define FRED_PROFILING_OS 0
#define FRED_FULL_ERRORS 0
#endif
#define SOFTWARE_RENDER 0
#if FRED_INTERNAL == 0
#undef FRED_PRINT_DEBUG
#define FRED_PRINT_DEBUG 0
#undef FRED_PROFILING
#define FRED_PROFILING 0
#undef FRED_PROFILING_OS
#define FRED_PROFILING_OS 0
#endif
#if FRED_PRINT_DEBUG == 0
#undef FRED_PRINT_DEBUG_FILE_LINE
#define FRED_PRINT_DEBUG_FILE_LINE 0
#undef FRED_PRINT_DEBUG_FILE_LINE
#define FRED_PROFILING_OS 0
#endif
#define FPS 30
#define FRAME_TIME (1000000 / FPS)
#define BUFFER_EXPERIMENT_SCALPEL 3
#include "4ed_meta.h"
#define FCPP_FORBID_MALLOC
#include "4cpp_types.h"
#define FCPP_STRING_IMPLEMENTATION
#include "4cpp_string.h"
#define FCPP_LEXER_IMPLEMENTATION
#include "4cpp_lexer.h"
#include "4ed_math.cpp"
#include "4coder_custom.h"
#include "4ed.h"
#include "4ed_system.h"
#include "4ed_rendering.h"
struct TEMP_BACKDOOR{
Get_Binding_Data_Function *get_bindings;
Set_Extra_Font_Function *set_extra_font;
} TEMP;
#if FRED_INTERNAL
struct Sys_Bubble : public Bubble{
i32 line_number;
char *file_name;
};
#endif
#include <windows.h>
#include <GL/gl.h>
#include "4ed_internal.h"
#include "4ed_rendering.cpp"
#include "4ed_command.cpp"
#include "4ed_layout.cpp"
#include "4ed_style.cpp"
#include "4ed_file_view.cpp"
#include "4ed_color_view.cpp"
#include "4ed_interactive_view.cpp"
#include "4ed_menu_view.cpp"
#include "4ed_debug_view.cpp"
#include "4ed.cpp"
#include "4ed_keyboard.cpp"
struct Full_Job_Data{
Job_Data job;
u32 job_memory_index;
u32 running_thread;
bool32 finished;
u32 id;
};
struct Work_Queue{
u32 volatile write_position;
u32 volatile read_position;
Full_Job_Data jobs[256];
HANDLE semaphore;
};
struct Thread_Context{
u32 job_id;
bool32 running;
Work_Queue *queue;
u32 id;
u32 windows_id;
HANDLE handle;
};
struct Thread_Group{
Thread_Context *threads;
i32 count;
};
struct Win32_Vars{
HWND window_handle;
Key_Codes key_codes, loose_codes;
Key_Input_Data input_data, previous_data;
#if SOFTWARE_RENDER
BITMAPINFO bmp_info;
union{
struct{
void *pixel_data;
i32 width, height, pitch;
};
Render_Target target;
};
i32 true_pixel_size;
#else
Render_Target target;
#endif
u32 volatile force_redraw;
Mouse_State mouse;
bool32 focus;
bool32 keep_playing;
HCURSOR cursor_ibeam;
HCURSOR cursor_arrow;
HCURSOR cursor_leftright;
HCURSOR cursor_updown;
Application_Mouse_Cursor prev_mouse_cursor;
Clipboard_Contents clipboard_contents;
bool32 next_clipboard_is_self;
DWORD clipboard_sequence;
Thread_Context main_thread;
Thread_Group groups[THREAD_GROUP_COUNT];
Work_Queue queues[THREAD_GROUP_COUNT];
HANDLE locks[LOCK_COUNT];
HANDLE DEBUG_sysmem_lock;
Thread_Memory *thread_memory;
HMODULE custom;
i64 performance_frequency;
i64 start_pcount;
};
globalvar Win32_Vars win32vars;
globalvar Application_Memory win32memory;
internal void
_OutDbgStr(u8 *msg){
OutputDebugString((char*)msg);
}
internal void
system_fatal_error(u8 *message){
MessageBox(0, (char*)message, "4ed Error", MB_OK|MB_ICONERROR);
}
internal File_Data
system_load_file(u8 *filename){
File_Data result = {};
HANDLE file;
file = CreateFile((char*)filename, GENERIC_READ, 0, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (!file){
return result;
}
DWORD lo, hi;
lo = GetFileSize(file, &hi);
if (hi != 0){
CloseHandle(file);
return result;
}
result.size = (lo) + (((u64)hi) << 32);
result.data = system_get_memory(result.size);
if (!result.data){
CloseHandle(file);
result = {};
return result;
}
DWORD read_size;
BOOL read_result = ReadFile(file, result.data, result.size,
&read_size, 0);
if (!read_result || read_size != result.size){
CloseHandle(file);
system_free_memory(result.data);
result = {};
return result;
}
CloseHandle(file);
return result;
}
internal bool32
system_save_file(u8 *filename, void *data, i32 size){
HANDLE file;
file = CreateFile((char*)filename, GENERIC_WRITE, 0, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if (!file){
return 0;
}
BOOL write_result;
DWORD bytes_written;
write_result = WriteFile(file, data, size, &bytes_written, 0);
CloseHandle(file);
if (!write_result || bytes_written != (u32)size){
return 0;
}
return 1;
}
internal Time_Stamp
system_file_time_stamp(u8 *filename){
Time_Stamp result;
result = {};
FILETIME last_write;
WIN32_FILE_ATTRIBUTE_DATA data;
if (GetFileAttributesEx((char*)filename, GetFileExInfoStandard, &data)){
last_write = data.ftLastWriteTime;
result.time = ((u64)last_write.dwHighDateTime << 32) | last_write.dwLowDateTime;
result.success = 1;
}
return result;
}
internal u64
system_get_now(){
u64 result;
SYSTEMTIME sys_now;
FILETIME file_now;
GetSystemTime(&sys_now);
SystemTimeToFileTime(&sys_now, &file_now);
result = ((u64)file_now.dwHighDateTime << 32) | file_now.dwLowDateTime;
return result;
}
internal void
system_free_file(File_Data data){
system_free_memory(data.data);
}
internal i32
system_get_working_directory(u8 *destination, i32 max_size){
DWORD required = GetCurrentDirectory(0, 0);
if ((i32) required > max_size){
// TODO(allen): WHAT NOW? Not enough space in destination for
// current directory. Two step approach perhaps?
return 0;
}
DWORD written = GetCurrentDirectory(max_size, (char*)destination);
return (i32)written;
}
internal i32
system_get_easy_directory(u8 *destination){
persist char easydir[] = "C:\\";
for (i32 i = 0; i < ArrayCount(easydir); ++i){
destination[i] = easydir[i];
}
return ArrayCount(easydir)-1;
}
internal File_List
system_get_files(String directory){
File_List result = {};
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);
result.block = system_get_memory(count + file_count * sizeof(File_Info));
result.infos = (File_Info*)result.block;
char *name = (char*)(result.infos + file_count);
if (result.block){
search = FindFirstFileA(c_str_dir, &find_data);
if (search != INVALID_HANDLE_VALUE){
File_Info *info = result.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;
char *name_base = name;
i32 i = 0;
for(;find_data.cFileName[i];++i) *name++ = find_data.cFileName[i];
info->filename.size = (i32)(name - name_base);
info->filename.memory_size = info->filename.size + 1;
*name++ = 0;
++info;
}
more_files = FindNextFile(search, &find_data);
}while(more_files);
FindClose(search);
result.count = file_count;
}else{
system_free_memory(result.block);
result = {};
}
}
}
}
return result;
}
internal void
system_free_file_list(File_List list){
system_free_memory(list.block);
}
#if FRED_INTERNAL
Sys_Bubble INTERNAL_sentinel;
internal Bubble*
INTERNAL_system_sentinel(){
return &INTERNAL_sentinel;
}
#endif
internal void*
system_get_memory_(i32 size, i32 line_number, char *file_name){
void *ptr = 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;
WaitForSingleObject(win32vars.DEBUG_sysmem_lock, INFINITE);
insert_bubble(&INTERNAL_sentinel, bubble);
ReleaseSemaphore(win32vars.DEBUG_sysmem_lock, 1, 0);
ptr = bubble + 1;
#else
ptr = VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#endif
return ptr;
}
internal void
system_free_memory(void *block){
if (block){
#if FRED_INTERNAL
Sys_Bubble *bubble = ((Sys_Bubble*)block) - 1;
Assert((bubble->flags & MEM_BUBBLE_DEBUG_MASK) == MEM_BUBBLE_SYS_DEBUG);
WaitForSingleObject(win32vars.DEBUG_sysmem_lock, INFINITE);
remove_bubble(bubble);
ReleaseSemaphore(win32vars.DEBUG_sysmem_lock, 1, 0);
VirtualFree(bubble, 0, MEM_RELEASE);
#else
VirtualFree(block, 0, MEM_RELEASE);
#endif
}
}
internal i64
system_time(){
i64 result = 0;
LARGE_INTEGER time;
if (QueryPerformanceCounter(&time)){
result = (i64)(time.QuadPart - win32vars.start_pcount) * 1000000 / win32vars.performance_frequency;
}
return result;
}
// TODO(allen): Probably best to just drop all system functions here again.
internal void
system_post_clipboard(String str){
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();
}
}
#if SOFTWARE_RENDER
internal void
Win32RedrawScreen(HDC hdc){
win32vars.bmp_info.bmiHeader.biHeight =
-win32vars.bmp_info.bmiHeader.biHeight;
SetDIBitsToDevice(hdc,
0, 0,
win32vars.width, win32vars.height,
0, 0,
0, win32vars.height,
win32vars.pixel_data,
&win32vars.bmp_info,
DIB_RGB_COLORS);
win32vars.bmp_info.bmiHeader.biHeight =
-win32vars.bmp_info.bmiHeader.biHeight;
}
#else
internal void
Win32RedrawScreen(HDC hdc){
glFlush();
SwapBuffers(hdc);
}
#endif
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
Win32KeyboardHandle(bool8 current_state, bool8 previous_state, WPARAM wParam){
u16 key = keycode_lookup((u8)wParam);
if (key != -1){
if (current_state & !previous_state){
i32 count = win32vars.input_data.press_count;
if (count < KEY_INPUT_BUFFER_SIZE){
win32vars.input_data.press[count].keycode = key;
win32vars.input_data.press[count].loose_keycode = loose_keycode_lookup((u8)wParam);
++win32vars.input_data.press_count;
}
}
else if (current_state){
i32 count = win32vars.input_data.hold_count;
if (count < KEY_INPUT_BUFFER_SIZE){
win32vars.input_data.hold[count].keycode = key;
win32vars.input_data.hold[count].loose_keycode = loose_keycode_lookup((u8)wParam);
++win32vars.input_data.hold_count;
}
}
}
}
#define HOTKEY_ALT_ID 0
internal LRESULT
Win32Callback(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam){
LRESULT result = {};
switch (uMsg){
case WM_MENUCHAR:
case WM_SYSCHAR:break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
{
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: break;
default:
bool8 previous_state, current_state;
previous_state = ((lParam & Bit_30)?(1):(0));
current_state = ((lParam & Bit_31)?(0):(1));
Win32KeyboardHandle(current_state, previous_state, wParam);
result = DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}break;
case WM_MOUSEMOVE:
{
win32vars.mouse.x = LOWORD(lParam);
win32vars.mouse.y = HIWORD(lParam);
}break;
case WM_MOUSEWHEEL:
{
i16 rotation = GET_WHEEL_DELTA_WPARAM(wParam);
if (rotation > 0){
win32vars.mouse.wheel = 1;
}
else{
win32vars.mouse.wheel = -1;
}
}break;
case WM_LBUTTONDOWN:
{
win32vars.mouse.left_button = true;
}break;
case WM_RBUTTONDOWN:
{
win32vars.mouse.right_button = true;
}break;
case WM_LBUTTONUP:
{
win32vars.mouse.left_button = false;
}break;
case WM_RBUTTONUP:
{
win32vars.mouse.right_button = false;
}break;
case WM_KILLFOCUS:
{
win32vars.focus = 0;
win32vars.mouse.left_button = false;
win32vars.mouse.right_button = false;
for (int i = 0; i < CONTROL_KEY_COUNT; ++i){
win32vars.input_data.control_keys[i] = 0;
}
}break;
case WM_SETFOCUS:
{
win32vars.focus = 1;
}break;
case WM_SIZE:
{
#if SOFTWARE_RENDER
i32 new_width = LOWORD(lParam);
i32 new_height = HIWORD(lParam);
i32 new_pitch = new_width * 4;
if (new_height*new_pitch > win32vars.true_pixel_size){
system_free_memory(win32vars.pixel_data);
win32vars.pixel_data = system_get_memory(new_height*new_pitch);
win32vars.true_pixel_size = new_height*new_pitch;
if (!win32vars.pixel_data){
FatalError("Failure allocating new screen memory");
win32vars.keep_playing = 0;
}
}
win32vars.width = new_width;
win32vars.height = new_height;
win32vars.pitch = new_pitch;
win32vars.bmp_info.bmiHeader.biWidth = win32vars.width;
win32vars.bmp_info.bmiHeader.biHeight = win32vars.height;
#else
if (win32vars.target.handle){
i32 new_width = LOWORD(lParam);
i32 new_height = HIWORD(lParam);
Win32Resize(new_width, new_height);
}
#endif
}break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwnd, &ps);
Clipboard_Contents empty_contents = {};
#if FRED_INTERNAL
INTERNAL_collecting_events = 0;
#endif
app_step(&win32vars.main_thread,
&win32vars.key_codes,
&win32vars.previous_data, &win32vars.mouse,
0, &win32vars.target, &win32memory, empty_contents, 0, 1);
#if FRED_INTERNAL
INTERNAL_collecting_events = 1;
#endif
Win32RedrawScreen(hdc);
EndPaint(hwnd, &ps);
}break;
case WM_CLOSE: // NOTE(allen): I expect WM_CLOSE not WM_DESTROY
case WM_DESTROY:
{
win32vars.keep_playing = 0;
}break;
default:
{
result = DefWindowProc(hwnd, uMsg, wParam, lParam);
}break;
}
return result;
}
#define THREAD_NOT_ASSIGNED 0xFFFFFFFF
#define JOB_ID_WRAP (ArrayCount(queue->jobs) * 4)
#define QUEUE_WRAP (ArrayCount(queue->jobs))
internal DWORD WINAPI
ThreadProc(LPVOID lpParameter){
Thread_Context *thread = (Thread_Context*)lpParameter;
Work_Queue *queue = thread->queue;
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;
Thread_Memory *thread_memory = 0;
if (full_job->job.memory_request != 0){
thread_memory = win32vars.thread_memory + thread->id - 1;
if (thread_memory->size < full_job->job.memory_request){
if (thread_memory->data){
system_free_memory(thread_memory->data);
}
i32 new_size = LargeRoundUp(full_job->job.memory_request, Kbytes(4));
thread_memory->data = system_get_memory(new_size);
thread_memory->size = new_size;
}
}
full_job->job.callback(thread, thread_memory, full_job->job.data);
full_job->running_thread = 0;
thread->running = 0;
}
}
}
else{
WaitForSingleObject(queue->semaphore, INFINITE);
}
}
}
internal bool32
Win32JobIsPending(Work_Queue *queue, u32 job_id){
bool32 result;
u32 job_index;
Full_Job_Data *full_job;
job_index = job_id % QUEUE_WRAP;
full_job = queue->jobs + job_index;
Assert(full_job->id == job_id);
result = 0;
if (full_job->running_thread != 0){
result = 1;
}
return result;
}
internal u32
system_thread_get_id(Thread_Context *thread){
return thread->id;
}
internal u32
system_thread_current_job_id(Thread_Context *thread){
return thread->job_id;
}
internal u32
system_post_job(Thread_Group_ID group_id, Job_Data job){
Work_Queue *queue = win32vars.queues + group_id;
Assert((queue->write_position + 1) % QUEUE_WRAP != queue->read_position % QUEUE_WRAP);
bool32 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(queue->semaphore, 1, 0);
return result;
}
internal void
system_cancel_job(Thread_Group_ID group_id, u32 job_id){
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;
Thread_Context *thread;
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){
system_aquire_lock(CANCEL_LOCK0 + thread_id - 1);
thread = group->threads + thread_id - 1;
TerminateThread(thread->handle, 0);
u32 creation_flag = 0;
thread->handle = CreateThread(0, 0, ThreadProc, thread, creation_flag, (LPDWORD)&thread->windows_id);
system_release_lock(CANCEL_LOCK0 + thread_id - 1);
thread->running = 0;
}
}
internal bool32
system_job_is_pending(Thread_Group_ID group_id, u32 job_id){
Work_Queue *queue = win32vars.queues + group_id;;
return Win32JobIsPending(queue, job_id);
}
internal void
system_aquire_lock(Lock_ID id){
WaitForSingleObject(win32vars.locks[id], INFINITE);
}
internal void
system_release_lock(Lock_ID id){
ReleaseSemaphore(win32vars.locks[id], 1, 0);
}
internal void
system_aquire_lock(i32 id){
WaitForSingleObject(win32vars.locks[id], INFINITE);
}
internal void
system_release_lock(i32 id){
ReleaseSemaphore(win32vars.locks[id], 1, 0);
}
internal void
system_grow_thread_memory(Thread_Memory *memory){
system_aquire_lock(CANCEL_LOCK0 + memory->id - 1);
void *old_data = memory->data;
i32 old_size = memory->size;
i32 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);
}
internal void
system_force_redraw(){
InterlockedExchange(&win32vars.force_redraw, 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
internal b32
system_cli_call(char *path, char *script_name, CLI_Handles *cli_out){
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);
append_partial(&s, make_lit_string(".bat "));
success = terminate_with_null(&s);
if (success){
success = 0;
SECURITY_ATTRIBUTES sec_attributes;
HANDLE out_read;
HANDLE out_write;
sec_attributes = {};
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;
}
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
}
}
else{
// TODO(allen): failed CreatePipe
}
}
return success;
}
struct CLI_Loop_Control{
u32 remaining_amount;
};
internal void
system_cli_begin_update(CLI_Handles *cli){
Assert(sizeof(cli->scratch_space) >= sizeof(CLI_Loop_Control));
CLI_Loop_Control *loop = (CLI_Loop_Control*)cli->scratch_space;
loop->remaining_amount = 0;
}
internal b32
system_cli_update_step(CLI_Handles *cli, char *dest, u32 max, u32 *amount){
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 b32
system_cli_end_update(CLI_Handles *cli){
b32 close_me = 0;
if (WaitForSingleObject(*(HANDLE*)&cli->proc, 0) == WAIT_OBJECT_0){
close_me = 1;
CloseHandle(*(HANDLE*)&cli->proc);
CloseHandle(*(HANDLE*)&cli->out_read);
CloseHandle(*(HANDLE*)&cli->out_write);
}
return close_me;
}
int
WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow){
win32vars = {};
TEMP = {};
LARGE_INTEGER lpf;
QueryPerformanceFrequency(&lpf);
win32vars.performance_frequency = lpf.QuadPart;
QueryPerformanceCounter(&lpf);
win32vars.start_pcount = lpf.QuadPart;
#if FRED_INTERNAL
memset(INTERNAL_event_hits, 0, INTERNAL_event_index_count * sizeof(u32));
INTERNAL_frame_index = 0;
INTERNAL_updating_profile = 1;
INTERNAL_collecting_events = 1;
INTERNAL_sentinel.next = &INTERNAL_sentinel;
INTERNAL_sentinel.prev = &INTERNAL_sentinel;
INTERNAL_sentinel.flags = MEM_BUBBLE_SYS_DEBUG;
#endif
keycode_init(&win32vars.key_codes, &win32vars.loose_codes);
#ifdef FRED_SUPER
win32vars.custom = LoadLibraryA("4coder_custom.dll");
if (win32vars.custom){
TEMP.get_bindings = (Get_Binding_Data_Function*)
GetProcAddress(win32vars.custom, "get_bindings");
TEMP.set_extra_font = (Set_Extra_Font_Function*)
GetProcAddress(win32vars.custom, "set_extra_font");
}
#endif
Thread_Context background[4];
memset(background, 0, sizeof(background));
win32vars.groups[BACKGROUND_THREADS].threads = background;
win32vars.groups[BACKGROUND_THREADS].count = ArrayCount(background);
Thread_Memory thread_memory[ArrayCount(background)];
win32vars.thread_memory = thread_memory;
win32vars.queues[BACKGROUND_THREADS].semaphore =
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_Memory *memory = win32vars.thread_memory + i;
*memory = {};
memory->id = thread->id;
thread->queue = &win32vars.queues[BACKGROUND_THREADS];
thread->handle = CreateThread(0, 0, ThreadProc, thread, creation_flag, (LPDWORD)&thread->windows_id);
}
Assert(win32vars.locks);
for (i32 i = 0; i < LOCK_COUNT; ++i){
win32vars.locks[i] = CreateSemaphore(0, 1, 1, 0);
}
win32vars.DEBUG_sysmem_lock = CreateSemaphore(0, 1, 1, 0);
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);
win32vars.prev_mouse_cursor = APP_MOUSE_CURSOR_ARROW;
WNDCLASS window_class = {};
window_class.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
window_class.lpfnWndProc = Win32Callback;
window_class.hInstance = hInstance;
window_class.lpszClassName = "4coder-win32-wndclass";
if (!RegisterClass(&window_class)){
// TODO(allen): diagnostics
FatalError("Failed to create window class");
return 1;
}
RECT window_rect = {};
window_rect.right = 800;
window_rect.bottom = 600;
if (!AdjustWindowRect(&window_rect, WS_OVERLAPPEDWINDOW, false)){
// TODO(allen): non-fatal diagnostics
}
#if SOFTWARE_RENDER
#define WINDOW_NAME "4coder-softrender-window"
#else
#define WINDOW_NAME "4coder-window"
#endif
HWND window_handle = {};
window_handle = CreateWindowA(
window_class.lpszClassName,
WINDOW_NAME,
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT/*x*/, CW_USEDEFAULT/*y*/,
window_rect.right - window_rect.left,
window_rect.bottom - window_rect.top,
0, 0, hInstance, 0);
if (!window_handle){
// TODO(allen): diagnostics
FatalError("Failed to create window");
return 2;
}
// TODO(allen): errors?
win32vars.window_handle = window_handle;
HDC hdc = GetDC(window_handle);
GetClientRect(window_handle, &window_rect);
#if SOFTWARE_RENDER
win32vars.width = window_rect.right - window_rect.left;
win32vars.height = window_rect.bottom - window_rect.top;
win32vars.pitch = win32vars.width*4;
#define bmi_header win32vars.bmp_info.bmiHeader
bmi_header = {};
bmi_header.biSize = sizeof(BITMAPINFOHEADER);
bmi_header.biWidth = win32vars.width;
bmi_header.biHeight = win32vars.height;
bmi_header.biPlanes = 1;
bmi_header.biBitCount = 32;
bmi_header.biCompression = BI_RGB;
#undef bmi_header
win32vars.true_pixel_size = win32vars.height*win32vars.pitch;
win32vars.pixel_data = system_get_memory(win32vars.true_pixel_size);
if (!win32vars.pixel_data){
FatalError("Failure allocating screen memory");
return 3;
}
#else
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);
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);
#endif
LPVOID base;
#if FRED_INTERNAL
base = (LPVOID)Tbytes(1);
#else
base = (LPVOID)0;
#endif
win32memory.vars_memory_size = Mbytes(2);
win32memory.vars_memory = VirtualAlloc(base, win32memory.vars_memory_size,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE);
#if FRED_INTERNAL
base = (LPVOID)Tbytes(2);
#else
base = (LPVOID)0;
#endif
win32memory.target_memory_size = Mbytes(512);
win32memory.target_memory = VirtualAlloc(base, win32memory.target_memory_size,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE);
if (!win32memory.vars_memory){
FatalError("Failure allocating application memory");
return 4;
}
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){
FatalError("Failure to access platform's clipboard");
}
}
else{
if (IsClipboardFormatAvailable(CF_TEXT)){
if (OpenClipboard(win32vars.window_handle)){
HANDLE clip_data;
clip_data = GetClipboardData(CF_TEXT);
if (clip_data){
win32vars.clipboard_contents.str = (u8*)GlobalLock(clip_data);
if (win32vars.clipboard_contents.str){
win32vars.clipboard_contents.size = str_size((char*)win32vars.clipboard_contents.str);
GlobalUnlock(clip_data);
}
}
CloseClipboard();
}
}
}
if (!app_init(&win32vars.main_thread,
&win32memory, &win32vars.key_codes,
win32vars.clipboard_contents)){
return 5;
}
win32vars.keep_playing = 1;
timeBeginPeriod(1);
system_aquire_lock(FRAME_LOCK);
Thread_Context *thread = &win32vars.main_thread;
AllowLocal(thread);
bool32 first = 1;
i64 timer_start = system_time();
while (win32vars.keep_playing){
#if FRED_INTERNAL
i64 dbg_procing_start = system_time();
if (!first){
if (INTERNAL_updating_profile){
i32 j = (INTERNAL_frame_index % 30);
Profile_Frame *frame = past_frames + j;
sort(&profile_frame.events);
frame->events.count = profile_frame.events.count;
memcpy(frame->events.e, profile_frame.events.e, sizeof(Debug_Event)*profile_frame.events.count);
past_frames[j].dbg_procing_start = profile_frame.dbg_procing_start;
past_frames[j].dbg_procing_end = profile_frame.dbg_procing_end;
past_frames[j].index = profile_frame.index;
past_frames[j].first_key = profile_frame.first_key;
++INTERNAL_frame_index;
if (INTERNAL_frame_index < 0){
INTERNAL_frame_index = ((INTERNAL_frame_index - 1) % 30) + 1;
}
memset(INTERNAL_event_hits, 0, INTERNAL_event_index_count * sizeof(u32));
}
}
profile_frame.events.count = 0;
profile_frame.first_key = -1;
profile_frame.index = INTERNAL_frame_index;
INTERNAL_frame_start_time = timer_start;
profile_frame.dbg_procing_start = (i32)(dbg_procing_start - INTERNAL_frame_start_time);
profile_frame.dbg_procing_end = (i32)(system_time() - INTERNAL_frame_start_time);
#endif
ProfileStart(OS_input);
win32vars.previous_data = win32vars.input_data;
win32vars.input_data.press_count = 0;
win32vars.input_data.hold_count = 0;
win32vars.input_data.caps_lock = GetKeyState(VK_CAPITAL) & 0x1;
win32vars.input_data.control_keys[CONTROL_KEY_SHIFT] = (GetKeyState(VK_SHIFT) & 0x0100) >> 8;
win32vars.input_data.control_keys[CONTROL_KEY_CONTROL] = (GetKeyState(VK_CONTROL) & 0x0100) >> 8;
win32vars.input_data.control_keys[CONTROL_KEY_ALT] = (GetKeyState(VK_MENU) & 0x0100) >> 8;
win32vars.mouse.left_button_prev = win32vars.mouse.left_button;
win32vars.mouse.right_button_prev = win32vars.mouse.right_button;
win32vars.mouse.wheel = 0;
MSG msg;
while (PeekMessage(&msg, window_handle, 0, 0, PM_REMOVE) && win32vars.keep_playing){
if (msg.message == WM_QUIT){
win32vars.keep_playing = 0;
}else{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (!win32vars.keep_playing){
break;
}
win32vars.mouse.out_of_window = 0;
POINT mouse_point;
if (GetCursorPos(&mouse_point) &&
ScreenToClient(window_handle, &mouse_point)){
if (mouse_point.x < 0 || mouse_point.x >= win32vars.target.width ||
mouse_point.y < 0 || mouse_point.y >= win32vars.target.height){
win32vars.mouse.out_of_window = 1;
}
}
else{
win32vars.mouse.out_of_window = 1;
}
b32 shift = win32vars.input_data.control_keys[CONTROL_KEY_SHIFT];
b32 caps_lock = win32vars.input_data.caps_lock;
for (i32 i = 0; i < win32vars.input_data.press_count; ++i){
i16 keycode = win32vars.input_data.press[i].keycode;
win32vars.input_data.press[i].character =
keycode_to_character_ascii(&win32vars.key_codes, keycode,
shift, caps_lock);
win32vars.input_data.press[i].character_no_caps_lock =
keycode_to_character_ascii(&win32vars.key_codes, keycode,
shift, 0);
}
for (i32 i = 0; i < win32vars.input_data.hold_count; ++i){
i16 keycode = win32vars.input_data.hold[i].keycode;
win32vars.input_data.hold[i].character =
keycode_to_character_ascii(&win32vars.key_codes, keycode,
shift, caps_lock);
win32vars.input_data.hold[i].character_no_caps_lock =
keycode_to_character_ascii(&win32vars.key_codes, keycode,
shift, 0);
}
win32vars.clipboard_contents = {};
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 if (IsClipboardFormatAvailable(CF_TEXT)){
if (OpenClipboard(win32vars.window_handle)){
HANDLE clip_data;
clip_data = GetClipboardData(CF_TEXT);
if (clip_data){
win32vars.clipboard_contents.str = (u8*)GlobalLock(clip_data);
if (win32vars.clipboard_contents.str){
win32vars.clipboard_contents.size = str_size((char*)win32vars.clipboard_contents.str);
GlobalUnlock(clip_data);
}
}
CloseClipboard();
}
}
}
}
i32 redraw = InterlockedExchange(&win32vars.force_redraw, 0);
ProfileEnd(OS_input);
Application_Step_Result result =
app_step(&win32vars.main_thread,
&win32vars.key_codes,
&win32vars.input_data, &win32vars.mouse,
1, &win32vars.target,
&win32memory,
win32vars.clipboard_contents,
first, redraw);
ProfileStart(OS_frame_out);
first = 0;
switch (result.mouse_cursor_type){
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;
}
if (result.redraw) Win32RedrawScreen(hdc);
ProfileEnd(OS_frame_out);
ProfileStart(frame_sleep);
i64 timer_end = system_time();
i64 end_target = (timer_start + FRAME_TIME);
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 = system_time();
}
system_aquire_lock(FRAME_LOCK);
timer_start = system_time();
ProfileEnd(frame_sleep);
}
return 0;
}
#if FRED_INTERNAL
const i32 INTERNAL_event_index_count = __COUNTER__;
u32 INTERNAL_event_hits[__COUNTER__];
#endif
// BOTTOM