diff --git a/4coder_base_types.cpp b/4coder_base_types.cpp index 94f3aea6..7ac891fc 100644 --- a/4coder_base_types.cpp +++ b/4coder_base_types.cpp @@ -24,6 +24,21 @@ round32(f32 v){ return(floor32(v + 0.5f)); } +static f32 +f32_ceil32(f32 v){ + return((f32)ceil32(v)); +} + +static f32 +f32_floor32(f32 v){ + return((f32)floor32(v)); +} + +static f32 +f32_round32(f32 v){ + return((f32)round32(v)); +} + static i8 round_up_i8(i8 x, i8 b){ x += b - 1; @@ -3342,6 +3357,59 @@ string_find_last(String_Const_u32 str, u32 c){ return(i); } +static umem +string_find_first_whitespace(String_Const_char str){ + umem i = 0; + for (;i < str.size && !character_is_whitespace(str.str[i]); i += 1); + return(i); +} +static umem +string_find_first_whitespace(String_Const_u8 str){ + umem i = 0; + for (;i < str.size && !character_is_whitespace(str.str[i]); i += 1); + return(i); +} +static umem +string_find_first_whitespace(String_Const_u16 str){ + umem i = 0; + for (;i < str.size && !character_is_whitespace(str.str[i]); i += 1); + return(i); +} +static umem +string_find_first_whitespace(String_Const_u32 str){ + umem i = 0; + for (;i < str.size && !character_is_whitespace(str.str[i]); i += 1); + return(i); +} +static imem +string_find_last_whitespace(String_Const_char str){ + imem size = (imem)str.size; + imem i = size - 1; + for (;i >= 0 && !character_is_whitespace(str.str[i]); i -= 1); + return(i); +} +static imem +string_find_last_whitespace(String_Const_u8 str){ + imem size = (imem)str.size; + imem i = size - 1; + for (;i >= 0 && !character_is_whitespace(str.str[i]); i -= 1); + return(i); +} +static imem +string_find_last_whitespace(String_Const_u16 str){ + imem size = (imem)str.size; + imem i = size - 1; + for (;i >= 0 && !character_is_whitespace(str.str[i]); i -= 1); + return(i); +} +static imem +string_find_last_whitespace(String_Const_u32 str){ + imem size = (imem)str.size; + imem i = size - 1; + for (;i >= 0 && !character_is_whitespace(str.str[i]); i -= 1); + return(i); +} + static umem string_find_first_non_whitespace(String_Const_char str){ umem i = 0; diff --git a/4coder_base_types.h b/4coder_base_types.h index c77f3004..ac52e465 100644 --- a/4coder_base_types.h +++ b/4coder_base_types.h @@ -102,6 +102,10 @@ #define OS_MAC 0 #endif +#if !defined(SHIP_MODE) +#define SHIP_MODE 0 +#endif + //////////////////////////////// #if COMPILER_CL @@ -160,6 +164,8 @@ typedef i64 imem; typedef float f32; typedef double f64; +typedef void Void_Func(void); + #define glue_(a,b) a##b #define glue(a,b) glue_(a,b) @@ -183,6 +189,7 @@ typedef double f64; #define Member(S,m) (((S*)0)->m) #define NullMember(S,m) (&Member(S,m)) #define OffsetOfMember(S,m) PtrAsInt(&Member(S,m)) +#define OffsetOfMemberStruct(s,m) PtrDif(&(s)->m, (s)) #define SizeAfterMember(S,m) (sizeof(S) - OffsetOfMember(S,m)) #define CastFromMember(S,m,ptr) (S*)( (u8*)(ptr) - OffsetOfMember(S,m) ) #define IntAsPtr(a) (void*)(((u8*)0) + a) diff --git a/4coder_generated/app_functions.h b/4coder_generated/app_functions.h index ec0b36a4..2791bd76 100644 --- a/4coder_generated/app_functions.h +++ b/4coder_generated/app_functions.h @@ -139,8 +139,6 @@ struct Application_Links; #define TRY_CREATE_NEW_FACE_SIG(n) Face_ID n(Application_Links *app, Face_Description *description) #define TRY_MODIFY_FACE_SIG(n) b32 n(Application_Links *app, Face_ID id, Face_Description *description) #define TRY_RELEASE_FACE_SIG(n) b32 n(Application_Links *app, Face_ID id, Face_ID replacement_id) -#define GET_AVAILABLE_FONT_COUNT_SIG(n) i32 n(Application_Links *app) -#define GET_AVAILABLE_FONT_SIG(n) Available_Font n(Application_Links *app, i32 index) #define SET_THEME_COLORS_SIG(n) void n(Application_Links *app, Theme_Color *colors, i32 count) #define GET_THEME_COLORS_SIG(n) void n(Application_Links *app, Theme_Color *colors, i32 count) #define FINALIZE_COLOR_SIG(n) argb_color n(Application_Links *app, int_color color) @@ -320,8 +318,6 @@ typedef GET_FACE_ID_SIG(Get_Face_ID_Function); typedef TRY_CREATE_NEW_FACE_SIG(Try_Create_New_Face_Function); typedef TRY_MODIFY_FACE_SIG(Try_Modify_Face_Function); typedef TRY_RELEASE_FACE_SIG(Try_Release_Face_Function); -typedef GET_AVAILABLE_FONT_COUNT_SIG(Get_Available_Font_Count_Function); -typedef GET_AVAILABLE_FONT_SIG(Get_Available_Font_Function); typedef SET_THEME_COLORS_SIG(Set_Theme_Colors_Function); typedef GET_THEME_COLORS_SIG(Get_Theme_Colors_Function); typedef FINALIZE_COLOR_SIG(Finalize_Color_Function); @@ -503,8 +499,6 @@ Get_Face_ID_Function *get_face_id; Try_Create_New_Face_Function *try_create_new_face; Try_Modify_Face_Function *try_modify_face; Try_Release_Face_Function *try_release_face; -Get_Available_Font_Count_Function *get_available_font_count; -Get_Available_Font_Function *get_available_font; Set_Theme_Colors_Function *set_theme_colors; Get_Theme_Colors_Function *get_theme_colors; Finalize_Color_Function *finalize_color; @@ -685,8 +679,6 @@ Get_Face_ID_Function *get_face_id_; Try_Create_New_Face_Function *try_create_new_face_; Try_Modify_Face_Function *try_modify_face_; Try_Release_Face_Function *try_release_face_; -Get_Available_Font_Count_Function *get_available_font_count_; -Get_Available_Font_Function *get_available_font_; Set_Theme_Colors_Function *set_theme_colors_; Get_Theme_Colors_Function *get_theme_colors_; Finalize_Color_Function *finalize_color_; @@ -875,8 +867,6 @@ app_links->get_face_id_ = Get_Face_ID;\ app_links->try_create_new_face_ = Try_Create_New_Face;\ app_links->try_modify_face_ = Try_Modify_Face;\ app_links->try_release_face_ = Try_Release_Face;\ -app_links->get_available_font_count_ = Get_Available_Font_Count;\ -app_links->get_available_font_ = Get_Available_Font;\ app_links->set_theme_colors_ = Set_Theme_Colors;\ app_links->get_theme_colors_ = Get_Theme_Colors;\ app_links->finalize_color_ = Finalize_Color;\ @@ -1057,8 +1047,6 @@ static Face_ID get_face_id(Application_Links *app, Buffer_ID buffer_id){return(a static Face_ID try_create_new_face(Application_Links *app, Face_Description *description){return(app->try_create_new_face(app, description));} static b32 try_modify_face(Application_Links *app, Face_ID id, Face_Description *description){return(app->try_modify_face(app, id, description));} static b32 try_release_face(Application_Links *app, Face_ID id, Face_ID replacement_id){return(app->try_release_face(app, id, replacement_id));} -static i32 get_available_font_count(Application_Links *app){return(app->get_available_font_count(app));} -static Available_Font get_available_font(Application_Links *app, i32 index){return(app->get_available_font(app, index));} static void set_theme_colors(Application_Links *app, Theme_Color *colors, i32 count){(app->set_theme_colors(app, colors, count));} static void get_theme_colors(Application_Links *app, Theme_Color *colors, i32 count){(app->get_theme_colors(app, colors, count));} static argb_color finalize_color(Application_Links *app, int_color color){return(app->finalize_color(app, color));} @@ -1239,8 +1227,6 @@ static Face_ID get_face_id(Application_Links *app, Buffer_ID buffer_id){return(a static Face_ID try_create_new_face(Application_Links *app, Face_Description *description){return(app->try_create_new_face_(app, description));} static b32 try_modify_face(Application_Links *app, Face_ID id, Face_Description *description){return(app->try_modify_face_(app, id, description));} static b32 try_release_face(Application_Links *app, Face_ID id, Face_ID replacement_id){return(app->try_release_face_(app, id, replacement_id));} -static i32 get_available_font_count(Application_Links *app){return(app->get_available_font_count_(app));} -static Available_Font get_available_font(Application_Links *app, i32 index){return(app->get_available_font_(app, index));} static void set_theme_colors(Application_Links *app, Theme_Color *colors, i32 count){(app->set_theme_colors_(app, colors, count));} static void get_theme_colors(Application_Links *app, Theme_Color *colors, i32 count){(app->get_theme_colors_(app, colors, count));} static argb_color finalize_color(Application_Links *app, int_color color){return(app->finalize_color_(app, color));} diff --git a/4coder_table.cpp b/4coder_table.cpp index 8802c4cd..e7d81f7b 100644 --- a/4coder_table.cpp +++ b/4coder_table.cpp @@ -15,6 +15,9 @@ global_const u64 table_erased_slot = 1; global_const u64 table_empty_key = 0; global_const u64 table_erased_key = max_u64; +global_const u32 table_empty_u32_key = 0; +global_const u32 table_erased_u32_key = max_u32; + //////////////////////////////// internal Table_u64_u64 @@ -160,6 +163,148 @@ table_erase(Table_u64_u64 *table, u64 key){ //////////////////////////////// +internal Table_u32_u16 +make_table_u32_u16(Base_Allocator *allocator, u32 slot_count){ + Table_u32_u16 table = {}; + table.allocator = allocator; + slot_count = clamp_bot(8, slot_count); + Data mem = base_allocate(allocator, slot_count*(sizeof(*table.keys) + sizeof(*table.vals))); + block_zero(mem.data, mem.size); + table.memory = mem.data; + table.keys = (u32*)table.memory; + table.vals = (u16*)(table.keys + slot_count); + table.slot_count = slot_count; + table.used_count = 0; + table.dirty_count = 0; + return(table); +} + +internal void +table_free(Table_u32_u16 *table){ + base_free(table->allocator, table->memory); + block_zero_struct(table); +} + +internal Table_Lookup +table_lookup(Table_u32_u16 *table, u32 key){ + Table_Lookup result = {}; + + if (key != table_empty_u32_key && key != table_erased_u32_key){ + u32 *keys = table->keys; + u32 slot_count = table->slot_count; + + u32 first_index = key % slot_count; + u32 index = first_index; + result.hash = key; + for (;;){ + if (key == keys[index]){ + result.index = index; + result.found_match = true; + result.found_empty_slot = false; + result.found_erased_slot = false; + break; + } + if (table_empty_u32_key == keys[index]){ + result.index = index; + result.found_empty_slot = true; + result.found_erased_slot = false; + break; + } + if (table_erased_u32_key == keys[index] && !result.found_erased_slot){ + result.index = index; + result.found_erased_slot = true; + } + index += 1; + if (index >= slot_count){ + index = 0; + } + if (index == first_index){ + break; + } + } + } + + return(result); +} + +internal b32 +table_read(Table_u32_u16 *table, u32 key, u16 *val_out){ + b32 result = false; + Table_Lookup lookup = table_lookup(table, key); + if (lookup.found_match){ + *val_out = table->vals[lookup.index]; + result = true; + } + return(result); +} + +internal void +table_insert__inner(Table_u32_u16 *table, Table_Lookup lookup, u32 key, u16 val){ + Assert(lookup.found_empty_slot || lookup.found_erased_slot); + table->keys[lookup.index] = key; + table->vals[lookup.index] = val; + table->used_count += 1; + if (lookup.found_empty_slot){ + table->dirty_count += 1; + } +} + +internal b32 +table_rehash(Table_u32_u16 *dst, Table_u32_u16 *src){ + b32 result = false; + u32 src_slot_count = src->slot_count; + if ((dst->dirty_count + src->used_count)*8 < dst->slot_count*7){ + u32 *src_keys = src->keys; + for (u32 i = 0; i < src_slot_count; i += 1){ + u32 key = src_keys[i]; + if (key != table_empty_u32_key && key != table_erased_u32_key){ + Table_Lookup lookup = table_lookup(dst, key); + table_insert__inner(dst, lookup, key, src->vals[i]); + } + } + result = true; + } + return(result); +} + +internal b32 +table_insert(Table_u32_u16 *table, u32 key, u16 val){ + b32 result = false; + Table_Lookup lookup = table_lookup(table, key); + if (!lookup.found_match){ + if ((table->dirty_count + 1)*8 >= table->slot_count*7){ + i32 new_slot_count = table->slot_count; + if (table->used_count*2 >= table->slot_count){ + new_slot_count = table->slot_count*4; + } + Table_u32_u16 new_table = make_table_u32_u16(table->allocator, new_slot_count); + table_rehash(&new_table, table); + table_free(table); + *table = new_table; + lookup = table_lookup(table, key); + Assert(lookup.found_empty_slot); + } + table_insert__inner(table, lookup, key, val); + result = true; + } + return(result); +} + +internal b32 +table_erase(Table_u32_u16 *table, u32 key){ + b32 result = false; + Table_Lookup lookup = table_lookup(table, key); + if (lookup.found_match){ + table->keys[lookup.index] = 0; + table->vals[lookup.index] = 0; + table->used_count -= 1; + result = true; + } + return(result); +} + +//////////////////////////////// + internal Table_Data_u64 make_table_Data_u64(Base_Allocator *allocator, u32 slot_count){ Table_Data_u64 table = {}; diff --git a/4coder_table.h b/4coder_table.h index 1a5be8ec..c8f211a4 100644 --- a/4coder_table.h +++ b/4coder_table.h @@ -25,6 +25,16 @@ struct Table_u64_u64{ u32 dirty_count; }; +struct Table_u32_u16{ + Base_Allocator *allocator; + void *memory; + u32 *keys; + u16 *vals; + u32 slot_count; + u32 used_count; + u32 dirty_count; +}; + struct Table_Data_u64{ Base_Allocator *allocator; void *memory; diff --git a/4ed_api_implementation.cpp b/4ed_api_implementation.cpp index 303e6f08..e679e88d 100644 --- a/4ed_api_implementation.cpp +++ b/4ed_api_implementation.cpp @@ -775,9 +775,12 @@ DOC_SEE(Buffer_Setting_ID) new_value = 48; } if (new_value != file->settings.display_width){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); +#endif + Face *face = 0; file->settings.display_width = new_value; - file_measure_wraps(system, &models->mem, file, font); + file_measure_wraps(system, &models->mem, file, face); adjust_views_looking_at_file_to_new_cursor(system, models, file); } }break; @@ -789,9 +792,12 @@ DOC_SEE(Buffer_Setting_ID) new_value = 0; } if (new_value != file->settings.minimum_base_display_width){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); +#endif + Face *face = 0; file->settings.minimum_base_display_width = new_value; - file_measure_wraps(system, &models->mem, file, font); + file_measure_wraps(system, &models->mem, file, face); adjust_views_looking_at_file_to_new_cursor(system, models, file); } }break; @@ -867,11 +873,14 @@ DOC_SEE(Buffer_Setting_ID) } if (full_remeasure){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); +#endif + Face *face = 0; file_allocate_character_starts_as_needed(&models->mem.heap, file); - buffer_measure_character_starts(system, font, &file->state.buffer, file->state.character_starts, 0, file->settings.virtual_white); - file_measure_wraps(system, &models->mem, file, font); + buffer_measure_character_starts(system, &file->state.buffer, file->state.character_starts, 0, file->settings.virtual_white); + file_measure_wraps(system, &models->mem, file, face); adjust_views_looking_at_file_to_new_cursor(system, models, file); } }break; @@ -2928,7 +2937,11 @@ DOC_RETURN(Returns the largest face ID that could be valid. There is no guarant */ { Models *models = (Models*)app->cmd_context; + Face_ID result = 0; +#if 0 Face_ID result = models->system->font.get_largest_id(); +#endif + NotImplemented; return(result); } @@ -2946,6 +2959,8 @@ DOC_RETURN(Returns true if the given id was a valid face and the change was made b32 did_change = false; + NotImplemented; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(id); if (font.valid){ did_change = true; @@ -2957,6 +2972,7 @@ DOC_RETURN(Returns true if the given id was a valid face and the change was made models->global_font_id = id; } } +#endif return(did_change); } @@ -3132,26 +3148,26 @@ Global_History_Edit_Group_End(Application_Links *app){ } internal void -font_pointers_to_face_description(Font_Pointers font, Face_Description *description){ - Font_Metrics *metrics = font.metrics; - umem len = cstring_length(metrics->name); - block_copy(description->font.name, metrics->name, len); +face_to_face_description(Face *face, Face_Description *description){ + umem size = clamp_top(face->name.size, sizeof(description->font.name) - 1); + block_copy(description->font.name, face->name.str, size); + description->font.name[size] = 0; + description->font.in_local_font_folder = face->settings.stub.in_font_folder; - Font_Settings *settings = font.settings; - description->font.in_local_font_folder = settings->stub.in_font_folder; - description->pt_size = settings->parameters.pt_size; - description->bold = settings->parameters.bold; - description->italic = settings->parameters.italics; - description->underline = settings->parameters.underline; - description->hinting = settings->parameters.use_hinting; + description->pt_size = face->settings.parameters.pt_size; + description->bold = face->settings.parameters.bold; + description->italic = face->settings.parameters.italics; + description->underline = face->settings.parameters.underline; + description->hinting = face->settings.parameters.use_hinting; } internal b32 -face_description_to_settings(System_Functions *system, Face_Description description, Font_Settings *settings){ +face_description_to_settings(System_Functions *system, Face_Description description, Face_Settings *settings){ b32 success = false; String_Const_u8 desc_name = SCu8(description.font.name); if (description.font.in_local_font_folder){ +#if 0 i32 count = system->font.get_loadable_count(); for (i32 i = 0; i < count; ++i){ Font_Loadable_Description loadable = {}; @@ -3170,6 +3186,7 @@ face_description_to_settings(System_Functions *system, Face_Description descript } } } +#endif } else{ success = true; @@ -3206,11 +3223,18 @@ DOC_RETURN(Returns true if the given id was a valid face and the change was made b32 did_change = false; if (api_check_buffer(file)){ System_Functions *system = models->system; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(id); if (font.valid){ did_change = true; file_set_font(system, models, file, id); } +#endif + Face *face = 0; + if (face != 0){ + did_change = true; + file_set_font(system, models, file, id); + } } return(did_change); } @@ -3232,11 +3256,18 @@ DOC_SEE(Face_Description) System_Functions *system = models->system; Face_Description description = {}; if (id != 0){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(id); if (font.valid){ font_pointers_to_face_description(font, &description); Assert(description.font.name[0] != 0); } +#endif + Face *face = 0; + if (face != 0){ + face_to_face_description(face, &description); + Assert(description.font.name[0] != 0); + } } else{ description.pt_size = models->settings.font_size; @@ -3251,11 +3282,18 @@ Get_Face_Metrics(Application_Links *app, Face_ID face_id){ System_Functions *system = models->system; Face_Metrics result = {}; if (face_id != 0){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(face_id); if (font.valid){ result.line_height = (f32)font.metrics->height; result.typical_character_width = font.metrics->sub_advances[1]; } +#endif + Face *face = 0; + if (face != 0){ + result.line_height = (f32)face->height; + result.typical_character_width = face->sub_advances[1]; + } } return(result); } @@ -3303,9 +3341,12 @@ DOC_SEE(Face_Description) Models *models = (Models*)app->cmd_context; System_Functions *system = models->system; Face_ID id = 0; - Font_Settings settings; + Face_Settings settings = {}; if (face_description_to_settings(system, *description, &settings)){ +#if 0 id = system->font.face_allocate_and_init(&settings); +#endif + NotImplemented; } return(id); } @@ -3327,7 +3368,7 @@ DOC_SEE(try_create_new_face) Models *models = (Models*)app->cmd_context; System_Functions *system = models->system; b32 success = false; - Font_Settings settings; + Face_Settings settings = {}; if (face_description_to_settings(system, *description, &settings)){ if (alter_font_and_update_files(system, models, id, &settings)){ success = true; @@ -3354,37 +3395,6 @@ DOC_RETURN(Returns true on success and zero on failure.) return(success); } -API_EXPORT i32 -Get_Available_Font_Count(Application_Links *app) -/* -DOC(An available font is a font that the 4coder font system detected on initialization. Available fonts either come from the font folder in the same path as the 4ed executable, or from the system fonts. Attempting to load fonts not in returned by available fonts will likely fail, but is permitted. Available fonts are not updated after initialization. Just because a font is returned by the available font system does not necessarily mean that it can be loaded.) -DOC_RETURN(Returns the number of available fonts that the user can query.) -*/ -{ - Models *models = (Models*)app->cmd_context; - i32 count = models->system->font.get_loadable_count(); - return(count); -} - -API_EXPORT Available_Font -Get_Available_Font(Application_Links *app, i32 index) -/* -DOC_PARAM(index, The index of the available font to retrieve. Must be in the range [0,count-1] where count is the value returned by get_available_font_count.) -DOC_RETURN(Returns a valid Available_Font if index is in the required range. Otherwise returns an invalid Available_Font. An Available_Font is valid if and only if it's name field contains a string with a non-zero length (i.e. font.name[0] != 0)) -DOC_SEE(get_available_font_count) -*/ -{ - Models *models = (Models*)app->cmd_context; - Available_Font available = {}; - Font_Loadable_Description description = {}; - models->system->font.get_loadable(index, &description); - if (description.valid){ - memcpy(available.name, description.display_name, description.display_len); - available.in_local_font_folder = description.stub.in_font_folder; - } - return(available); -} - API_EXPORT void Set_Theme_Colors(Application_Links *app, Theme_Color *colors, i32 count) /* @@ -3933,7 +3943,10 @@ Compute_Render_Layout(Application_Links *app, View_ID view_id, Buffer_ID buffer_ b32 wrapped = !file->settings.unwrapped_lines; Face_ID font_id = file->settings.font_id; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(font_id); +#endif + Face *face = 0; Full_Cursor intermediate_cursor = file_compute_cursor(system, file, seek_line_char(buffer_point.line_number, 1)); f32 scroll_x = buffer_point.pixel_shift.x; @@ -3962,7 +3975,7 @@ Compute_Render_Layout(Application_Links *app, View_ID view_id, Buffer_ID buffer_ params.start_cursor = render_cursor; params.wrapped = wrapped; params.system = system; - params.font = font; + params.face = face; params.virtual_white = file->settings.virtual_white; params.wrap_slashes = file->settings.wrap_indicator; params.one_past_last_abs_pos = one_past_last; diff --git a/4ed_app_target.cpp b/4ed_app_target.cpp index 345720fc..c99165de 100644 --- a/4ed_app_target.cpp +++ b/4ed_app_target.cpp @@ -17,9 +17,9 @@ #include "4coder_API/4coder_custom.h" #include "4coder_base_types.h" +#include "4coder_table.h" #include "4ed_font.h" #include "4ed_system.h" -#include "4coder_table.h" #include "4coder_base_types.cpp" #include "4coder_string_match.cpp" @@ -47,7 +47,6 @@ struct Mem_Options{ #define FCPP_FORBID_MALLOC #include "4coder_lib/4cpp_lexer.h" -#include "4ed_log.h" #include "4ed_ptr_check.h" #include "4ed_memory_bank.h" #include "4ed_dynamic_variables.h" diff --git a/4ed_buffer.cpp b/4ed_buffer.cpp index 9fece7c9..192e4cde 100644 --- a/4ed_buffer.cpp +++ b/4ed_buffer.cpp @@ -676,7 +676,7 @@ buffer_measure_starts(Buffer_Measure_Starts *state, Gap_Buffer *buffer){ } internal void -buffer_measure_character_starts(System_Functions *system, Font_Pointers font, Gap_Buffer *buffer, i32 *character_starts, i32 mode, i32 virtual_white){ +buffer_measure_character_starts(System_Functions *system, Gap_Buffer *buffer, i32 *character_starts, i32 mode, i32 virtual_white){ Assert(mode == 0); Gap_Buffer_Stream stream = {}; @@ -705,7 +705,7 @@ buffer_measure_character_starts(System_Functions *system, Font_Pointers font, Ga for (; i < stream.end; ++i){ u8 ch = (u8)stream.data[i]; - translating_fully_process_byte(system, font, &tran, ch, i, size, &emits); + translating_fully_process_byte(system, &tran, ch, i, size, &emits); for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ TRANSLATION_DECL_GET_STEP(step, behavior, J, emits); @@ -781,7 +781,7 @@ buffer_measure_wrap_y(Buffer_Measure_Wrap_State *S_ptr, Buffer_Measure_Wrap_Para S.skipping_whitespace = false; } - translating_fully_process_byte(params.system, params.font, &S.tran, ch, S.i, S.size, &S.emits); + translating_fully_process_byte(params.system, &S.tran, ch, S.i, S.size, &S.emits); } for (TRANSLATION_EMIT_LOOP(S.J, S.emits)){ @@ -809,10 +809,10 @@ buffer_measure_wrap_y(Buffer_Measure_Wrap_State *S_ptr, Buffer_Measure_Wrap_Para else if (S.behavior.do_number_advance || S.behavior.do_codepoint_advance){ if (!S.skipping_whitespace){ if (S.behavior.do_codepoint_advance){ - S.current_adv = font_get_glyph_advance(params.system, params.font.settings, params.font.metrics, params.font.pages, S.step.value); + S.current_adv = font_get_glyph_advance(params.system, params.face, S.step.value); } else{ - S.current_adv = params.font.metrics->byte_advance; + S.current_adv = params.face->byte_advance; } S.did_wrap = false; @@ -942,7 +942,7 @@ buffer_remeasure_starts(Gap_Buffer *buffer, i32 line_start, i32 line_end, i32 li } internal void -buffer_remeasure_character_starts(System_Functions *system, Font_Pointers font, Gap_Buffer *buffer, i32 line_start, i32 line_end, i32 line_shift, i32 *character_starts, i32 mode, i32 virtual_whitespace){ +buffer_remeasure_character_starts(System_Functions *system, Gap_Buffer *buffer, i32 line_start, i32 line_end, i32 line_shift, i32 *character_starts, i32 mode, i32 virtual_whitespace){ Assert(mode == 0); i32 new_line_count = buffer->line_count; @@ -990,7 +990,7 @@ buffer_remeasure_character_starts(System_Functions *system, Font_Pointers font, do{ for (; char_i < stream.end; ++char_i){ u8 ch = (u8)stream.data[char_i]; - translating_fully_process_byte(system, font, &tran, ch, char_i, size, &emits); + translating_fully_process_byte(system, &tran, ch, char_i, size, &emits); for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ TRANSLATION_DECL_GET_STEP(step, behavior, J, emits); @@ -1260,7 +1260,7 @@ buffer_cursor_seek(Buffer_Cursor_Seek_State *S_ptr, Buffer_Cursor_Seek_Params pa DrCase(4); } - S.font_height = params.font.metrics->height; + S.font_height = (i32)(params.face->height); S.xy_seek = (params.seek.type == buffer_seek_wrapped_xy || params.seek.type == buffer_seek_unwrapped_xy); S.size = buffer_size(params.buffer); @@ -1417,7 +1417,7 @@ buffer_cursor_seek(Buffer_Cursor_Seek_State *S_ptr, Buffer_Cursor_Seek_Params pa for (; S.i < S.stream.end; ++S.i){ { u8 ch = (u8)S.stream.data[S.i]; - translating_fully_process_byte(params.system, params.font, &S.tran, ch, S.i, S.size, &S.emits); + translating_fully_process_byte(params.system, &S.tran, ch, S.i, S.size, &S.emits); } for (TRANSLATION_EMIT_LOOP(S.J, S.emits)){ @@ -1448,10 +1448,10 @@ buffer_cursor_seek(Buffer_Cursor_Seek_State *S_ptr, Buffer_Cursor_Seek_Params pa else if (S.behavior.do_number_advance || S.behavior.do_codepoint_advance){ if (S.behavior.do_codepoint_advance){ - S.ch_width = font_get_glyph_advance(params.system, params.font.settings, params.font.metrics, params.font.pages, S.step.value); + S.ch_width = font_get_glyph_advance(params.system, params.face, S.step.value); } else{ - S.ch_width = params.font.metrics->byte_advance; + S.ch_width = params.face->byte_advance; } if (S.step.i >= S.wrap_unit_end){ @@ -1628,7 +1628,7 @@ internal Render_Item_Write write_render_item(Render_Item_Write write, i32 index, u32 codepoint, u32 flags, Render_Item_Flag render_flags){ if (write.item < write.item_end){ - f32 ch_width = font_get_glyph_advance(write.system, write.font.settings, write.font.metrics, write.font.pages, codepoint); + f32 ch_width = font_get_glyph_advance(write.system, write.face, codepoint); b32 visible_on_layout = (write.x_min <= write.x + ch_width && write.x <= write.x_max); @@ -1695,12 +1695,12 @@ buffer_render_data(Buffer_Render_State *S_ptr, Buffer_Render_Params params, f32 S.write.x = S.shift_x + line_shift; S.write.y = S.shift_y; S.write.system = params.system; - S.write.font = params.font; - S.write.font_height = params.font.metrics->height; + S.write.face = params.face; + S.write.font_height = (i32)params.face->height; S.write.x_min = params.port_x; S.write.x_max = params.port_x + params.clip_w; - S.byte_advance = params.font.metrics->byte_advance; + S.byte_advance = params.face->byte_advance; if (params.virtual_white){ S.skipping_whitespace = true; @@ -1714,7 +1714,7 @@ buffer_render_data(Buffer_Render_State *S_ptr, Buffer_Render_Params params, f32 for (; S.i < S.stream.end; ++S.i){ { u8 ch = (u8)S.stream.data[S.i]; - translating_fully_process_byte(params.system, params.font, &S.tran, ch, S.i, S.size, &S.emits); + translating_fully_process_byte(params.system, &S.tran, ch, S.i, S.size, &S.emits); } for (TRANSLATION_EMIT_LOOP(S.J, S.emits)){ @@ -1814,9 +1814,7 @@ buffer_render_data(Buffer_Render_State *S_ptr, Buffer_Render_Params params, f32 case '\t': { - S.ch_width = font_get_glyph_advance(params.system, params.font.settings, - params.font.metrics, params.font.pages, - '\t'); + S.ch_width = font_get_glyph_advance(params.system, params.face, '\t'); f32 new_x = S.write.x + S.ch_width; S.write = write_render_item(S.write, I, ' ', 0, flags); diff --git a/4ed_buffer.h b/4ed_buffer.h index fd0ef537..2f05bc97 100644 --- a/4ed_buffer.h +++ b/4ed_buffer.h @@ -90,7 +90,7 @@ struct Buffer_Measure_Wrap_Params{ Gap_Buffer *buffer; i32 *wrap_line_index; System_Functions *system; - Font_Pointers font; + Face *face; b32 virtual_white; }; @@ -124,7 +124,7 @@ struct Buffer_Cursor_Seek_Params{ Gap_Buffer *buffer; Buffer_Seek seek; System_Functions *system; - Font_Pointers font; + Face *face; i32 *wrap_line_index; i32 *character_starts; b32 virtual_white; @@ -186,7 +186,7 @@ struct Render_Item_Write{ f32 x; f32 y; System_Functions *system; - Font_Pointers font; + Face *face; i32 font_height; f32 x_min; f32 x_max; @@ -207,7 +207,7 @@ struct Buffer_Render_Params{ Full_Cursor start_cursor; i32 wrapped; System_Functions *system; - Font_Pointers font; + Face *face; b32 virtual_white; i32 wrap_slashes; i32 one_past_last_abs_pos; diff --git a/4ed_code_wrap.cpp b/4ed_code_wrap.cpp index 881960d6..885b573a 100644 --- a/4ed_code_wrap.cpp +++ b/4ed_code_wrap.cpp @@ -10,7 +10,7 @@ // TOP internal void -wrap_state_init(System_Functions *system, Code_Wrap_State *state, Editing_File *file, Font_Pointers font){ +wrap_state_init(System_Functions *system, Code_Wrap_State *state, Editing_File *file, Face *face){ state->token_array = file->state.token_array; state->token_ptr = state->token_array.tokens; state->end_token = state->token_ptr + state->token_array.count; @@ -25,10 +25,10 @@ wrap_state_init(System_Functions *system, Code_Wrap_State *state, Editing_File * state->size = size; state->i = 0; - state->font = font; + state->face = face; - state->tab_indent_amount = font_get_glyph_advance(system, font.settings, font.metrics, font.pages, '\t'); - state->byte_advance = font.metrics->byte_advance; + state->tab_indent_amount = font_get_glyph_advance(system, face, '\t'); + state->byte_advance = face->byte_advance; state->tran = null_buffer_translating_state; } @@ -41,7 +41,7 @@ wrap_state_set_top(Code_Wrap_State *state, f32 line_shift){ } internal Code_Wrap_Step -wrap_state_consume_token(System_Functions *system, Font_Pointers font, Code_Wrap_State *state, i32 fixed_end_point){ +wrap_state_consume_token(System_Functions *system, Face *face, Code_Wrap_State *state, i32 fixed_end_point){ Code_Wrap_Step result = {}; i32 i = state->i; @@ -123,7 +123,7 @@ wrap_state_consume_token(System_Functions *system, Font_Pointers font, Code_Wrap } u8 ch = (u8)state->stream.data[i]; - translating_fully_process_byte(system, font, &state->tran, ch, i, state->size, &state->emits); + translating_fully_process_byte(system, &state->tran, ch, i, state->size, &state->emits); for (TRANSLATION_EMIT_LOOP(state->J, state->emits)){ TRANSLATION_GET_STEP(state->step, state->behavior, state->J, state->emits); @@ -136,7 +136,7 @@ wrap_state_consume_token(System_Functions *system, Font_Pointers font, Code_Wrap u32 n = state->step.value; f32 adv = 0; if (state->behavior.do_codepoint_advance){ - adv = font_get_glyph_advance(system, state->font.settings, state->font.metrics, state->font.pages, n); + adv = font_get_glyph_advance(system, state->face, n); if (n != ' ' && n != '\t'){ skipping_whitespace = false; @@ -439,7 +439,7 @@ get_current_shift(Code_Wrap_State *wrap_state, i32 next_line_start){ } internal void -file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *file, Font_Pointers font){ +file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *file, Face *face){ Heap *heap = &mem->heap; Arena *scratch = &mem->arena; @@ -453,7 +453,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil params.buffer = &file->state.buffer; params.wrap_line_index = file->state.wrap_line_index; params.system = system; - params.font = font; + params.face = face; params.virtual_white = file->settings.virtual_white; f32 width = (f32)file->settings.display_width; @@ -484,7 +484,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil i32 max_wrap_indent_mark = Million(1); if (params.virtual_white && file->state.tokens_complete && !file->state.still_lexing){ - wrap_state_init(system, &wrap_state, file, font); + wrap_state_init(system, &wrap_state, file, face); use_tokens = true; potential_marks = push_array(scratch, Potential_Wrap_Indent_Pair, floor32(width)); @@ -531,7 +531,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil for (; i < stream.end; ++i){ { u8 ch = stream.data[i]; - translating_fully_process_byte(system, font, &tran, ch, i, size, &emits); + translating_fully_process_byte(system, &tran, ch, i, size, &emits); } for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ @@ -545,7 +545,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil word_stage = 1; } else{ - f32 adv = font_get_glyph_advance(params.system, params.font.settings, params.font.metrics, params.font.pages, codepoint); + f32 adv = font_get_glyph_advance(params.system, params.face, codepoint); x += adv; self_x += adv; @@ -659,7 +659,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil for (; i < stream.end; ++i){ { u8 ch = stream.data[i]; - translating_fully_process_byte(system, font, &tran, ch, i, end_i, &emits); + translating_fully_process_byte(system, &tran, ch, i, end_i, &emits); } for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ @@ -680,7 +680,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil for (; i < stream.end; ++i){ { u8 ch = stream.data[i]; - translating_fully_process_byte(system, font, &tran, ch, i, end_i, &emits); + translating_fully_process_byte(system, &tran, ch, i, end_i, &emits); } for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ @@ -690,7 +690,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil goto doublebreak_stage1; } - f32 adv = font_get_glyph_advance(params.system, params.font.settings, params.font.metrics, params.font.pages, buffer_step.value); + f32 adv = font_get_glyph_advance(params.system, params.face, buffer_step.value); x += adv; if (!first_word && x > current_width){ @@ -715,7 +715,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil for (; i < stream.end; ++i){ { u8 ch = stream.data[i]; - translating_fully_process_byte(system, font, &tran, ch, i, end_i, &emits); + translating_fully_process_byte(system, &tran, ch, i, end_i, &emits); } for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ @@ -726,7 +726,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil goto doublebreak_stage2; } - f32 adv = font_get_glyph_advance(params.system, params.font.settings, params.font.metrics, params.font.pages, buffer_step.value); + f32 adv = font_get_glyph_advance(params.system, params.face, buffer_step.value); x += adv; } } @@ -747,7 +747,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil } if (!emit_comment_position){ - step = wrap_state_consume_token(system, font, &wrap_state, next_line_start); + step = wrap_state_consume_token(system, face, &wrap_state, next_line_start); } b32 need_to_choose_a_wrap = false; @@ -874,7 +874,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil wrap_state = original_wrap_state; for (;;){ - step = wrap_state_consume_token(system, font, &wrap_state, wrap_position); + step = wrap_state_consume_token(system, face, &wrap_state, wrap_position); if (step.position_end >= wrap_position){ break; } @@ -900,7 +900,7 @@ file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *fil ++real_count; for (i32 l = 0; wrap_state.i < next_line_start && l < 3; ++l){ - wrap_state_consume_token(system, font, &wrap_state, next_line_start); + wrap_state_consume_token(system, face, &wrap_state, next_line_start); } } diff --git a/4ed_code_wrap.h b/4ed_code_wrap.h index b4e40ee1..0ab1fbbd 100644 --- a/4ed_code_wrap.h +++ b/4ed_code_wrap.h @@ -42,7 +42,7 @@ struct Code_Wrap_State{ i32 size; i32 i; - Font_Pointers font; + Face *face; f32 tab_indent_amount; f32 byte_advance; @@ -69,7 +69,7 @@ struct Wrap_Current_Shift{ }; internal void -file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *file, Font_Pointers font); +file_measure_wraps(System_Functions *system, Mem_Options *mem, Editing_File *file, Face *face); #endif diff --git a/4ed_edit.cpp b/4ed_edit.cpp index 27826c99..4784408a 100644 --- a/4ed_edit.cpp +++ b/4ed_edit.cpp @@ -282,14 +282,11 @@ edit_single(System_Functions *system, Models *models, Editing_File *file, Range i32 new_line_count = buffer_count_newlines(buffer, edit.range.first, edit.range.first + edit.length); i32 line_shift = new_line_count - replaced_line_count; - Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); - Assert(font.valid); - file_grow_starts_as_needed(heap, buffer, line_shift); buffer_remeasure_starts(buffer, line_start, line_end, line_shift, shift_amount); file_allocate_character_starts_as_needed(heap, file); - buffer_remeasure_character_starts(system, font, buffer, line_start, line_end, line_shift, file->state.character_starts, 0, file->settings.virtual_white); + buffer_remeasure_character_starts(system, buffer, line_start, line_end, line_shift, file->state.character_starts, 0, file->settings.virtual_white); // NOTE(allen): token fixing if (file->settings.tokens_exist){ @@ -297,7 +294,14 @@ edit_single(System_Functions *system, Models *models, Editing_File *file, Range } // NOTE(allen): wrap meta data - file_measure_wraps(system, &models->mem, file, font); +#if 0 + Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); + Assert(font.valid); +#endif + Face *face = 0; + Assert(face != 0); + + file_measure_wraps(system, &models->mem, file, face); // NOTE(allen): cursor fixing edit_fix_markers(system, models, file, edit); diff --git a/4ed_file.cpp b/4ed_file.cpp index 90fde17b..706dfef8 100644 --- a/4ed_file.cpp +++ b/4ed_file.cpp @@ -238,8 +238,12 @@ file_compute_partial_cursor(Editing_File *file, Buffer_Seek seek){ internal Full_Cursor file_compute_cursor__inner(System_Functions *system, Editing_File *file, Buffer_Seek seek, b32 return_hint){ +#if 0 Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); Assert(font.valid); +#endif + Face *face = 0; + Assert(face != 0); Full_Cursor result = {}; @@ -247,7 +251,7 @@ file_compute_cursor__inner(System_Functions *system, Editing_File *file, Buffer_ params.buffer = &file->state.buffer; params.seek = seek; params.system = system; - params.font = font; + params.face = face; params.wrap_line_index = file->state.wrap_line_index; params.character_starts = file->state.character_starts; params.virtual_white = file->settings.virtual_white; @@ -446,15 +450,19 @@ file_create_from_string(System_Functions *system, Models *models, Editing_File * Face_ID font_id = models->global_font_id; file->settings.font_id = font_id; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(font_id); Assert(font.valid); +#endif + Face *face = 0; + Assert(face != 0); file_measure_starts(heap, &file->state.buffer); file_allocate_character_starts_as_needed(heap, file); - buffer_measure_character_starts(system, font, &file->state.buffer, file->state.character_starts, 0, file->settings.virtual_white); + buffer_measure_character_starts(system, &file->state.buffer, file->state.character_starts, 0, file->settings.virtual_white); - file_measure_wraps(system, &models->mem, file, font); + file_measure_wraps(system, &models->mem, file, face); //adjust_views_looking_at_files_to_new_cursor(system, models, file); file->lifetime_object = lifetime_alloc_object(heap, &models->lifetime_allocator, DynamicWorkspace_Buffer, file); diff --git a/4ed_font.cpp b/4ed_font.cpp index b8690e3a..a4b80e79 100644 --- a/4ed_font.cpp +++ b/4ed_font.cpp @@ -9,6 +9,9 @@ // TOP +// TODO(allen): This is really "renderer font helpers or something like that" + +#if 0 internal Face_ID font_get_id_by_name(System_Functions *system, String_Const_u8 name){ Face_ID id = 0; @@ -155,12 +158,6 @@ font_make_page(System_Functions *system, Font_Settings *settings, Font_Metrics * return(new_page); } -internal b32 -font_can_render(System_Functions *system, Font_Settings *settings, Font_Metrics *metrics, Font_Page_Storage *pages, u32 codepoint){ - b32 result = (codepoint <= 0x10FFFF); - return(result); -} - /////// // HACK(allen): Hack optimizations struct Font_Cached_Lookup_Result{ @@ -220,6 +217,14 @@ font_get_glyph_advance(System_Functions *system, Font_Settings *settings, Font_M } return(result); } +#endif + +internal f32 +font_get_glyph_advance(System_Functions *system, Face *face, u32 codepoint){ + f32 result = 0.f; + NotImplemented; + return(result); +} // BOTTOM diff --git a/4ed_font.h b/4ed_font.h index bebf4769..fe82049b 100644 --- a/4ed_font.h +++ b/4ed_font.h @@ -12,7 +12,6 @@ #if !defined(FCODER_FONT_H) #define FCODER_FONT_H -// NOTE(allen): A description of an available font. struct Font_Loadable_Stub{ b32 load_from_path; b32 in_font_folder; @@ -20,15 +19,7 @@ struct Font_Loadable_Stub{ char name[256]; }; -struct Font_Loadable_Description{ - b32 valid; - Font_Loadable_Stub stub; - i32 display_len; - char display_name[64]; -}; - -// NOTE(allen): Settings that the are specified that determine how a font should be loaded and rendered. -struct Font_Parameters{ +struct Face_Parameters{ i32 pt_size; b32 italics; b32 bold; @@ -36,129 +27,58 @@ struct Font_Parameters{ b32 use_hinting; }; -struct Font_Settings{ +struct Face_Settings{ Font_Loadable_Stub stub; - Font_Parameters parameters; + Face_Parameters parameters; }; -// NOTE(allen): Data about the font true for the entire font as a whole. -struct Font_Metrics{ - i32 name_len; - char name[256]; +struct Glyph_Bounds{ + Rect_f32 uv; + f32 w; + Rect_f32 xy_off; +}; + +typedef i32 Texture_Kind; + +struct Face{ + Face_Settings settings; - i32 height; - i32 ascent; - i32 descent; - i32 line_skip; - i32 advance; + // NOTE(allen): Metrics + String_Const_u8 name; + + f32 height; + f32 ascent; + f32 descent; + f32 line_skip; + f32 advance; f32 underline_yoff1; f32 underline_yoff2; f32 byte_advance; f32 sub_advances[3]; -}; - -// NOTE(allen): The pages of glyph data. -#define GLYPHS_PER_PAGE 256 - -struct Glyph_Bounds{ - f32 x0, x1; - f32 y0, y1; - f32 xoff, yoff; - f32 xoff2, yoff2; -}; -global_const Glyph_Bounds null_glyph_bounds = {}; - -struct Glyph_Page{ - u32 page_number; - b32 has_layout; - f32 advance[GLYPHS_PER_PAGE]; - Glyph_Bounds glyphs[GLYPHS_PER_PAGE]; - i32 tex_width, tex_height; + // NOTE(allen): Glyph data + Table_u32_u16 codepoint_to_index_table; + i32 index_count; + Glyph_Bounds *bounds; + Glyph_Bounds white; - b32 has_gpu_setup; - u32 gpu_tex; + Texture_Kind gpu_texture_kind; + u32 gpu_texture; + Vec3_f32 gpu_texture_dim; }; -#define FONT_PAGE_EMPTY ((Glyph_Page*)0) -#define FONT_PAGE_DELETED ((Glyph_Page*)(1)) -#define FONT_PAGE_MAX 0x1100 +//////////////////////////////// -struct Font_Page_Storage{ - Glyph_Page **pages; - u32 page_count; - u32 page_max; - - // Hack optimizations - struct Page_Cache{ - u32 page_number; - Glyph_Page *page; - }; - - Page_Cache cache[16]; -}; - -// NOTE(allen): Types of refernces fonts. -struct Font_Pointers{ - b32 valid; - Font_Settings *settings; - Font_Metrics *metrics; - Font_Page_Storage *pages; -}; +typedef u32 Get_GPU_Texture_Function(Vec3_i32 dim, Texture_Kind texture_kind); +typedef b32 Fill_GPU_Texture_Function(Texture_Kind texture_kind, u32 gpu_texture, + Vec3_i32 p, Vec3_i32 dim, void *data); // NOTE(allen): Platform layer calls - implemented in a "font provider" -#define Sys_Font_Get_Loadable_Count_Sig(n) i32 (n)(void) -typedef Sys_Font_Get_Loadable_Count_Sig(Font_Get_Loadable_Count_Function); - -#define Sys_Font_Get_Loadable_Sig(n,i,o) void (n)(i32 i, Font_Loadable_Description *o) -typedef Sys_Font_Get_Loadable_Sig(Font_Get_Loadable_Function, index, out); - -#define Sys_Font_Face_Allocate_And_Init_Sig(n,s) Face_ID (n)(Font_Settings *s) -typedef Sys_Font_Face_Allocate_And_Init_Sig(Font_Face_Allocate_And_Init_Function, settings); - -#define Sys_Font_Face_Change_Settings_Sig(n,id,s) b32 (n)(Face_ID id, Font_Settings *s) -typedef Sys_Font_Face_Change_Settings_Sig(Font_Face_Change_Settings_Function, font_id, new_settings); - -#define Sys_Font_Face_Release_Sig(n,id) b32 (n)(Face_ID id) -typedef Sys_Font_Face_Release_Sig(Font_Face_Release_Function, font_id); - -#define Sys_Font_Get_Largest_ID_Sig(n) Face_ID (n)(void) -typedef Sys_Font_Get_Largest_ID_Sig(Font_Get_Largest_ID_Function); - -#define Sys_Font_Get_Count_Sig(n) i32 (n)(void) -typedef Sys_Font_Get_Count_Sig(Font_Get_Count_Function); - -#define Sys_Font_Get_Name_By_ID_Sig(n, font_id, out, cap) i32 (n)(Face_ID font_id, char *out, u32 cap) -typedef Sys_Font_Get_Name_By_ID_Sig(Font_Get_Name_By_ID_Function, font_id, out, cap); - -#define Sys_Font_Get_Pointers_By_ID_Sig(n, font_id) Font_Pointers (n)(Face_ID font_id) -typedef Sys_Font_Get_Pointers_By_ID_Sig(Font_Get_Pointers_By_ID_Function, font_id); - -#define Sys_Font_Load_Page_Sig(n,s,m,p,pn) void (n)(Font_Settings *s, Font_Metrics *m, Glyph_Page *p, u32 pn) -typedef Sys_Font_Load_Page_Sig(Font_Load_Page_Function, settings, metrics, page, page_number); - -#define Sys_Font_Allocate_Sig(n,size) void* (n)(i32 size) -typedef Sys_Font_Allocate_Sig(Font_Allocate_Function,size); - -#define Sys_Font_Free_Sig(n,ptr) void (n)(void *ptr) -typedef Sys_Font_Free_Sig(Font_Free_Function,ptr); - -struct Font_Functions{ - Font_Get_Loadable_Count_Function *get_loadable_count; - Font_Get_Loadable_Function *get_loadable; - Font_Face_Allocate_And_Init_Function *face_allocate_and_init; - Font_Face_Change_Settings_Function *face_change_settings; - Font_Face_Release_Function *face_release; - Font_Get_Largest_ID_Function *get_largest_id; - Font_Get_Count_Function *get_count; - Font_Get_Name_By_ID_Function *get_name_by_id; - Font_Get_Pointers_By_ID_Function *get_pointers_by_id; - Font_Load_Page_Function *load_page; - Font_Allocate_Function *allocate; - Font_Free_Function *free; -}; +typedef Face Font_Make_Face_Function(Arena *arena, Face_Settings *settings, + Get_GPU_Texture_Function *get_gpu_texture, + Fill_GPU_Texture_Function *fill_gpu_texture); #endif diff --git a/4ed_font_provider_freetype.cpp b/4ed_font_provider_freetype.cpp index eca6f6bf..d5209a81 100644 --- a/4ed_font_provider_freetype.cpp +++ b/4ed_font_provider_freetype.cpp @@ -17,21 +17,287 @@ #define internal static internal u32 -font_ft_flags(b32 use_hinting){ +ft__load_flags(b32 use_hinting){ u32 ft_flags = FT_LOAD_RENDER; - if (use_hinting){ // NOTE(inso): FT_LOAD_TARGET_LIGHT does hinting only vertically, which looks nicer imo // maybe it could be exposed as an option for hinting, instead of just on/off. - ft_flags |= FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_LIGHT; + ft_flags |= (FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_LIGHT); } else{ ft_flags |= (FT_LOAD_NO_AUTOHINT | FT_LOAD_NO_HINTING); } - return(ft_flags); } +internal FT_Codepoint_Index_Pair_Array +ft__get_codepoint_index_pairs(Arena *arena, FT_Face face, u16 *maximum_index_out){ + FT_Long glyph_count = face->num_glyphs; + + FT_Codepoint_Index_Pair_Array array = {}; + array.count = glyph_count; + array.vals = push_array(arena, FT_Codepoint_Index_Pair, glyph_count); + + u16 maximum_index = 0; + + i32 counter = 0; + FT_UInt index = 0; + FT_ULong codepoint = FT_Get_First_Char(face, &index); + array.vals[counter].codepoint = codepoint; + array.vals[counter].index = (u16)index; + maximum_index = Max(maximum_index, (u16)index); + counter += 1; + for (;;){ + codepoint = FT_Get_Next_Char(face, codepoint, &index); + array.vals[counter].codepoint = codepoint; + array.vals[counter].index = (u16)index; + maximum_index = Max(maximum_index, (u16)index); + counter += 1; + if (counter == glyph_count){ + break; + } + } + + *maximum_index_out = maximum_index; + + return(array); +} + +internal Table_u32_u16 +ft__get_codepoint_index_table(Base_Allocator *base_allocator, FT_Face face, u16 *maximum_index_out){ + FT_Long glyph_count = face->num_glyphs; + + Table_u32_u16 table = make_table_u32_u16(base_allocator, glyph_count*4); + + u16 maximum_index = 0; + + i32 counter = 0; + FT_UInt index = 0; + FT_ULong codepoint = FT_Get_First_Char(face, &index); + table_insert(&table, (u32)codepoint, (u16)index); + maximum_index = Max(maximum_index, (u16)index); + counter += 1; + for (;;){ + codepoint = FT_Get_Next_Char(face, codepoint, &index); + table_insert(&table, (u32)codepoint, (u16)index); + maximum_index = Max(maximum_index, (u16)index); + counter += 1; + if (counter == glyph_count){ + break; + } + } + + *maximum_index_out = maximum_index; + + return(table); +} + +struct FT_Bad_Rect_Pack{ + Vec2_i32 max_dim; + Vec3_i32 dim; + Vec3_i32 p; + i32 current_line_h; +}; + +internal void +ft__bad_rect_pack_init(FT_Bad_Rect_Pack *pack, Vec2_i32 max_dim){ + pack->max_dim = max_dim; + pack->dim = V3i32(0, 0, 0); + pack->p = V3i32(0, 0, 0); + pack->current_line_h = 0; +} + +internal void +ft__bad_rect_pack_end_line(FT_Bad_Rect_Pack *pack){ + pack->p.y += pack->current_line_h; + pack->dim.y = Max(pack->dim.y, pack->p.y); + pack->current_line_h = 0; + pack->p.x = 0; +} + +internal Vec3_i32 +ft__bad_rect_pack_next(FT_Bad_Rect_Pack *pack, Vec2_i32 dim){ + Vec3_i32 result = {}; + if (dim.x <= pack->max_dim.x && dim.y <= pack->max_dim.y){ + if (pack->current_line_h < dim.y){ + pack->current_line_h = dim.y; + } + if (pack->current_line_h > pack->max_dim.y){ + ft__bad_rect_pack_end_line(pack); + pack->p.y = 0; + pack->dim.z += 1; + pack->p.z += 1; + } + else{ + if (pack->p.x + dim.x > pack->max_dim.x){ + ft__bad_rect_pack_end_line(pack); + } + result = pack->p; + pack->p.x += dim.x; + pack->current_line_h = Max(pack->current_line_h, dim.y); + } + } + return(result); +} + +internal void +ft__glyph_bounds_store_uv_raw(Vec3_i32 p, Vec2_i32 dim, Glyph_Bounds *bounds){ + bounds->uv = Rf32((f32)p.x, (f32)p.y, (f32)dim.x, (f32)dim.y); + bounds->w = (f32)p.z; +} + +enum{ + TextureKind_Error, + TextureKind_Mono, +}; + +internal Face* +ft__font_make_face(Arena *arena, Face_Settings *settings, Get_GPU_Texture_Function *get_gpu_texture, Fill_GPU_Texture_Function *fill_gpu_texture){ + String_Const_u8 file_name = SCu8(settings->stub.name, settings->stub.len); + + FT_Library ft; + FT_Init_FreeType(&ft); + + FT_Face ft_face; + FT_Error error = FT_New_Face(ft, (char*)file_name.str, 0, &ft_face); + + Face *face = push_array_zero(arena, Face, 1);; + if (error == 0){ + u32 pt_size = settings->parameters.pt_size; + b32 use_hinting = settings->parameters.use_hinting; + + FT_Size_RequestRec_ size = {}; + size.type = FT_SIZE_REQUEST_TYPE_NOMINAL; + size.height = (pt_size << 6); + FT_Request_Size(ft_face, &size); + + face->name = push_string_copy(arena, file_name); + + face->ascent = f32_ceil32(ft_face->size->metrics.ascender/64.f); + face->descent = f32_floor32(ft_face->size->metrics.descender/64.f); + face->advance = f32_ceil32(ft_face->size->metrics.max_advance/64.f); + face->height = f32_ceil32(ft_face->size->metrics.height/64.f); + face->line_skip = face->height - (face->ascent - face->descent); + face->height -= face->line_skip; + + { + f32 real_over_notional = (f32)face->height/(f32)ft_face->height; + f32 relative_center = -1.f*real_over_notional*ft_face->underline_position; + f32 relative_thickness = real_over_notional*ft_face->underline_thickness; + + f32 center = (f32)floor32(face->ascent + relative_center); + f32 thickness = clamp_bot(1.f, relative_thickness); + + face->underline_yoff1 = center - thickness*0.5f; + face->underline_yoff2 = center + thickness*0.5f; + } + + u16 index_count = 0; + face->codepoint_to_index_table = ft__get_codepoint_index_table(arena->base_allocator, ft_face, &index_count); + face->bounds = push_array(arena, Glyph_Bounds, index_count); + + struct FT_Bitmap{ + Vec2_i32 dim; + u8 *data; + }; + FT_Bitmap *glyph_bitmaps = push_array(arena, FT_Bitmap, index_count); + + u32 load_flags = ft__load_flags(use_hinting); + for (u16 i = 0; i < index_count; i += 1){ + + FT_Bitmap *bitmap = &glyph_bitmaps[i]; + + error = FT_Load_Glyph(ft_face, i, load_flags); + if (error == 0){ + FT_GlyphSlot ft_glyph = ft_face->glyph; + Vec2_i32 dim = V2i32(ft_glyph->bitmap.width, ft_glyph->bitmap.rows); + bitmap->dim = dim; + bitmap->data = push_array(arena, u8, dim.x*dim.y); + + face->bounds[i].xy_off.x0 = (f32)(ft_face->glyph->bitmap_left); + face->bounds[i].xy_off.y0 = (f32)(face->ascent - ft_face->glyph->bitmap_top); + face->bounds[i].xy_off.x1 = (f32)(face->bounds[i].xy_off.x0 + dim.x); + face->bounds[i].xy_off.y1 = (f32)(face->bounds[i].xy_off.y0 + dim.y); + + switch (ft_glyph->bitmap.pixel_mode){ + case FT_PIXEL_MODE_MONO: + { + NotImplemented; + }break; + + case FT_PIXEL_MODE_GRAY: + { + u8 *src_line = ft_glyph->bitmap.buffer; + if (ft_glyph->bitmap.pitch < 0){ + src_line = ft_glyph->bitmap.buffer + (-ft_glyph->bitmap.pitch)*(dim.y - 1); + } + u8 *dst = bitmap->data; + for (i32 y = 0; y < dim.y; y += 1){ + u8 *src_pixel = src_line; + for (i32 x = 0; x < dim.x; x += 1){ + *dst = *src_pixel; + dst += 1; + src_pixel += 1; + } + src_line += ft_glyph->bitmap.pitch; + } + }break; + + default: + { + NotImplemented; + }break; + } + } + } + + u8 white_data[16] = { + 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, + }; + + FT_Bitmap white = {}; + white.dim = V2i32(4, 4); + white.data = white_data; + + FT_Bad_Rect_Pack pack = {}; + ft__bad_rect_pack_init(&pack, V2i32(1024, 1024)); + ft__glyph_bounds_store_uv_raw(ft__bad_rect_pack_next(&pack, white.dim), white.dim, &face->white); + for (u16 i = 0; i < index_count; i += 1){ + Vec2_i32 dim = glyph_bitmaps[i].dim; + ft__glyph_bounds_store_uv_raw(ft__bad_rect_pack_next(&pack, dim), dim, &face->bounds[i]); + } + + Texture_Kind texture_kind = TextureKind_Mono; + u32 gpu_texture = get_gpu_texture(pack.dim, texture_kind); + face->gpu_texture_kind = texture_kind; + face->gpu_texture = gpu_texture; + + Vec3_f32 gpu_texture_dim = V3f32(pack.dim); + face->gpu_texture_dim = gpu_texture_dim; + for (u16 i = 0; i < index_count; i += 1){ + Vec3_i32 p = V3i32((i32)face->bounds[i].uv.x0, (i32)face->bounds[i].uv.y0, (i32)face->bounds[i].w); + Vec3_i32 dim = V3i32(glyph_bitmaps[i].dim.x, glyph_bitmaps[i].dim.y, 1); + fill_gpu_texture(texture_kind, gpu_texture, p, dim, glyph_bitmaps[i].data); + + face->bounds[i].uv.x1 = (face->bounds[i].uv.x0 + face->bounds[i].uv.x1)/gpu_texture_dim.x; + face->bounds[i].uv.y1 = (face->bounds[i].uv.y0 + face->bounds[i].uv.y1)/gpu_texture_dim.y; + face->bounds[i].uv.x0 = face->bounds[i].uv.x0/gpu_texture_dim.x; + face->bounds[i].uv.y0 = face->bounds[i].uv.y0/gpu_texture_dim.y; + face->bounds[i].w /= gpu_texture_dim.z; + } + + face->settings = *settings; + } + + FT_Done_FreeType(ft); + + return(face); +} + +#if 0 internal b32 font_ft_get_face(FT_Library ft, Font_Loadable_Stub *stub, Font_Parameters *parameters, FT_Face *face){ b32 success = true; @@ -520,7 +786,7 @@ Sys_Font_Face_Allocate_And_Init_Sig(system_font_face_allocate_and_init, new_sett } if (page_with_slot == 0){ - LOG("Could not get a font slot while loading a font\n"); + //LOG("Could not get a font slot while loading a font\n"); return(0); } @@ -849,6 +1115,7 @@ system_font_init(Font_Functions *font_links, u32 pt_size, b32 use_hinting, Font_ first_settings.parameters.use_hinting = use_hinting; system_font_face_allocate_and_init(&first_settings); } +#endif // BOTTOM diff --git a/4ed_font_provider_freetype.h b/4ed_font_provider_freetype.h index 4c7c458c..66124dd4 100644 --- a/4ed_font_provider_freetype.h +++ b/4ed_font_provider_freetype.h @@ -12,11 +12,25 @@ #if !defined(FCODER_FONT_PROVIDER_FREETYPE_H) #define FCODER_FONT_PROVIDER_FREETYPE_H +struct FT_Codepoint_Index_Pair{ + u32 codepoint; + u16 index; +}; + +struct FT_Codepoint_Index_Pair_Array{ + FT_Codepoint_Index_Pair *vals; + i32 count; +}; + +#if 0 struct Font_Slot{ b32 is_active; Font_Settings settings; Font_Metrics metrics; + Font_Data data; +#if 0 Font_Page_Storage pages; +#endif }; struct Font_Slot_Page{ @@ -70,7 +84,7 @@ struct Font_Setup{ char name[64]; }; -struct Font_Setup_List{ +struct _Setup_List{ Font_Setup *first; Font_Setup *last; }; @@ -106,6 +120,8 @@ internal Sys_Font_Data(name, parameters); #define Sys_Font_Data_Not_Used \ internal Sys_Font_Data(n,p){ \ Font_Raw_Data data = {}; LOG("there is no font data retrieval procedure available\n"); return(data);} +#endif + #endif diff --git a/4ed_log.h b/4ed_log.h deleted file mode 100644 index 5bda7f39..00000000 --- a/4ed_log.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Mr. 4th Dimention - Allen Webster - * - * 12.06.2017 - * - * Setup macro wrappers for the logging system. - * - */ - -// TOP - -#define GEN_LOG(l,m) l(m, sizeof(m)-1) -#define GEN_LOGF(l,...) do{ char space[4096]; \ - i32 length = snprintf(space, sizeof(space), __VA_ARGS__); \ - l(space, length); \ -}while(0) - -#if defined(IS_PLAT_LAYER) - -# if defined(USE_LOG) -# define LOG(m) GEN_LOG(sysfunc.log, FNLN "\n" m) -# else -# define LOG(m) -# endif - -# if defined(USE_LOGF) -# define LOGF(...) GEN_LOGF(sysfunc.log, FNLN "\n" __VA_ARGS__) -# else -# define LOGF(...) -# endif - -#elif defined(IS_OBJC_LAYER) - -# if defined(USE_LOG) -# define LOG(m) GEN_LOG(osx_log, FNLN "\n" m) -# else -# define LOG(m) -# endif - -# if defined(USE_LOGF) -# define LOGF(...) GEN_LOGF(osx_log, FNLN "\n" __VA_ARGS__) -# else -# define LOGF(...) -# endif - -#else /* Not platform layer */ - -# if defined(USE_LOG) -# define LOG(s,m) GEN_LOG((s)->log, FNLN "\n" m) -# else -# define LOG(s,m) -# endif - -# if defined(USE_LOGF) -# define LOGF(s,...) GEN_LOGF((s)->log, FNLN "\n" __VA_ARGS__) -# else -# define LOGF(s,...) -# endif - -#endif - -// HACK(allen): Get rid of this dependency. Implement snprintf ourself or something. -#if defined(USE_LOG) -# include -#endif - -// BOTTOM - diff --git a/4ed_render_format.cpp b/4ed_render_format.cpp index 67341bc6..7f140aad 100644 --- a/4ed_render_format.cpp +++ b/4ed_render_format.cpp @@ -52,33 +52,52 @@ end_render_section(Render_Target *target, System_Functions *system){ Assert(target->clip_top == 0); } +//////////////////////////////// + #define CmdHeader(t) cmd.header.size = sizeof(cmd), cmd.header.type = t internal void draw_rectangle(Render_Target *target, f32_Rect rect, u32 color){ Render_Command_Rectangle cmd = {}; CmdHeader(RenCom_Rectangle); - cmd.rect = rect; cmd.color = color; + cmd.vertices[0] = V2(rect.x0, rect.y0); + cmd.vertices[1] = V2(rect.x1, rect.y0); + cmd.vertices[2] = V2(rect.x0, rect.y1); + cmd.vertices[3] = V2(rect.x1, rect.y1); void *h = render_begin_push(target, &cmd, cmd.header.size); render_end_push(target, h); } -internal void -draw_rectangle(Render_Target *target, i32_Rect rect, u32 color){ - draw_rectangle(target, f32R(rect), color); -} - internal void draw_rectangle_outline(Render_Target *target, f32_Rect rect, u32 color){ - Render_Command_Rectangle cmd = {}; - CmdHeader(RenCom_Outline); - cmd.rect = rect; + draw_rectangle(target, Rf32(rect.x0, rect.y0, rect.x1, rect.y0 + 1), color); + draw_rectangle(target, Rf32(rect.x1 - 1, rect.y0, rect.x1, rect.y1), color); + draw_rectangle(target, Rf32(rect.x0, rect.y1 - 1, rect.x1, rect.y1), color); + draw_rectangle(target, Rf32(rect.x0, rect.y0, rect.x0 + 1, rect.y1), color); +} + +internal void +draw_font_glyph(Render_Target *target, Face_ID font_id, u32 codepoint, f32 x, f32 y, u32 color, u32 flags){ + Render_Command_Glyph cmd = {}; + CmdHeader(RenCom_Glyph); + cmd.pos.x = x; + cmd.pos.y = y; cmd.color = color; + cmd.font_id = font_id; + cmd.codepoint = codepoint; + cmd.flags = flags; void *h = render_begin_push(target, &cmd, cmd.header.size); render_end_push(target, h); } +//////////////////////////////// + +internal void +draw_rectangle(Render_Target *target, i32_Rect rect, u32 color){ + draw_rectangle(target, f32R(rect), color); +} + internal void draw_rectangle_outline(Render_Target *target, i32_Rect rect, u32 color){ draw_rectangle_outline(target, f32R(rect), color); @@ -102,7 +121,6 @@ internal void draw_margin(Render_Target *target, i32_Rect outer, i32_Rect inner, u32 color){ draw_rectangle(target, i32R(outer.x0, outer.y0, outer.x1, inner.y0), color); draw_rectangle(target, i32R(outer.x0, inner.y1, outer.x1, outer.y1), color); - draw_rectangle(target, i32R(outer.x0, inner.y0, inner.x0, inner.y1), color); draw_rectangle(target, i32R(inner.x1, inner.y0, outer.x1, inner.y1), color); } @@ -113,20 +131,6 @@ draw_margin(Render_Target *target, i32_Rect outer, i32 width, u32 color){ draw_margin(target, outer, inner, color); } -internal void -draw_font_glyph(Render_Target *target, Face_ID font_id, u32 codepoint, f32 x, f32 y, u32 color, u32 flags){ - Render_Command_Glyph cmd; - CmdHeader(RenCom_Glyph); - cmd.pos.x = x; - cmd.pos.y = y; - cmd.color = color; - cmd.font_id = font_id; - cmd.codepoint = codepoint; - cmd.flags = flags; - void *h = render_begin_push(target, &cmd, cmd.header.size); - render_end_push(target, h); -} - internal Vec2 snap_point_to_boundary(Vec2 point){ point.x = (f32)(floor32(point.x)); @@ -138,12 +142,16 @@ internal f32 draw_string(System_Functions *system, Render_Target *target, Face_ID font_id, String_Const_u8 string, Vec2 point, u32 color, u32 flags, Vec2 delta){ f32 total_delta = 0.f; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(font_id); - if (font.valid != 0){ +#endif + Face *face = 0; + + if (face != 0){ point = snap_point_to_boundary(point); - f32 byte_advance = font.metrics->byte_advance; - f32 *sub_advances = font.metrics->sub_advances; + f32 byte_advance = face->byte_advance; + f32 *sub_advances = face->sub_advances; u8 *str = (u8*)string.str; u8 *str_end = str + string.size; @@ -152,7 +160,7 @@ draw_string(System_Functions *system, Render_Target *target, Face_ID font_id, St Translation_Emits emits = {}; for (u32 i = 0; str < str_end; ++str, ++i){ - translating_fully_process_byte(system, font, &tran, *str, i, (i32)string.size, &emits); + translating_fully_process_byte(system, &tran, *str, i, (i32)string.size, &emits); for (TRANSLATION_DECL_EMIT_LOOP(J, emits)){ TRANSLATION_DECL_GET_STEP(step, behavior, J, emits); @@ -162,7 +170,7 @@ draw_string(System_Functions *system, Render_Target *target, Face_ID font_id, St if (color != 0){ draw_font_glyph(target, font_id, codepoint, point.x, point.y, color, flags); } - f32 d = font_get_glyph_advance(system, font.settings, font.metrics, font.pages, codepoint); + f32 d = font_get_glyph_advance(system, face, codepoint); point += d*delta; total_delta += d; } diff --git a/4ed_render_format.h b/4ed_render_format.h index 1fe4d289..9dfdbfff 100644 --- a/4ed_render_format.h +++ b/4ed_render_format.h @@ -14,7 +14,6 @@ enum Render_Command_Type{ RenCom_Rectangle, - RenCom_Outline, RenCom_Glyph, RenCom_ChangeClip, }; @@ -31,8 +30,14 @@ struct Render_Command_Header{ struct Render_Command_Rectangle{ Render_Command_Header header; - f32_Rect rect; u32 color; + Vec2 vertices[4]; +}; + +struct Render_Command_Rectangle_Outline{ + Render_Command_Header header; + u32 color; + Vec2 vertices[5]; }; struct Render_Command_Gradient{ diff --git a/4ed_render_target.cpp b/4ed_render_target.cpp index 0370cfa2..9eebd2ca 100644 --- a/4ed_render_target.cpp +++ b/4ed_render_target.cpp @@ -37,7 +37,6 @@ Render_End_Push_Sig(render_internal_end_push, t, h){ Render_Command_Header *header = (Render_Command_Header*)h; header->size = (i32)(end_ptr - (u8*)h); } - // TODO(allen): else { LOG } } internal void diff --git a/4ed_system.h b/4ed_system.h index 7c738e3a..9c079e76 100644 --- a/4ed_system.h +++ b/4ed_system.h @@ -224,12 +224,8 @@ typedef Sys_Set_Fullscreen_Sig(System_Set_Fullscreen); #define Sys_Is_Fullscreen_Sig(name) b32 name() typedef Sys_Is_Fullscreen_Sig(System_Is_Fullscreen); -// debug -#define Sys_Log_Sig(name) void name(char *message, u32 length) -typedef Sys_Log_Sig(System_Log); - struct System_Functions{ - Font_Functions font; + Font_Make_Face_Function *font_make_face; // files (tracked api): 11 System_Set_File_List *set_file_list; @@ -287,9 +283,6 @@ struct System_Functions{ System_Show_Mouse_Cursor *show_mouse_cursor; System_Set_Fullscreen *set_fullscreen; System_Is_Fullscreen *is_fullscreen; - - // debug: 1 - System_Log *log; }; #endif diff --git a/4ed_system_allocator.cpp b/4ed_system_allocator.cpp new file mode 100644 index 00000000..6a8da5b6 --- /dev/null +++ b/4ed_system_allocator.cpp @@ -0,0 +1,56 @@ +/* + * 4coder malloc base allocator + */ + +// TOP + +internal void* +base_reserve__system(void *user_data, umem size, umem *size_out){ + System_Functions *system = (System_Functions*)user_data; + umem extra_size = 128; + umem increased_size = size + extra_size; + size = round_up_umem(increased_size, KB(4)); + *size_out = size - extra_size; + void *ptr = system->memory_allocate(size); + *(umem*)ptr = size; + ptr = (u8*)ptr + extra_size; + return(ptr); +} + +internal void +base_free__system(void *user_data, void *ptr){ + System_Functions *system = (System_Functions*)user_data; + umem extra_size = 128; + ptr = (u8*)ptr - extra_size; + umem size = *(umem*)ptr; + system->memory_free(ptr, size); +} + +internal Base_Allocator +make_base_allocator_system(System_Functions *system){ + return(make_base_allocator(base_reserve__system, 0, 0, + base_free__system, 0, system)); +} + +global Base_Allocator base_allocator_system = {}; + +internal Arena +make_arena_system(System_Functions *system, umem chunk_size, umem align){ + if (base_allocator_system.reserve == 0){ + base_allocator_system = make_base_allocator_system(system); + } + return(make_arena(&base_allocator_system, chunk_size, align)); +} + +internal Arena +make_arena_system(System_Functions *system, umem chunk_size){ + return(make_arena_system(system, chunk_size, 8)); +} + +internal Arena +make_arena_system(System_Functions *system){ + return(make_arena_system(system, KB(16), 8)); +} + +// BOTTOM + diff --git a/4ed_translation.cpp b/4ed_translation.cpp index 3a504e96..a9e66c60 100644 --- a/4ed_translation.cpp +++ b/4ed_translation.cpp @@ -98,7 +98,7 @@ translating_select_emit_rule_ASCII(Translation_State *tran, Translation_Byte_Des } internal void -translating_select_emit_rule_with_font(System_Functions *system, Font_Pointers font, Translation_State *tran, Translation_Byte_Description desc, Translation_Emit_Rule *type_out){ +translating_select_emit_rule_UTF8(System_Functions *system, Translation_State *tran, Translation_Byte_Description desc, Translation_Emit_Rule *type_out){ type_out->byte_class = desc.byte_class; type_out->last_byte_handler = desc.last_byte_handler; type_out->emit_type = desc.prelim_emit_type; @@ -113,7 +113,7 @@ translating_select_emit_rule_with_font(System_Functions *system, Font_Pointers f } else{ type_out->codepoint = cp; - if (!font_can_render(system, font.settings, font.metrics, font.pages, cp)){ + if (cp > 0x10FFFF){ type_out->emit_type = BufferModelUnit_Numbers; } } @@ -178,11 +178,11 @@ translating_generate_emits(Translation_State *tran, Translation_Emit_Rule emit_r } internal void -translating_fully_process_byte(System_Functions *system, Font_Pointers font, Translation_State *tran, u8 ch, u32 i, u32 size, Translation_Emits *emits_out){ +translating_fully_process_byte(System_Functions *system, Translation_State *tran, u8 ch, u32 i, u32 size, Translation_Emits *emits_out){ Translation_Byte_Description description = {}; translating_consume_byte(tran, ch, i, size, &description); Translation_Emit_Rule emit_rule = {}; - translating_select_emit_rule_with_font(system, font, tran, description, &emit_rule); + translating_select_emit_rule_UTF8(system, tran, description, &emit_rule); translating_generate_emits(tran, emit_rule, ch, i, emits_out); } diff --git a/4ed_view.cpp b/4ed_view.cpp index 03c6efc5..23151f31 100644 --- a/4ed_view.cpp +++ b/4ed_view.cpp @@ -345,8 +345,13 @@ view_set_file(System_Functions *system, Models *models, View *view, Editing_File view->mark = edit_pos.cursor_pos; view_set_preferred_x_to_current_position(system, view); +#if 0 Font_Pointers font = system->font.get_pointers_by_id(file->settings.font_id); - view->line_height = font.metrics->height; +#endif + Face *face = 0; + Assert(face != 0); + + view->line_height = (i32)face->height; models->layout.panel_state_dirty = true; } @@ -386,8 +391,11 @@ adjust_views_looking_at_file_to_new_cursor(System_Functions *system, Models *mod internal void file_full_remeasure(System_Functions *system, Models *models, Editing_File *file){ Face_ID font_id = file->settings.font_id; +#if 0 Font_Pointers font = system->font.get_pointers_by_id(font_id); - file_measure_wraps(system, &models->mem, file, font); +#endif + Face *face = 0; + file_measure_wraps(system, &models->mem, file, face); adjust_views_looking_at_file_to_new_cursor(system, models, file); Layout *layout = &models->layout; @@ -396,7 +404,7 @@ file_full_remeasure(System_Functions *system, Models *models, Editing_File *file panel = layout_get_next_open_panel(layout, panel)){ View *view = panel->view; if (view->file == file){ - view->line_height = font.metrics->height; + view->line_height = (i32)face->height; } } } @@ -419,8 +427,10 @@ global_set_font_and_update_files(System_Functions *system, Models *models, Face_ } internal b32 -alter_font_and_update_files(System_Functions *system, Models *models, Face_ID font_id, Font_Settings *new_settings){ +alter_font_and_update_files(System_Functions *system, Models *models, Face_ID font_id, Face_Settings *new_settings){ b32 success = false; + NotImplemented; +#if 0 if (system->font.face_change_settings(font_id, new_settings)){ success = true; for (Node *node = models->working_set.used_sentinel.next; @@ -432,12 +442,15 @@ alter_font_and_update_files(System_Functions *system, Models *models, Face_ID fo } } } +#endif return(success); } internal b32 release_font_and_update_files(System_Functions *system, Models *models, Face_ID font_id, Face_ID replacement_id){ b32 success = false; + NotImplemented; +#if 0 if (system->font.face_release(font_id)){ Font_Pointers font = system->font.get_pointers_by_id(replacement_id); if (!font.valid){ @@ -460,6 +473,7 @@ release_font_and_update_files(System_Functions *system, Models *models, Face_ID } } } +#endif return(success); } diff --git a/meta/4ed_build.cpp b/meta/4ed_build.cpp index 17a87367..e2632799 100644 --- a/meta/4ed_build.cpp +++ b/meta/4ed_build.cpp @@ -161,7 +161,6 @@ enum{ SUPER = 0x40, INTERNAL = 0x80, KEEP_ASSERT = 0x100, - LOG = 0x200, }; internal char** @@ -176,10 +175,6 @@ get_defines_from_flags(Arena *arena, u32 flags){ if (HasFlag(flags, SUPER)){ result = fm_list(arena, fm_list_one_item(arena, "FRED_SUPER"), result); } - if (HasFlag(flags, LOG)){ - char *log_defines[] = { "USE_LOG", "USE_LOGF", 0}; - result = fm_list(arena, log_defines, result); - } return(result); } @@ -633,7 +628,7 @@ package(Arena *arena, char *cdir){ }; char *tiers[] = { "alpha", "super" }; - u32 base_flags = OPTIMIZATION | KEEP_ASSERT | DEBUG_INFO | LOG; + u32 base_flags = OPTIMIZATION | KEEP_ASSERT | DEBUG_INFO; u32 tier_flags[] = { 0, SUPER, }; for (u32 tier_index = 0; tier_index < Tier_COUNT; ++tier_index){ @@ -704,7 +699,7 @@ int main(int argc, char **argv){ END_TIME_SECTION("current directory"); #if defined(DEV_BUILD) || defined(OPT_BUILD) || defined(DEV_BUILD_X86) - u32 flags = DEBUG_INFO | SUPER | INTERNAL | LOG; + u32 flags = DEBUG_INFO | SUPER | INTERNAL; u32 arch = Arch_X64; #if defined(OPT_BUILD) flags |= OPTIMIZATION; diff --git a/opengl/4ed_opengl_defines.h b/opengl/4ed_opengl_defines.h index e90b9259..db76550f 100644 --- a/opengl/4ed_opengl_defines.h +++ b/opengl/4ed_opengl_defines.h @@ -12,8 +12,216 @@ #if !defined(FRED_OPENGL_DEFINES_H) #define FRED_OPENGL_DEFINES_H -#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242 -#define GL_DEBUG_OUTPUT 0x92E0 +#include + +#define GL_MULTISAMPLE 0x809D +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242 +#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ARRAY_BUFFER 0x8892 +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_DEBUG_SEVERITY_HIGH 0x9146 +#define GL_DEBUG_SEVERITY_MEDIUM 0x9147 +#define GL_DEBUG_SEVERITY_LOW 0x9148 + +#define GL_TEXTURE_3D 0x806F +#define GL_TEXTURE_2D_ARRAY 0x8C1A + +//////////////////////////////// + +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C + +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F + +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B + +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B + +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH24_STENCIL8 0x88F0 + +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA + +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A + +//////////////////////////////// + +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 + +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 + +//////////////////////////////// + +typedef char GLchar; +typedef short GLshort; +typedef signed char GLbyte; +typedef unsigned short GLushort; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptr; + +typedef void GL_Debug_Function(GLenum src, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + GLchar *message, + void *user_data); +typedef GL_Debug_Function *GLDEBUGPROC; + +#define GL_FUNC(N,R,P) typedef R (N##_Function)P; N##_Function *N = 0; +#include "4ed_opengl_funcs.h" #endif diff --git a/opengl/4ed_opengl_funcs.h b/opengl/4ed_opengl_funcs.h index 7a3cec64..8ed2a786 100644 --- a/opengl/4ed_opengl_funcs.h +++ b/opengl/4ed_opengl_funcs.h @@ -13,6 +13,77 @@ #include "4ed_opengl_funcs.h" */ +GL_FUNC(glDebugMessageControl, void, (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)) +GL_FUNC(glDebugMessageCallback, void, (GLDEBUGPROC callback, const void *userParam)) + +GL_FUNC(glTexImage3D, void, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)) +GL_FUNC(glTexSubImage3D, void, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)) + +GL_FUNC(glGenVertexArrays, void, (GLsizei n, GLuint *arrays)) +GL_FUNC(glBindVertexArray, void, (GLuint array)) +GL_FUNC(glDeleteVertexArrays, void, (GLsizei n, const GLuint *arrays)) + +GL_FUNC(glGenBuffers, void, (GLsizei n, GLuint *buffers)) +GL_FUNC(glBindBuffer, void, (GLenum target, GLuint buffer)) +GL_FUNC(glBufferData, void, (GLenum target, GLsizeiptr size, const void *data, GLenum usage)) + +GL_FUNC(glCreateShader, GLuint, (GLenum type)) +GL_FUNC(glShaderSource, void, (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length)) +GL_FUNC(glCompileShader, void, (GLuint shader)) +GL_FUNC(glGetShaderiv, void, (GLuint shader, GLenum pname, GLint *params)) +GL_FUNC(glGetShaderInfoLog, void, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) +GL_FUNC(glDeleteShader, void, (GLuint shader)) +GL_FUNC(glCreateProgram, GLuint, (void)) +GL_FUNC(glAttachShader, void, (GLuint program, GLuint shader)) +GL_FUNC(glLinkProgram, void, (GLuint program)) +GL_FUNC(glUseProgram, void, (GLuint program)) +GL_FUNC(glGetProgramiv, void, (GLuint program, GLenum pname, GLint *params)) +GL_FUNC(glGetProgramInfoLog, void, (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) +GL_FUNC(glDeleteProgram, void, (GLuint program)) +GL_FUNC(glValidateProgram, void, (GLuint program)) + +GL_FUNC(glGetUniformLocation, GLint, (GLuint program, const GLchar *name)) +GL_FUNC(glGetAttribLocation, GLint, (GLuint program, const GLchar *name)) + +GL_FUNC(glBindAttribLocation, void, (GLuint program, GLuint index, const GLchar *name)) +GL_FUNC(glDisableVertexAttribArray, void, (GLuint index)) +GL_FUNC(glEnableVertexAttribArray, void, (GLuint index)) + +GL_FUNC(glVertexAttribPointer, void, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)) + +GL_FUNC(glUniform1f, void, (GLint location, GLfloat v0)) +GL_FUNC(glUniform2f, void, (GLint location, GLfloat v0, GLfloat v1)) +GL_FUNC(glUniform3f, void, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) +GL_FUNC(glUniform4f, void, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) +GL_FUNC(glUniform1i, void, (GLint location, GLint v0)) +GL_FUNC(glUniform2i, void, (GLint location, GLint v0, GLint v1)) +GL_FUNC(glUniform3i, void, (GLint location, GLint v0, GLint v1, GLint v2)) +GL_FUNC(glUniform4i, void, (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) +GL_FUNC(glUniform1fv, void, (GLint location, GLsizei count, const GLfloat *value)) +GL_FUNC(glUniform2fv, void, (GLint location, GLsizei count, const GLfloat *value)) +GL_FUNC(glUniform3fv, void, (GLint location, GLsizei count, const GLfloat *value)) +GL_FUNC(glUniform4fv, void, (GLint location, GLsizei count, const GLfloat *value)) +GL_FUNC(glUniform1iv, void, (GLint location, GLsizei count, const GLint *value)) +GL_FUNC(glUniform2iv, void, (GLint location, GLsizei count, const GLint *value)) +GL_FUNC(glUniform3iv, void, (GLint location, GLsizei count, const GLint *value)) +GL_FUNC(glUniform4iv, void, (GLint location, GLsizei count, const GLint *value)) +GL_FUNC(glUniformMatrix2fv, void, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) +GL_FUNC(glUniformMatrix3fv, void, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) +GL_FUNC(glUniformMatrix4fv, void, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) + +GL_FUNC(glActiveTexture, void, (GLenum texture)) + +GL_FUNC(glGenFramebuffers, void, (GLsizei n, GLuint *framebuffers)) +GL_FUNC(glBindFramebuffer, void, (GLenum target, GLuint framebuffer)) +GL_FUNC(glCheckFramebufferStatus, GLenum, (GLenum target)) +GL_FUNC(glFramebufferTexture1D, void, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) +GL_FUNC(glFramebufferTexture2D, void, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) +GL_FUNC(glFramebufferTexture3D, void, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)) + +GL_FUNC(glBlitFramebuffer, void, (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) + +GL_FUNC(glTexImage2DMultisample, void, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) + #undef GL_FUNC // BOTTOM diff --git a/opengl/4ed_opengl_render.cpp b/opengl/4ed_opengl_render.cpp index 4e959e5b..524d3a03 100644 --- a/opengl/4ed_opengl_render.cpp +++ b/opengl/4ed_opengl_render.cpp @@ -9,92 +9,204 @@ // TOP -// TODO(allen): If we don't actually need this then burn down 4ed_opengl_funcs.h -// Declare function types and function pointers //#define GL_FUNC(N,R,P) typedef R (N##_Function) P; N##_Function *P = 0; //#include "4ed_opengl_funcs.h" #include "4ed_opengl_defines.h" -// OpenGL 2.1 implementation - +#if 0 internal GLuint -private_texture_initialize(GLint tex_width, GLint tex_height, u32 *pixels){ +gl__texture_initialize(GLint tex_width, GLint tex_height, u32 *pixels){ GLuint tex; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); - glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, tex_width, tex_height, 0, GL_ALPHA, GL_UNSIGNED_INT, pixels); + glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, tex_width, tex_height, 0, GL_RED, GL_UNSIGNED_INT, pixels); + return(tex); +} +#endif + +internal u32 +gl__get_gpu_texture(Vec3_i32 dim, Texture_Kind texture_kind){ + u32 tex; + glGenTextures(1, &tex); + glBindTexture(GL_TEXTURE_2D, tex); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0); + glTexStorage3D(GL_TEXTURE_2D_ARRAY, 0, GL_R8, dim.x, dim.y, 0, GL_RED, GL_UNSIGNED_INT, 0); return(tex); } internal void -private_draw_bind_texture(Render_Target *t, i32 texid){ +gl__draw_bind_texture(Render_Target *t, i32 texid){ if (t->bound_texture != texid){ glBindTexture(GL_TEXTURE_2D, texid); t->bound_texture = texid; } } -internal void -private_draw_set_color(Render_Target *t, u32 color){ - if (t->color != color){ - t->color = color; - Vec4 c = unpack_color4(color); - glColor4f(c.r, c.g, c.b, c.a); - } +internal void CALL_CONVENTION +gl__error_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, char *message, void *userParam){ + InvalidPath; } +char *gl__header = R"foo(#version 150 +)foo"; + +char *gl__vertex = R"foo( +uniform vec2 view_t; +uniform mat2x2 view_m; + uniform vec4 color; +in vec2 vertex_p; +in vec2 vertex_t; +smooth out vec4 fragment_color; +smooth out vec2 uv; +void main(void) +{ +gl_Position = vec4(view_m*(vertex_p - view_t), 0.f, 1.f); +fragment_color = color; +uv = vertex_t; +} +)foo"; + +char *gl__fragment = R"foo( +smooth in vec4 fragment_color; +smooth in vec2 uv; +uniform sampler2D sampler; +uniform float texture_override; +out vec4 out_color; +void main(void) +{ +out_color = fragment_color*(texture(sampler, uv).r + texture_override); +} +)foo"; + +#define AttributeList(X) \ +X(vertex_p) \ +X(vertex_t) + +#define UniformList(X) \ +X(view_t) \ +X(view_m) \ +X(color) \ +X(sampler) \ +X(texture_override) + +struct GL_Program{ + u32 program; +#define GetAttributeLocation(N) i32 N; + AttributeList(GetAttributeLocation) +#undef GetAttributeLocation +#define GetUniformLocation(N) i32 N; + UniformList(GetUniformLocation) +#undef GetUniformLocation +}; + +internal GL_Program +gl__make_program(char *header, char *vertex, char *fragment){ + if (header == 0){ + header = ""; + } + + GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); + GLchar *vertex_source_array[] = { header, vertex }; + glShaderSource(vertex_shader, ArrayCount(vertex_source_array), vertex_source_array, 0); + glCompileShader(vertex_shader); + + GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); + GLchar *fragment_source_array[] = { header, fragment }; + glShaderSource(fragment_shader, ArrayCount(fragment_source_array), fragment_source_array, 0); + glCompileShader(fragment_shader); + + GLuint program = glCreateProgram(); + glAttachShader(program, vertex_shader); + glAttachShader(program, fragment_shader); + glLinkProgram(program); + glValidateProgram(program); + + GLint success = false; + glGetProgramiv(program, GL_LINK_STATUS, &success); + if (!success){ + GLsizei ignore = 0; + char vertex_errors[KB(4)]; + char fragment_errors[KB(4)]; + char program_errors[KB(4)]; + glGetShaderInfoLog(vertex_shader, sizeof(vertex_errors), &ignore, vertex_errors); + glGetShaderInfoLog(fragment_shader, sizeof(fragment_errors), &ignore, fragment_errors); + glGetProgramInfoLog(program, sizeof(program_errors), &ignore, program_errors); +#if SHIP_MODE + os_popup_window(string_u8_litexpr("Error"), string_u8_litexpr("Shader compilation failed.")); +#endif + InvalidPath; + } + + glDeleteShader(vertex_shader); + glDeleteShader(fragment_shader); + + GL_Program result = {}; + result.program = program; +#define GetAttributeLocation(N) result.N = glGetAttribLocation(program, #N); + AttributeList(GetAttributeLocation) +#undef GetAttributeLocation +#define GetUniformLocation(N) result.N = glGetUniformLocation(program, #N); + UniformList(GetUniformLocation) +#undef GetUniformLocation + return(result); +} + +#define GLOffset(p,m) ((void*)(OffsetOfMemberStruct(p,m))) + internal void -interpret_render_buffer(Render_Target *t, Arena *scratch){ +gl_render(Render_Target *t, Arena *scratch){ local_persist b32 first_opengl_call = true; + local_persist u32 attribute_buffer = 0; + local_persist GL_Program gpu_program = {}; + if (first_opengl_call){ first_opengl_call = false; - char *vendor = (char *)glGetString(GL_VENDOR); - char *renderer = (char *)glGetString(GL_RENDERER); - char *version = (char *)glGetString(GL_VERSION); - - LOGF("GL_VENDOR: %s\n", vendor); - LOGF("GL_RENDERER: %s\n", renderer); - LOGF("GL_VERSION: %s\n", version); - - // TODO(allen): Get this up and running for dev mode again. -#if (defined(BUILD_X64) && 0) || (defined(BUILD_X86) && 0) - // NOTE(casey): This slows down GL but puts error messages to - // the debug console immediately whenever you do something wrong - - void CALL_CONVENTION gl_dbg(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam); - - glDebugMessageCallback_type *glDebugMessageCallback = - (glDebugMessageCallback_type *)win32_load_gl_always("glDebugMessageCallback", module); - glDebugMessageControl_type *glDebugMessageControl = - (glDebugMessageControl_type *)win32_load_gl_always("glDebugMessageControl", module); - if(glDebugMessageCallback != 0 && glDebugMessageControl != 0) - { - glDebugMessageCallback(opengl_debug_callback, 0); - glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE); - glEnable(GL_DEBUG_OUTPUT); - glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); - } +#if !SHIP_MODE + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, 0, true); + glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0, 0, true); + glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, 0, true); + glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, 0, true); + glDebugMessageCallback(gl__error_callback, 0); #endif - glEnable(GL_TEXTURE_2D); + //////////////////////////////// + + GLuint dummy_vao = 0; + glGenVertexArrays(1, &dummy_vao); + glBindVertexArray(dummy_vao); + + //////////////////////////////// + + glGenBuffers(1, &attribute_buffer); + glBindBuffer(GL_ARRAY_BUFFER, attribute_buffer); + + //////////////////////////////// + glEnable(GL_SCISSOR_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + //////////////////////////////// + + gpu_program = gl__make_program(gl__header, gl__vertex, gl__fragment); + glUseProgram(gpu_program.program); } i32 width = t->width; i32 height = t->height; glViewport(0, 0, width, height); - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - glOrtho(0, width, height, 0, -1, 1); glScissor(0, 0, width, height); glClearColor(1.f, 0.f, 1.f, 1.f); glClear(GL_COLOR_BUFFER_BIT); @@ -102,9 +214,6 @@ interpret_render_buffer(Render_Target *t, Arena *scratch){ glBindTexture(GL_TEXTURE_2D, 0); t->bound_texture = 0; - glColor4f(0.f, 0.f, 0.f, 0.f); - t->color = 0; - for (Render_Free_Texture *free_texture = t->free_texture_first; free_texture != 0; free_texture = free_texture->next){ @@ -124,45 +233,45 @@ interpret_render_buffer(Render_Target *t, Arena *scratch){ case RenCom_Rectangle: { Render_Command_Rectangle *rectangle = (Render_Command_Rectangle*)header; - f32_Rect r = rectangle->rect; - private_draw_set_color(t, rectangle->color); - private_draw_bind_texture(t, 0); - glBegin(GL_QUADS); - { - glVertex2f(r.x0, r.y0); - glVertex2f(r.x0, r.y1); - glVertex2f(r.x1, r.y1); - glVertex2f(r.x1, r.y0); - } - glEnd(); - }break; - - case RenCom_Outline: - { - Render_Command_Rectangle *rectangle = (Render_Command_Rectangle*)header; - f32_Rect r = rect_inner(rectangle->rect, .5f); - private_draw_set_color(t, rectangle->color); - private_draw_bind_texture(t, 0); - glBegin(GL_LINE_STRIP); - { - glVertex2f(r.x0, r.y0); - glVertex2f(r.x1, r.y0); - glVertex2f(r.x1, r.y1); - glVertex2f(r.x0, r.y1); - glVertex2f(r.x0, r.y0); - } - glEnd(); + gl__draw_bind_texture(t, 0); + + Vec4 c = unpack_color4(rectangle->color); + + i32 vertex_count = ArrayCount(rectangle->vertices); + glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle->vertices), rectangle->vertices, GL_STREAM_DRAW); + glEnableVertexAttribArray(gpu_program.vertex_p); + glVertexAttribPointer(gpu_program.vertex_p, 2, GL_FLOAT, true, sizeof(rectangle->vertices[0]), 0); + + glUniform2f(gpu_program.view_t, width/2.f, height/2.f); + f32 m[4] = { + 2.f/width, 0.f, + 0.f, -2.f/height, + }; + glUniformMatrix2fv(gpu_program.view_m, 1, GL_FALSE, m); + glUniform4f(gpu_program.color, c.r, c.g, c.b, c.a); + glUniform1f(gpu_program.texture_override, 1.f); + + glDrawArrays(GL_TRIANGLE_STRIP, 0, vertex_count); + glDisableVertexAttribArray(gpu_program.vertex_p); }break; case RenCom_Glyph: { Render_Command_Glyph *glyph = (Render_Command_Glyph*)header; +#if 0 Font_Pointers font = system_font_get_pointers_by_id(glyph->font_id); if (!font.valid){ break; } +#endif + Face *face = 0; + if (face == 0){ + break; + } u32 codepoint = glyph->codepoint; + +#if 0 u32 page_number = codepoint/GLYPHS_PER_PAGE; Glyph_Page *page = font_cached_get_page(font.pages, page_number); if (page == 0){ @@ -175,10 +284,9 @@ interpret_render_buffer(Render_Target *t, Arena *scratch){ i32 tex_height = 0; u32 *pixels = font_load_page_pixels(scratch, font.settings, page, page_number, &tex_width, &tex_height); page->has_gpu_setup = true; - page->gpu_tex = private_texture_initialize(tex_width, tex_height, pixels); + page->gpu_tex = gl__texture_initialize(tex_width, tex_height, pixels); end_temp(temp); } - if (page->gpu_tex == 0){ break; } @@ -189,38 +297,76 @@ interpret_render_buffer(Render_Target *t, Arena *scratch){ i32 tex_width = page->tex_width; i32 tex_height = page->tex_height; - f32 x = glyph->pos.x; - f32 y = glyph->pos.y; - - f32_Rect uv = {}; - // TODO(allen): do(think about baking unit_u/unit_v into font data) f32 unit_u = 1.f/tex_width; f32 unit_v = 1.f/tex_height; +#else - uv.x0 = bounds.x0*unit_u; - uv.y0 = bounds.y0*unit_v; - uv.x1 = bounds.x1*unit_u; - uv.y1 = bounds.y1*unit_v; + u16 glyph_index = 0; + if (!table_read(&face->codepoint_to_index_table, codepoint, &glyph_index)){ + glyph_index = 0; + } + Glyph_Bounds bounds = face->bounds[glyph_index]; + GLuint tex = face->gpu_texture; + Vec3_f32 gpu_texture_dim = face->gpu_texture_dim; +#endif - private_draw_set_color(t, glyph->color); - private_draw_bind_texture(t, tex); - glBegin(GL_QUADS); - if ((glyph->flags & GlyphFlag_Rotate90) == 0){ - glTexCoord2f(uv.x0, uv.y1); glVertex2f(x + bounds.xoff , y + bounds.yoff2); - glTexCoord2f(uv.x1, uv.y1); glVertex2f(x + bounds.xoff2, y + bounds.yoff2); - glTexCoord2f(uv.x1, uv.y0); glVertex2f(x + bounds.xoff2, y + bounds.yoff ); - glTexCoord2f(uv.x0, uv.y0); glVertex2f(x + bounds.xoff , y + bounds.yoff ); + f32 x = glyph->pos.x; + f32 y = glyph->pos.y; + + f32_Rect uv = Rf32(bounds.uv.x0, bounds.uv.y0, + bounds.uv.x1, bounds.uv.y1); + f32_Rect xy = Rf32(x + bounds.xy_off.x0, y + bounds.xy_off.y0, + x + bounds.xy_off.x1, y + bounds.xy_off.y1); + + struct Textutred_Vertex{ + Vec2 xy; + Vec2 uv; + }; + + Textutred_Vertex vertices[4]; + if (!HasFlag(glyph->flags, GlyphFlag_Rotate90)){ + vertices[0].xy = V2(xy.x0, xy.y1); vertices[0].uv = V2(uv.x0, uv.y1); + vertices[1].xy = V2(xy.x1, xy.y1); vertices[1].uv = V2(uv.x1, uv.y1); + vertices[2].xy = V2(xy.x0, xy.y0); vertices[2].uv = V2(uv.x0, uv.y0); + vertices[3].xy = V2(xy.x1, xy.y0); vertices[3].uv = V2(uv.x1, uv.y0); } else{ - glTexCoord2f(uv.x0, uv.y1); glVertex2f(x + bounds.yoff2, y + bounds.xoff2); - glTexCoord2f(uv.x1, uv.y1); glVertex2f(x + bounds.yoff2, y + bounds.xoff ); - glTexCoord2f(uv.x1, uv.y0); glVertex2f(x + bounds.yoff , y + bounds.xoff ); - glTexCoord2f(uv.x0, uv.y0); glVertex2f(x + bounds.yoff , y + bounds.xoff2); + vertices[0].xy = V2(xy.x0, xy.y1); vertices[0].uv = V2(uv.x1, uv.y1); + vertices[1].xy = V2(xy.x1, xy.y1); vertices[1].uv = V2(uv.x1, uv.y0); + vertices[2].xy = V2(xy.x0, xy.y0); vertices[2].uv = V2(uv.x0, uv.y1); + vertices[3].xy = V2(xy.x1, xy.y0); vertices[3].uv = V2(uv.x0, uv.y0); } - glEnd(); + gl__draw_bind_texture(t, tex); + + Vec4 c = unpack_color4(glyph->color); + + i32 vertex_count = ArrayCount(vertices); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STREAM_DRAW); + glEnableVertexAttribArray(gpu_program.vertex_p); + glEnableVertexAttribArray(gpu_program.vertex_t); + glVertexAttribPointer(gpu_program.vertex_p, 2, GL_FLOAT, true, sizeof(vertices[0]), GLOffset(&vertices[0], xy)); + glVertexAttribPointer(gpu_program.vertex_t, 2, GL_FLOAT, true, sizeof(vertices[0]), GLOffset(&vertices[0], uv)); + + glUniform2f(gpu_program.view_t, width/2.f, height/2.f); + f32 m[4] = { + 2.f/width, 0.f, + 0.f, -2.f/height, + }; + glUniformMatrix2fv(gpu_program.view_m, 1, GL_FALSE, m); + glUniform4f(gpu_program.color, c.r, c.g, c.b, c.a); + + glUniform1i(gpu_program.sampler, 0); + glUniform1f(gpu_program.texture_override, 0.f); + + glDrawArrays(GL_TRIANGLE_STRIP, 0, vertex_count); + glDisableVertexAttribArray(gpu_program.vertex_p); + glDisableVertexAttribArray(gpu_program.vertex_t); + +#if 0 if (codepoint != ' ' && font.settings->parameters.underline){ + // TODO(allen): recover this feature glDisable(GL_TEXTURE_2D); f32 x0 = x; @@ -239,6 +385,7 @@ interpret_render_buffer(Render_Target *t, Arena *scratch){ glEnable(GL_TEXTURE_2D); } +#endif }break; case RenCom_ChangeClip: diff --git a/platform_all/4ed_link_system_functions.cpp b/platform_all/4ed_link_system_functions.cpp index 471a283f..f1f00e7e 100644 --- a/platform_all/4ed_link_system_functions.cpp +++ b/platform_all/4ed_link_system_functions.cpp @@ -63,8 +63,6 @@ link_system_code(){ SYSLINK(set_fullscreen); SYSLINK(is_fullscreen); SYSLINK(show_mouse_cursor); - - SYSLINK(log); } // BOTTOM diff --git a/platform_all/4ed_shared_init_logic.cpp b/platform_all/4ed_shared_init_logic.cpp index b245c1e3..a0577d4c 100644 --- a/platform_all/4ed_shared_init_logic.cpp +++ b/platform_all/4ed_shared_init_logic.cpp @@ -46,11 +46,11 @@ memory_init(){ internal void load_app_code(void){ - LOG("Loading 4coder core..."); + //LOG("Loading 4coder core..."); App_Get_Functions *get_funcs = 0; - if (system_load_library(&libraries.app_code, "4ed_app", LoadLibrary_BinaryDirectory)){ + if (system_load_library(&shared_vars.scratch, &libraries.app_code, "4ed_app", LoadLibrary_BinaryDirectory)){ get_funcs = (App_Get_Functions*)system_get_proc(&libraries.app_code, "app_get_functions"); } else{ @@ -95,7 +95,7 @@ load_custom_code(){ for (u32 i = 0; custom_files[i] != 0 && !has_library; ++i){ char *file = custom_files[i]; for (u32 j = 0; j < ArrayCount(locations) && !has_library; ++j){ - if (system_load_library(&libraries.custom, file, locations[j], success_file, sizeof(success_file))){ + if (system_load_library(&shared_vars.scratch, &libraries.custom, file, locations[j], success_file, sizeof(success_file))){ has_library = true; success_file[sizeof(success_file) - 1] = 0; } @@ -120,12 +120,12 @@ load_custom_code(){ system_error_box(custom_fail_missing_get_bindings_msg); } - LOGF("Loaded custom file: %s\n", success_file); + //LOGF("Loaded custom file: %s\n", success_file); } internal void read_command_line(i32 argc, char **argv){ - LOG("Reading command line\n"); + //LOG("Reading command line\n"); char cwd[4096]; u32 size = sysfunc.get_current_path(cwd, sizeof(cwd)); if (size == 0 || size >= sizeof(cwd)){ @@ -139,7 +139,7 @@ read_command_line(i32 argc, char **argv){ i32 *file_count = 0; app.read_command_line(&sysfunc, &memory_vars, curdir, &plat_settings, &files, &file_count, argc, argv); sysshared_filter_real_files(files, file_count); - LOG("Read command line.\n"); + //LOG("Read command line.\n"); } internal void diff --git a/platform_all/4ed_shared_library_constants.h b/platform_all/4ed_shared_library_constants.h index 9a5b43d0..4a5dea1c 100644 --- a/platform_all/4ed_shared_library_constants.h +++ b/platform_all/4ed_shared_library_constants.h @@ -36,59 +36,57 @@ enum{ }; internal b32 -system_load_library(Library *library, char *name, Load_Library_Location location, char *full_file_out, u32 full_file_max){ - char space[4096]; - String extension = file_extension(make_string_slowly(name)); - if (!match(extension, DLL)){ - String full_name = make_fixed_width_string(space); - append(&full_name, name); - append(&full_name, "." DLL); - if (terminate_with_null(&full_name)){ - name = space; - } - else{ - name = 0; - } +system_load_library(Arena *scratch, Library *library, char *name_cstr, Load_Library_Location location, char *full_file_out, u32 full_file_max){ + Temp_Memory temp = begin_temp(scratch); + + String_Const_char name = SCchar(name_cstr); + String_Const_char extension = string_file_extension(name); + if (!string_match(extension, string_litexpr( DLL ))){ + String_Const_char full_name = push_stringf(scratch, "%.*s." DLL, string_expand(name)); + name_cstr = full_name.str; } - char path_space[4096]; - String path = make_fixed_width_string(path_space); + umem memory_size = KB(4); + String_Const_char path = {}; + path.str = push_array(scratch, char, memory_size); switch (location){ case LoadLibrary_CurrentDirectory: { - path.size = sysfunc.get_current_path(path.str, path.memory_size); + path.size = (umem)sysfunc.get_current_path(path.str, (i32)memory_size); }break; case LoadLibrary_BinaryDirectory: { - path.size = sysfunc.get_4ed_path(path.str, path.memory_size); + path.size = (umem)sysfunc.get_4ed_path(path.str, (i32)memory_size); }break; - default: LOG("Invalid library location passed.\n"); break; + //default: LOG("Invalid library location passed.\n"); break; } b32 success = false; if (path.size > 0){ if (path.str[path.size - 1] != SLASH){ - append(&path, SLASH); + path = push_stringf(scratch, "%.*s%c%.*s", string_expand(path), SLASH, string_expand(name)); + } + else{ + path = push_stringf(scratch, "%.*s%.*s", string_expand(path), string_expand(name)); } - append(&path, name); - terminate_with_null(&path); success = system_load_library_direct(library, path.str); - if (success && full_file_out != 0){ - String out = make_string_cap(full_file_out, 0, full_file_max); - copy(&out, path); - terminate_with_null(&out); + if (success && full_file_out != 0 && full_file_out > 0){ + u32 fill_size = clamp_top((u32)(path.size), (u32)(full_file_max - 1)); + block_copy(full_file_out, path.str, fill_size); + full_file_out[fill_size] = 0; } } + end_temp(temp); + return(success); } internal b32 -system_load_library(Library *library, char *name, Load_Library_Location location){ - b32 result = system_load_library(library, name, location, 0, 0); - return(result); +system_load_library(Arena *scratch, Library *library, char *name, Load_Library_Location location){ + return(system_load_library(scratch, library, name, location, 0, 0)); } #endif diff --git a/platform_all/4ed_system_shared.cpp b/platform_all/4ed_system_shared.cpp index 3f5de7fe..12cfdd98 100644 --- a/platform_all/4ed_system_shared.cpp +++ b/platform_all/4ed_system_shared.cpp @@ -16,12 +16,6 @@ // Standard implementation of file system stuff based on the file track layer. // -internal i32 -system_get_binary_path_string(String *out){ - out->size = system_get_4ed_path(out->str, out->memory_size); - return(out->size); -} - internal void init_shared_vars(){ shared_vars.scratch = make_arena_system(&sysfunc); @@ -46,20 +40,6 @@ sysshared_filter_real_files(char **files, i32 *file_count){ *file_count = j; } -internal b32 -sysshared_to_binary_path(String *out_filename, char *filename){ - b32 translate_success = 0; - i32 max = out_filename->memory_size; - i32 size = out_filename->size = system_get_4ed_path(out_filename->str, out_filename->memory_size); - if (size > 0 && size < max-1){ - out_filename->size = size; - if (append_sc(out_filename, filename) && terminate_with_null(out_filename)){ - translate_success = 1; - } - } - return(translate_success); -} - #endif // BOTTOM diff --git a/platform_linux/linux_4ed.cpp b/platform_linux/linux_4ed.cpp index c9027f63..13159308 100644 --- a/platform_linux/linux_4ed.cpp +++ b/platform_linux/linux_4ed.cpp @@ -37,7 +37,6 @@ #include "4ed_font.h" #include "4ed_system.h" -#include "4ed_log.h" #include "4ed_render_target.h" #include "4ed_render_format.h" #include "4ed.h" @@ -86,7 +85,7 @@ #define frame_useconds (1000000UL / FPS) #define LINUX_FN_DEBUG(fmt, ...) do { \ - LOGF("%s: " fmt "\n", __func__, ##__VA_ARGS__); \ + /*LOGF("%s: " fmt "\n", __func__, ##__VA_ARGS__);*/ \ } while (0) // TODO(allen): Make an intrinsics header that uses the cracked OS to define a single set of intrinsic names. @@ -678,7 +677,7 @@ linux_get_loadable_fonts(Partition *part, Font_Setup_List *list){ FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, FC_FILE, (char*)0); FcFontSet* fs = FcFontList(fc_config, pat, os); if (fs != 0){ - LOGF("Total matching fonts: %d\n", fs->nfont); + //LOGF("Total matching fonts: %d\n", fs->nfont); for (int i=0; fs && i < fs->nfont; ++i) { FcPattern* font = fs->fonts[i]; FcChar8 *file = 0; @@ -776,7 +775,7 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler); if (glXCreateContextAttribsARB == 0){ - LOG("glXCreateContextAttribsARB() not found, using old-style GLX context\n" ); + //LOG("glXCreateContextAttribsARB() not found, using old-style GLX context\n" ); ctx = glXCreateNewContext( XDisplay, *best_config, GLX_RGBA_TYPE, 0, True ); } else{ @@ -790,15 +789,15 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con None }; - LOG("Creating GL 2.1 context... "); + //LOG("Creating GL 2.1 context... "); ctx = glXCreateContextAttribsARB(XDisplay, *best_config, 0, True, context_attribs); XSync( XDisplay, False ); if (!ctxErrorOccurred && ctx){ - LOG("Created GL 2.1 context.\n"); + //LOG("Created GL 2.1 context.\n"); } else{ - LOG("Could not create a context.\n"); + //LOG("Could not create a context.\n"); exit(1); } } @@ -807,21 +806,21 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con XSetErrorHandler(oldHandler); if (ctxErrorOccurred || !ctx){ - LOG("Failed to create an OpenGL context\n"); + //LOG("Failed to create an OpenGL context\n"); exit(1); } b32 Direct; if (!glXIsDirect(XDisplay, ctx)){ - LOG("Indirect GLX rendering context obtained\n"); + //LOG("Indirect GLX rendering context obtained\n"); Direct = false; } else{ - LOG("Direct GLX rendering context obtained\n"); + //LOG("Direct GLX rendering context obtained\n"); Direct = true; } - LOG("Making context current\n"); + //LOG("Making context current\n"); glXMakeCurrent( XDisplay, XWindow, ctx ); //TODO(inso): glGetStringi is required in core profile if the GL version is >= 3.0 @@ -838,7 +837,7 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con glXQueryDrawable(XDisplay, XWindow, GLX_SWAP_INTERVAL_EXT, &swap_val); linuxvars.vsync = (swap_val == true); - LOGF("VSync enabled? %s.\n", linuxvars.vsync ? "Yes" : "No"); + //LOGF("VSync enabled? %s.\n", linuxvars.vsync ? "Yes" : "No"); } } @@ -852,12 +851,12 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con if (glXGetSwapIntervalMESA != 0){ linuxvars.vsync = glXGetSwapIntervalMESA(); - LOGF("VSync enabled? %s (MESA)\n", linuxvars.vsync ? "Yes" : "No"); + //LOGF("VSync enabled? %s (MESA)\n", linuxvars.vsync ? "Yes" : "No"); } else{ // NOTE(inso): assume it worked? linuxvars.vsync = true; - LOG("VSync enabled? possibly (MESA)\n"); + //LOG("VSync enabled? possibly (MESA)\n"); } } @@ -870,12 +869,12 @@ InitializeOpenGLContext(Display *XDisplay, Window XWindow, GLXFBConfig *best_con // NOTE(inso): The SGI one doesn't seem to have a way to confirm we got it... linuxvars.vsync = true; - LOG("VSync enabled? hopefully (SGI)\n"); + //LOG("VSync enabled? hopefully (SGI)\n"); } } else{ - LOG("VSync enabled? nope, no suitable extension\n"); + //LOG("VSync enabled? nope, no suitable extension\n"); } return(ctx); @@ -889,10 +888,10 @@ GLXCanUseFBConfig(Display *XDisplay) int GLXMajor, GLXMinor; char *XVendor = ServerVendor(XDisplay); - LOGF("XWindows vendor: %s\n", XVendor); + //LOGF("XWindows vendor: %s\n", XVendor); if (glXQueryVersion(XDisplay, &GLXMajor, &GLXMinor)) { - LOGF("GLX version %d.%d\n", GLXMajor, GLXMinor); + //LOGF("GLX version %d.%d\n", GLXMajor, GLXMinor); if (((GLXMajor == 1 ) && (GLXMinor >= 3)) || (GLXMajor > 1)) { Result = true; @@ -939,7 +938,7 @@ ChooseGLXConfig(Display *XDisplay, int XScreenIndex) int id = 0; glXGetFBConfigAttrib(XDisplay, Result.BestConfig, GLX_FBCONFIG_ID, &id); - LOGF("Using FBConfig: %d (0x%x)\n", id, id); + //LOGF("Using FBConfig: %d (0x%x)\n", id, id); XFree(VI); } @@ -971,12 +970,12 @@ LinuxInputInit(Display *dpy, Window XWindow){ setlocale(LC_ALL, ""); XSetLocaleModifiers(""); b32 locale_supported = XSupportsLocale(); - LOGF("Supported locale?: %s.\n", locale_supported ? "Yes" : "No"); + //LOGF("Supported locale?: %s.\n", locale_supported ? "Yes" : "No"); if (!locale_supported){ - LOG("Reverting to 'C' ... "); + //LOG("Reverting to 'C' ... "); setlocale(LC_ALL, "C"); locale_supported = XSupportsLocale(); - LOGF("C is supported? %s.\n", locale_supported ? "Yes" : "No"); + //LOGF("C is supported? %s.\n", locale_supported ? "Yes" : "No"); } result.input_method = XOpenIM(dpy, 0, 0, 0); @@ -1010,13 +1009,13 @@ LinuxInputInit(Display *dpy, Window XWindow){ } else{ result = null_init_input_result; - LOG("Could not get minimum required input style.\n"); + //LOG("Could not get minimum required input style.\n"); exit(1); } } else{ result = null_init_input_result; - LOG("Could not open X Input Method.\n"); + //LOG("Could not open X Input Method.\n"); exit(1); } @@ -1189,7 +1188,7 @@ LinuxGetXSettingsDPI(Display* dpy, int screen) Atom XSET_SET = XInternAtom(dpy, "_XSETTINGS_SETTINGS", True); if (XSET_SEL == None || XSET_SET == None){ - LOG("XSETTINGS unavailable.\n"); + //LOG("XSETTINGS unavailable.\n"); return(dpi); } @@ -1206,12 +1205,12 @@ LinuxGetXSettingsDPI(Display* dpy, int screen) unsigned long pad, num; if (XGetWindowProperty(dpy, xset_win, XSET_SET, 0, 1024, False, XSET_SET, &type, &fmt, &num, &pad, &prop) != Success){ - LOG("XSETTINGS: GetWindowProperty failed.\n"); + //LOG("XSETTINGS: GetWindowProperty failed.\n"); goto out; } if (fmt != 8){ - LOG("XSETTINGS: Wrong format.\n"); + //LOG("XSETTINGS: Wrong format.\n"); goto out; } } @@ -1220,7 +1219,7 @@ LinuxGetXSettingsDPI(Display* dpy, int screen) p = (char*)(xs + 1); if (xs->byte_order != 0){ - LOG("FIXME: XSETTINGS not host byte order?\n"); + //LOG("FIXME: XSETTINGS not host byte order?\n"); goto out; } @@ -1253,7 +1252,7 @@ LinuxGetXSettingsDPI(Display* dpy, int screen) } break; default: { - LOG("XSETTINGS: Got invalid type...\n"); + //LOG("XSETTINGS: Got invalid type...\n"); goto out; } break; } @@ -1457,7 +1456,7 @@ linux_handle_x11_events(void) //TODO(inso): handle properly Xutf8ResetIC(linuxvars.input_context); XSetICFocus(linuxvars.input_context); - LOG("FIXME: XBufferOverflow from LookupString.\n"); + //LOG("FIXME: XBufferOverflow from LookupString.\n"); } // don't push modifiers @@ -1478,7 +1477,7 @@ linux_handle_x11_events(void) //TODO(inso): handle properly Xutf8ResetIC(linuxvars.input_context); XSetICFocus(linuxvars.input_context); - LOG("FIXME: XBufferOverflow from LookupString.\n"); + //LOG("FIXME: XBufferOverflow from LookupString.\n"); } if (*buff_no_caps){ @@ -1973,7 +1972,7 @@ main(int argc, char **argv){ linuxvars.XDisplay = XOpenDisplay(0); if (!linuxvars.XDisplay){ // NOTE(inso): probably not worth trying the popup in this case... - LOG("Can't open display!\n"); + //LOG("Can't open display!\n"); exit(1); } @@ -2009,10 +2008,10 @@ main(int argc, char **argv){ linuxvars.dpi_x = dw_mm ? dw / (dw_mm / 25.4) : 96; linuxvars.dpi_y = dh_mm ? dh / (dh_mm / 25.4) : 96; - LOGF("%dx%d - %dmmx%dmm DPI: %dx%d\n", dw, dh, dw_mm, dh_mm, linuxvars.dpi_x, linuxvars.dpi_y); + //LOGF("%dx%d - %dmmx%dmm DPI: %dx%d\n", dw, dh, dw_mm, dh_mm, linuxvars.dpi_x, linuxvars.dpi_y); } else{ - LOGF("DPI from XSETTINGS: %d\n", linuxvars.dpi_x); + //LOGF("DPI from XSETTINGS: %d\n", linuxvars.dpi_x); } int window_width, window_height; @@ -2028,7 +2027,7 @@ main(int argc, char **argv){ XFixesSelectSelectionInput(linuxvars.XDisplay, linuxvars.XWindow, linuxvars.atom_CLIPBOARD, XFixesSetSelectionOwnerNotifyMask); } else{ - LOG("Your X server doesn't support XFIXES, mention this fact if you report any clipboard-related issues.\n"); + //LOG("Your X server doesn't support XFIXES, mention this fact if you report any clipboard-related issues.\n"); } Init_Input_Result input_result = LinuxInputInit(linuxvars.XDisplay, linuxvars.XWindow); @@ -2109,7 +2108,7 @@ main(int argc, char **argv){ terminate_with_null(&curdir); replace_char(&curdir, '\\', '/'); - LOG("Initializing application variables\n"); + //LOG("Initializing application variables\n"); app.init(&sysfunc, &target, &memory_vars, linuxvars.clipboard_contents, curdir, custom_api); LinuxResizeTarget(window_width, window_height); @@ -2140,7 +2139,7 @@ main(int argc, char **argv){ if (num_events == -1){ if (errno != EINTR){ - LOG("epoll_wait\n"); + //LOG("epoll_wait\n"); } continue; } @@ -2215,7 +2214,7 @@ main(int argc, char **argv){ result = app.step(&sysfunc, &target, &memory_vars, &frame_input); } else{ - LOG("app.step == 0 -- skipping\n"); + //LOG("app.step == 0 -- skipping\n"); } @@ -2242,7 +2241,7 @@ main(int argc, char **argv){ } // NOTE(allen): Render - interpret_render_buffer(&target, &shared_vars.pixel_scratch); + gl_render(&target, &shared_vars.pixel_scratch); glXSwapBuffers(linuxvars.XDisplay, linuxvars.XWindow); // NOTE(allen): Toggle Full Screen diff --git a/platform_linux/linux_error_box.cpp b/platform_linux/linux_error_box.cpp index 99d8afa6..a473cafc 100644 --- a/platform_linux/linux_error_box.cpp +++ b/platform_linux/linux_error_box.cpp @@ -13,7 +13,7 @@ // HACK(allen): // NOTE(inso): this was a quick hack, might need some cleanup. internal void system_error_box(char *msg, b32 shutdown = true){ - LOGF("Fatal Error: %s\n", msg); + //LOGF("Fatal Error: %s\n", msg); Display *dpy = XOpenDisplay(0); if (!dpy){ diff --git a/platform_mac/mac_4ed.cpp b/platform_mac/mac_4ed.cpp index 3c5f3a77..c6930600 100644 --- a/platform_mac/mac_4ed.cpp +++ b/platform_mac/mac_4ed.cpp @@ -38,7 +38,6 @@ #include "4ed_font.h" #include "4ed_system.h" -#include "4ed_log.h" #include "4ed_render_target.h" #include "4ed_render_format.h" #include "4ed.h" @@ -722,7 +721,7 @@ osx_step(void){ result = app.step(&sysfunc, &target, &memory_vars, &frame_input); } else{ - LOG("app.step == 0 -- skipping\n"); + //LOG("app.step == 0 -- skipping\n"); } // NOTE(allen): Finish the Loop @@ -743,7 +742,7 @@ osx_step(void){ // NOTE(allen): Render osx_begin_render(); - interpret_render_buffer(&target, &shared_vars.pixel_scratch); + gl_render(&target, &shared_vars.pixel_scratch); osx_end_render(); // NOTE(allen): Toggle Full Screen @@ -865,7 +864,7 @@ osx_init(){ clipboard_string = make_string(osx_objc.clipboard_data, osx_objc.clipboard_size); } - LOG("Initializing application variables\n"); + //LOG("Initializing application variables\n"); app.init(&sysfunc, &target, &memory_vars, clipboard_string, curdir, custom_api); } diff --git a/platform_mac/mac_4ed.m b/platform_mac/mac_4ed.m index ecb0fba9..8bc86ed3 100644 --- a/platform_mac/mac_4ed.m +++ b/platform_mac/mac_4ed.m @@ -16,7 +16,6 @@ #include "4coder_API/4coder_version.h" #include "4coder_API/4coder_keycodes.h" -#include "4ed_log.h" #include "4ed_cursor_codes.h" #include "4ed_linked_node_macros.h" @@ -522,7 +521,7 @@ osx_file_listener_hash(u64 hash, void *name, i32 counter, File_Watching_Handle * } if (!result){ - LOG("file change listener table error: could not find a free slot in the table\n"); + //LOG("file change listener table error: could not find a free slot in the table\n"); } } diff --git a/platform_mac/mac_error_box.cpp b/platform_mac/mac_error_box.cpp index e95ba9ca..fba3df37 100644 --- a/platform_mac/mac_error_box.cpp +++ b/platform_mac/mac_error_box.cpp @@ -11,7 +11,7 @@ internal void system_error_box(char *msg, b32 shutdown = true){ - LOGF("error box: %s\n", msg); + //LOGF("error box: %s\n", msg); osx_error_dialogue(msg); if (shutdown){ exit(1); diff --git a/platform_mac/mac_fd_check.cpp b/platform_mac/mac_fd_check.cpp index 515c64fa..e53e1b74 100644 --- a/platform_mac/mac_fd_check.cpp +++ b/platform_mac/mac_fd_check.cpp @@ -39,11 +39,11 @@ print_open_file_descriptors(void){ if (descriptor_open(fd)){ char b[MAXPATHLEN + 1]; fcntl(fd, F_GETPATH, b); - LOGF("FD(%d) = \"%s\"\n", fd, b); + //LOGF("FD(%d) = \"%s\"\n", fd, b); } } } -#define FD_CHECK() LOG("FD_CHECK\n"); print_open_file_descriptors() +//#define FD_CHECK() LOG("FD_CHECK\n"); print_open_file_descriptors() // BOTTOM diff --git a/platform_unix/unix_4ed_functions.cpp b/platform_unix/unix_4ed_functions.cpp index 947f18f9..641eccba 100644 --- a/platform_unix/unix_4ed_functions.cpp +++ b/platform_unix/unix_4ed_functions.cpp @@ -32,44 +32,6 @@ Sys_Get_Current_Path_Sig(system_get_current_path){ return(result); } -// -// Logging -// - -internal -Sys_Log_Sig(system_log){ - if (plat_settings.use_log == LogTo_LogFile){ - char file_path_space[1024]; - String file_path = make_fixed_width_string(file_path_space); - file_path.size = system_get_4ed_path(file_path.str, file_path.memory_size); - append_sc(&file_path, "4coder_log.txt"); - terminate_with_null(&file_path); - - i32 fd = -1; - if (unixvars.did_first_log){ - fd = open(file_path.str, O_WRONLY | O_CREAT | O_APPEND, 00640); - } - else{ - fd = open(file_path.str, O_WRONLY | O_CREAT | O_TRUNC, 00640); - unixvars.did_first_log = true; - } - - if (fd >= 0){ - do{ - ssize_t written = write(fd, message, length); - if (written != -1){ - length -= written; - message += written; - } - } while(length > 0); - close(fd); - } - } - else if (plat_settings.use_log == LogTo_Stdout){ - fwrite(message, 1, length, stdout); - } -} - // // Shared system functions (system_shared.h) // @@ -77,7 +39,7 @@ Sys_Log_Sig(system_log){ internal Sys_File_Can_Be_Made_Sig(system_file_can_be_made){ b32 result = access((char*)filename, W_OK) == 0; - LOGF("%s = %d\n", filename, result); + //LOGF("%s = %d\n", filename, result); return(result); } @@ -91,7 +53,6 @@ system_memory_allocate_extended(void *base, umem size){ // We will count on the user to keep track of size themselves. void *result = mmap(base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if (result == MAP_FAILED){ - LOG("error: mmap failed\n"); result = 0; } return(result); @@ -132,7 +93,6 @@ Sys_Memory_Set_Protection_Sig(system_memory_set_protection){ if(mprotect(ptr, size, protect) == -1){ result = 0; - LOG("error: mprotect\n"); } return(result); @@ -159,7 +119,7 @@ Sys_Set_File_List_Sig(system_set_file_list){ return; } - LOGF("%s\n", directory); + //LOGF("%s\n", directory); DIR *d = opendir(directory); if (d != 0){ @@ -296,7 +256,7 @@ Sys_Get_Canonical_Sig(system_get_canonical){ #if defined(FRED_INTERNAL) if (len != (write_p - path) || memcmp(filename, path, len) != 0){ - LOGF("[%.*s] -> [%.*s]\n", len, filename, (int)(write_p - path), path); + //LOGF("[%.*s] -> [%.*s]\n", len, filename, (int)(write_p - path), path); } #endif @@ -313,10 +273,10 @@ Sys_Load_Handle_Sig(system_load_handle){ i32 fd = open(filename, O_RDONLY); if (fd == -1 || fd == 0){ - LOGF("upable to open file descriptor for %s\n", filename); + //LOGF("upable to open file descriptor for %s\n", filename); } else{ - LOGF("file descriptor (%d) == file %s\n", fd, filename); + //LOGF("file descriptor (%d) == file %s\n", fd, filename); *(i32*)handle_out = fd; result = true; } @@ -332,10 +292,10 @@ Sys_Load_Size_Sig(system_load_size){ struct stat st = {}; if (fstat(fd, &st) == -1){ - LOGF("unable to stat a file\n"); + //LOGF("unable to stat a file\n"); } else{ - LOGF("file descriptor (%d) has size %d\n", fd, (i32)st.st_size); + //LOGF("file descriptor (%d) has size %d\n", fd, (i32)st.st_size); result = st.st_size; } @@ -350,7 +310,7 @@ Sys_Load_File_Sig(system_load_file){ ssize_t n = read(fd, buffer, size); if (n == -1){ if (errno != EINTR){ - LOGF("error reading from file descriptor (%d)\n", fd); + //LOGF("error reading from file descriptor (%d)\n", fd); break; } } @@ -369,11 +329,11 @@ Sys_Load_Close_Sig(system_load_close){ i32 fd = *(i32*)&handle; if (close(fd) == -1){ - LOGF("error closing file descriptor (%d)\n", fd); + //LOGF("error closing file descriptor (%d)\n", fd); result = false; } else{ - LOGF("file descriptor (%d) closed\n", fd); + //LOGF("file descriptor (%d) closed\n", fd); } FD_CHECK(); @@ -385,16 +345,15 @@ internal Sys_Save_File_Sig(system_save_file){ i32 fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 00640); - LOGF("%s %d\n", filename, size); + //LOGF("%s %d\n", filename, size); if (fd < 0){ - LOGF("error: open '%s': %s\n", filename, strerror(errno)); + //LOGF("error: open '%s': %s\n", filename, strerror(errno)); } else{ do{ ssize_t written = write(fd, buffer, size); if (written == -1){ if (errno != EINTR){ - LOG("error: write\n"); break; } } @@ -419,7 +378,7 @@ Sys_File_Exists_Sig(system_file_exists){ char buff[PATH_MAX] = {}; if (len + 1 > PATH_MAX){ - LOG("system_directory_has_file: path too long\n"); + //LOG("system_directory_has_file: path too long\n"); } else{ memcpy(buff, filename, len); @@ -428,7 +387,7 @@ Sys_File_Exists_Sig(system_file_exists){ result = stat(buff, &st) == 0 && S_ISREG(st.st_mode); } - LOGF("%s: %d\n", buff, result); + //LOGF("%s: %d\n", buff, result); return(result); } diff --git a/platform_win32/win32_4ed.cpp b/platform_win32/win32_4ed.cpp index d794dc44..6b5dd219 100644 --- a/platform_win32/win32_4ed.cpp +++ b/platform_win32/win32_4ed.cpp @@ -21,6 +21,7 @@ #define frame_useconds (1000000 / FPS) #include "4coder_base_types.h" +#include "4coder_table.h" #include "4coder_API/4coder_version.h" #include @@ -28,14 +29,11 @@ #if defined(FRED_SUPER) # include "4coder_lib/4coder_heap.h" - -# include "4coder_lib/4coder_string.h" - -#include "4coder_base_types.cpp" - # include "4coder_lib/4coder_heap.cpp" -# define FSTRING_IMPLEMENTATION -# include "4coder_lib/4coder_string.h" + +# include "4coder_base_types.cpp" +# include "4coder_hash_functions.cpp" +# include "4coder_table.cpp" # include "4coder_API/4coder_keycodes.h" # include "4coder_API/4coder_default_colors.h" @@ -44,12 +42,8 @@ # include "4coder_default_bindings.cpp" #endif -#include "4coder_base_types.cpp" -//#include "4ed_math.h" - #include "4ed_font.h" #include "4ed_system.h" -#include "4ed_log.h" #include "4ed_render_target.h" #include "4ed_render_format.h" #include "4ed.h" @@ -57,6 +51,8 @@ #include #include "win32_gl.h" +# include "4coder_stringf.cpp" + #define GL_TEXTURE_MAX_LEVEL 0x813D ////////////////////////////// @@ -115,58 +111,6 @@ struct Win32_Input_Chunk{ //////////////////////////////// -// TODO(allen): MERGE WITH 4ed.exe version!!!!!!! - -internal void* -base_reserve__system(void *user_data, umem size, umem *size_out){ - System_Functions *system = (System_Functions*)user_data; - umem extra_size = 128; - umem increased_size = size + extra_size; - size = round_up_umem(increased_size, KB(4)); - *size_out = size - extra_size; - void *ptr = system->memory_allocate(size); - *(umem*)ptr = size; - ptr = (u8*)ptr + extra_size; - return(ptr); -} - -internal void -base_free__system(void *user_data, void *ptr){ - System_Functions *system = (System_Functions*)user_data; - umem extra_size = 128; - ptr = (u8*)ptr - extra_size; - umem size = *(umem*)ptr; - system->memory_free(ptr, size); -} - -internal Base_Allocator -make_base_allocator_system(System_Functions *system){ - return(make_base_allocator(base_reserve__system, 0, 0, - base_free__system, 0, system)); -} - -global Base_Allocator base_allocator_system = {}; - -internal Arena -make_arena_system(System_Functions *system, umem chunk_size, umem align){ - if (base_allocator_system.reserve == 0){ - base_allocator_system = make_base_allocator_system(system); - } - return(make_arena(&base_allocator_system, chunk_size, align)); -} - -internal Arena -make_arena_system(System_Functions *system, umem chunk_size){ - return(make_arena_system(system, chunk_size, 8)); -} - -internal Arena -make_arena_system(System_Functions *system){ - return(make_arena_system(system, KB(16), 8)); -} - -//////////////////////////////// - #define SLASH '\\' #define DLL "dll" @@ -181,6 +125,8 @@ global System_Functions sysfunc; #include "4ed_mem.cpp" #include "4coder_hash_functions.cpp" +#include "4ed_system_allocator.cpp" + //////////////////////////////// typedef i32 Win32_Object_Kind; @@ -217,11 +163,11 @@ struct Win32_Vars{ i32 cursor_show; i32 prev_cursor_show; - String binary_path; + String_Const_u8 binary_path; u8 *clip_buffer; u32 clip_max; - String clipboard_contents; + String_Const_u8 clipboard_contents; b32 next_clipboard_is_self; DWORD clipboard_sequence; @@ -269,13 +215,13 @@ win32_output_error_string(b32 use_error_box){ char *str = 0; char *str_ptr = (char*)&str; if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, error, 0, str_ptr, 0, 0)){ - LOGF("win32 error:\n%s\n", str); + //LOGF("win32 error:\n%s\n", str); if (use_error_box){ system_error_box(str, false); } } else{ - LOGF("win32 error raw: %d\n", error); + //LOGF("win32 error raw: %d\n", error); } } @@ -394,7 +340,7 @@ union Directory_Track_Node{ OVERLAPPED overlapped; HANDLE dir_handle; char buffer[(32 << 10) + 12]; - String dir_name; + String_Const_u8 dir_name; i32 ref_count; }; }; @@ -405,7 +351,7 @@ union File_Track_Node{ File_Track_Node *prev; }; struct{ - String file_name; + String_Const_u8 file_name; i32 ref_count; Directory_Track_Node *parent_dir; }; @@ -452,7 +398,7 @@ union File_Track_Instruction_Node{ struct File_Track_Note_Node{ File_Track_Note_Node *next; File_Track_Note_Node *prev; - String file_name; + String_Const_u8 file_name; }; Heap file_track_heap = {}; @@ -656,9 +602,9 @@ alloc_insert_CString_Ptr_table(CString_Ptr_Table *table, char*key, i32 key_size, //////////////////////////////// -internal String -file_track_store_string_copy(String string){ - i32 alloc_size = string.size + 1; +internal String_Const_u8 +file_track_store_string_copy(String_Const_u8 string){ + i32 alloc_size = (i32)string.size + 1; alloc_size = round_up_i32(alloc_size, 16); char *buffer = (char*)heap_allocate(&file_track_heap, alloc_size); if (buffer == 0){ @@ -670,17 +616,17 @@ file_track_store_string_copy(String string){ Assert(buffer != 0); memcpy(buffer, string.str, string.size); buffer[string.size] = 0; - return(make_string(buffer, string.size, alloc_size)); + return(SCu8(buffer, string.size)); } internal void -file_track_free_string(String string){ +file_track_free_string(String_Const_u8 string){ Assert(string.str != 0); heap_free(&file_track_heap, string.str); } internal Directory_Track_Node* -file_track_store_new_dir_node(String dir_name_string, HANDLE dir_handle){ +file_track_store_new_dir_node(String_Const_u8 dir_name_string, HANDLE dir_handle){ if (file_track_dir_free_first == 0){ u32 size = MB(1); void *new_block = system_memory_allocate(size); @@ -701,7 +647,7 @@ file_track_store_new_dir_node(String dir_name_string, HANDLE dir_handle){ } Directory_Track_Node *new_node = file_track_dir_free_first; zdll_remove(file_track_dir_free_first, file_track_dir_free_last, new_node); - alloc_insert_CString_Ptr_table(&file_track_dir_table, dir_name_string.str, dir_name_string.size, new_node); + alloc_insert_CString_Ptr_table(&file_track_dir_table, (char*)dir_name_string.str, (i32)dir_name_string.size, new_node); memset(&new_node->overlapped, 0, sizeof(new_node->overlapped)); new_node->dir_handle = dir_handle; new_node->dir_name = file_track_store_string_copy(dir_name_string); @@ -711,14 +657,14 @@ file_track_store_new_dir_node(String dir_name_string, HANDLE dir_handle){ internal void file_track_free_dir_node(Directory_Track_Node *node){ - erase_CString_Ptr_table(&file_track_dir_table, node->dir_name.str, node->dir_name.size); + erase_CString_Ptr_table(&file_track_dir_table, (char*)node->dir_name.str, (i32)node->dir_name.size); file_track_free_string(node->dir_name); memset(&node->dir_name, 0, sizeof(node->dir_name)); zdll_push_back(file_track_dir_free_first, file_track_dir_free_last, node); } internal File_Track_Node* -file_track_store_new_file_node(String file_name_string, Directory_Track_Node *existing_dir_node){ +file_track_store_new_file_node(String_Const_u8 file_name_string, Directory_Track_Node *existing_dir_node){ if (file_track_free_first == 0){ u32 size = KB(16); void *new_block = system_memory_allocate(size); @@ -739,7 +685,7 @@ file_track_store_new_file_node(String file_name_string, Directory_Track_Node *ex } File_Track_Node *new_node = file_track_free_first; zdll_remove(file_track_free_first, file_track_free_last, new_node); - alloc_insert_CString_Ptr_table(&file_track_table, file_name_string.str, file_name_string.size, new_node); + alloc_insert_CString_Ptr_table(&file_track_table, (char*)file_name_string.str, (i32)file_name_string.size, new_node); new_node->file_name = file_track_store_string_copy(file_name_string); new_node->ref_count = 1; new_node->parent_dir = existing_dir_node; @@ -749,14 +695,14 @@ file_track_store_new_file_node(String file_name_string, Directory_Track_Node *ex internal void file_track_free_file_node(File_Track_Node *node){ - erase_CString_Ptr_table(&file_track_table, node->file_name.str, node->file_name.size); + erase_CString_Ptr_table(&file_track_table, (char*)node->file_name.str, (i32)node->file_name.size); file_track_free_string(node->file_name); memset(&node->file_name, 0, sizeof(node->file_name)); zdll_push_back(file_track_free_first, file_track_free_last, node); } internal File_Track_Note_Node* -file_track_store_new_note_node(String file_name){ +file_track_store_new_note_node(String_Const_u8 file_name){ if (file_track_note_free_first == 0){ u32 size = KB(16); void *new_block = system_memory_allocate(size); @@ -821,16 +767,16 @@ file_track_free_instruction_node(File_Track_Instruction_Node *node){ } internal Directory_Track_Node* -file_track_dir_lookup(String dir_name_string){ +file_track_dir_lookup(String_Const_u8 dir_name_string){ void *ptr = 0; - lookup_CString_Ptr_table(&file_track_dir_table, dir_name_string.str, dir_name_string.size, &ptr); + lookup_CString_Ptr_table(&file_track_dir_table, (char*)dir_name_string.str, (i32)dir_name_string.size, &ptr); return((Directory_Track_Node*)ptr); } internal File_Track_Node* -file_track_file_lookup(String file_name_string){ +file_track_file_lookup(String_Const_u8 file_name_string){ void *ptr = 0; - lookup_CString_Ptr_table(&file_track_table, file_name_string.str, file_name_string.size, &ptr); + lookup_CString_Ptr_table(&file_track_table, (char*)file_name_string.str, (i32)file_name_string.size, &ptr); return((File_Track_Node*)ptr); } @@ -899,7 +845,7 @@ file_track_worker(void*){ } pos -= 4; } - String file_name = make_string((char*)buffer, pos); + String_Const_u8 file_name = SCu8(buffer, pos); file_track_store_new_note_node(file_name); system_schedule_step(); @@ -928,7 +874,7 @@ Sys_Add_Listener_Sig(system_add_listener){ EnterCriticalSection(&file_track_critical_section); - String file_name_string = make_string_slowly(filename); + String_Const_u8 file_name_string = SCu8(filename); File_Track_Node *existing_file_node = file_track_file_lookup(file_name_string); if (existing_file_node != 0){ @@ -936,12 +882,12 @@ Sys_Add_Listener_Sig(system_add_listener){ added_new_listener = true; } else{ - String dir_name_string = path_of_directory(file_name_string); + String_Const_u8 dir_name_string = string_remove_last_folder(file_name_string); Directory_Track_Node *existing_dir_node = file_track_dir_lookup(dir_name_string); if (existing_dir_node == 0){ Temp_Memory temp = begin_temp(&file_track_scratch); - String dir_name_string_terminated = string_push_copy(&file_track_scratch, dir_name_string); + String_Const_u8 dir_name_string_terminated = push_string_copy(&file_track_scratch, dir_name_string); HANDLE dir_handle = CreateFile_utf8(&file_track_scratch, (u8*)dir_name_string_terminated.str, FILE_LIST_DIRECTORY, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, 0, @@ -977,7 +923,7 @@ Sys_Remove_Listener_Sig(system_remove_listener){ EnterCriticalSection(&file_track_critical_section); - String file_name_string = make_string_slowly(filename); + String_Const_u8 file_name_string = SCu8(filename); File_Track_Node *existing_file_node = file_track_file_lookup(file_name_string); if (existing_file_node != 0){ @@ -1010,7 +956,7 @@ Sys_Get_File_Change_Sig(system_get_file_change){ if (file_track_note_first != 0){ has_or_got_a_change = true; File_Track_Note_Node *node = file_track_note_first; - *required_size = node->file_name.size + 1; + *required_size = (i32)node->file_name.size + 1; if (node->file_name.size < max){ memcpy(buffer, node->file_name.str, node->file_name.size); buffer[node->file_name.size] = 0; @@ -1065,7 +1011,7 @@ Sys_Post_Clipboard_Sig(system_post_clipboard){ win32vars.clip_post.size = str.size; } else{ - LOGF("Failed to allocate buffer for clipboard post (%d)\n", (i32)str.size + 1); + //LOGF("Failed to allocate buffer for clipboard post (%d)\n", (i32)str.size + 1); } } @@ -1133,7 +1079,7 @@ win32_read_clipboard_contents(void){ } if (contents_length > 0){ - win32vars.clipboard_contents = make_string_cap(win32vars.clip_buffer, contents_length - 1, win32vars.clip_max); + win32vars.clipboard_contents = SCu8(win32vars.clip_buffer, contents_length - 1); } GlobalUnlock(clip_data); @@ -1160,67 +1106,67 @@ Sys_CLI_Call_Sig(system_cli_call, path, script_name, cli_out){ char *env_variables = 0; char command_line[2048]; - String s = make_fixed_width_string(command_line); - copy_ss(&s, make_lit_string("/C ")); - append_partial_sc(&s, script_name); - b32 success = terminate_with_null(&s); + Arena *scratch = &shared_vars.scratch; - if (success){ - success = false; - - *(HANDLE*)&cli_out->proc = INVALID_HANDLE_VALUE; - *(HANDLE*)&cli_out->out_read = INVALID_HANDLE_VALUE; - *(HANDLE*)&cli_out->out_write = INVALID_HANDLE_VALUE; - *(HANDLE*)&cli_out->in_read = INVALID_HANDLE_VALUE; - *(HANDLE*)&cli_out->in_write = INVALID_HANDLE_VALUE; - - SECURITY_ATTRIBUTES security_atrb = {}; - security_atrb.nLength = sizeof(SECURITY_ATTRIBUTES); - security_atrb.bInheritHandle = TRUE; - - HANDLE out_read = INVALID_HANDLE_VALUE; - HANDLE out_write = INVALID_HANDLE_VALUE; - if (CreatePipe(&out_read, &out_write, &security_atrb, 0)){ - if (SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)){ - STARTUPINFO startup = {}; - startup.cb = sizeof(STARTUPINFO); - startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES; + Temp_Memory temp = begin_temp(scratch); + String_Const_u8 s = push_u8_stringf(scratch, "/C %s", script_name); + + b32 success = false; + + *(HANDLE*)&cli_out->proc = INVALID_HANDLE_VALUE; + *(HANDLE*)&cli_out->out_read = INVALID_HANDLE_VALUE; + *(HANDLE*)&cli_out->out_write = INVALID_HANDLE_VALUE; + *(HANDLE*)&cli_out->in_read = INVALID_HANDLE_VALUE; + *(HANDLE*)&cli_out->in_write = INVALID_HANDLE_VALUE; + + SECURITY_ATTRIBUTES security_atrb = {}; + security_atrb.nLength = sizeof(SECURITY_ATTRIBUTES); + security_atrb.bInheritHandle = TRUE; + + HANDLE out_read = INVALID_HANDLE_VALUE; + HANDLE out_write = INVALID_HANDLE_VALUE; + if (CreatePipe(&out_read, &out_write, &security_atrb, 0)){ + if (SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)){ + STARTUPINFO startup = {}; + startup.cb = sizeof(STARTUPINFO); + startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES; + + HANDLE in_read = CreateFileA("nul", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, &security_atrb, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); + + startup.hStdInput = in_read; + startup.hStdOutput = out_write; + startup.hStdError = out_write; + startup.wShowWindow = SW_HIDE; + + PROCESS_INFORMATION info = {}; + if (CreateProcess_utf8(&shared_vars.scratch, (u8*)cmd, (u8*)command_line, 0, 0, TRUE, 0, env_variables, (u8*)path, &startup, &info)){ + success = true; + CloseHandle(info.hThread); + *(HANDLE*)&cli_out->proc = info.hProcess; + *(HANDLE*)&cli_out->out_read = out_read; + *(HANDLE*)&cli_out->out_write = out_write; - HANDLE in_read = CreateFileA("nul", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, &security_atrb, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); - - startup.hStdInput = in_read; - startup.hStdOutput = out_write; - startup.hStdError = out_write; - startup.wShowWindow = SW_HIDE; - - PROCESS_INFORMATION info = {}; - if (CreateProcess_utf8(&shared_vars.scratch, (u8*)cmd, (u8*)command_line, 0, 0, TRUE, 0, env_variables, (u8*)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); - CloseHandle(in_read); - } + ++win32vars.running_cli; } else{ - // TODO(allen): failed SetHandleInformation CloseHandle(out_read); CloseHandle(out_write); + CloseHandle(in_read); } } else{ - // TODO(allen): failed CreatePipe + // TODO(allen): failed SetHandleInformation + CloseHandle(out_read); + CloseHandle(out_write); } } + else{ + // TODO(allen): failed CreatePipe + } - return success; + end_temp(temp); + + return(success); } struct CLI_Loop_Control{ @@ -1302,122 +1248,8 @@ Sys_CLI_End_Update_Sig(system_cli_end_update){ } #include "4ed_font_provider_freetype.h" -global u32 system_font_method = SystemFontMethod_RawData; #include "4ed_font_provider_freetype.cpp" -Sys_Font_Path_Not_Used; - -internal -Sys_Font_Data(name, parameters){ - Font_Raw_Data data = {}; - - int weight = FW_REGULAR; - if (parameters->bold){ - weight = FW_BOLD; - } - - HFONT hfont = CreateFontA( - 0, - 0, - 0, - 0, - weight, // Weight - parameters->italics, // Italic - FALSE, // Underline - FALSE, // Strikeout - ANSI_CHARSET, - OUT_DEVICE_PRECIS, - CLIP_DEFAULT_PRECIS, - DEFAULT_QUALITY, - DEFAULT_PITCH | FF_DONTCARE, - name - ); - - if (hfont != 0){ - HDC hdc = CreateCompatibleDC(NULL); - if (hdc != 0){ - SelectObject(hdc, hfont); - DWORD size = GetFontData(hdc, 0, 0, NULL, 0); - if (size > 0){ - Arena *arena = &shared_vars.font_scratch; - u8 *buffer = push_array(arena, u8, size); - if (GetFontData(hdc, 0, 0, buffer, size) == size){ - data.data = buffer; - data.size = size; - } - } - DeleteDC(hdc); - } - } - - return(data); -} - -struct Win32_Font_Enum{ - Arena *arena; - Font_Setup_List *list; -}; - -int CALL_CONVENTION -win32_font_enum_callback( -const LOGFONT *lpelfe, -const TEXTMETRIC *lpntme, -DWORD FontType, -LPARAM lParam -){ - - if ((FontType & TRUETYPE_FONTTYPE) != 0){ - ENUMLOGFONTEXDV *log_font = (ENUMLOGFONTEXDV*)lpelfe; - TCHAR *name = ((log_font)->elfEnumLogfontEx).elfLogFont.lfFaceName; - - if ((char)name[0] != '@'){ - i32 len = 0; - for (;name[len]!=0;++len); - - if (len < sizeof(Member(Font_Loadable_Stub, name))){ - Win32_Font_Enum p = *(Win32_Font_Enum*)lParam; - Temp_Memory reset = begin_temp(p.arena); - Font_Setup *setup = push_array_zero(p.arena, Font_Setup, 1); - b32 good = true; - for (i32 i = 0; i < len; ++i){ - if (name[i] >= 128){ - good = false; - break; - } - setup->stub.name[i] = (char)name[i]; - } - if (good){ - setup->stub.load_from_path = false; - setup->stub.len = len; - sll_queue_push(p.list->first, p.list->last, setup); - } - else{ - end_temp(reset); - } - } - } - } - - return(1); -} - -internal void -win32_get_loadable_fonts(Arena *arena, Font_Setup_List *list){ - HDC hdc= GetDC(0); - - LOGFONT log_font = {}; - log_font.lfCharSet = ANSI_CHARSET; - log_font.lfFaceName[0] = 0; - - Win32_Font_Enum p = {}; - p.arena = arena; - p.list = list; - - EnumFontFamiliesEx(hdc, &log_font, win32_font_enum_callback, (LPARAM)&p,0); - - ReleaseDC(0, hdc); -} - #include #include "opengl/4ed_opengl_render.cpp" @@ -1428,7 +1260,7 @@ win32_get_loadable_fonts(Arena *arena, Font_Setup_List *list){ global Key_Code keycode_lookup_table[255]; internal void -Win32KeycodeInit(void){ +win32_keycode_init(void){ keycode_lookup_table[VK_BACK] = key_back; keycode_lookup_table[VK_DELETE] = key_del; keycode_lookup_table[VK_UP] = key_up; @@ -1480,28 +1312,17 @@ Win32KeycodeInit(void){ } internal void -Win32Resize(i32 width, i32 height){ +win32_resize(i32 width, i32 height){ if (width > 0 && height > 0){ target.width = width; target.height = height; } } -#define GLFuncGood(f) (((f)!=0)&&((f)!=(void*)1)&&((f)!=(void*)2)&&((f)!=(void*)3)&&((f)!=(void*)-11)) - -typedef HGLRC (CALL_CONVENTION wglCreateContextAttribsARB_Function)(HDC,HGLRC,i32*); -typedef BOOL (CALL_CONVENTION wglChoosePixelFormatARB_Function)(HDC,i32*,f32*,u32,i32*,u32*); -typedef char* (CALL_CONVENTION wglGetExtensionsStringEXT_Function)(); -typedef VOID (CALL_CONVENTION wglSwapIntervalEXT_Function)(i32); - -global wglCreateContextAttribsARB_Function *wglCreateContextAttribsARB = 0; -global wglChoosePixelFormatARB_Function *wglChoosePixelFormatARB = 0; -global wglGetExtensionsStringEXT_Function *wglGetExtensionsStringEXT = 0; -global wglSwapIntervalEXT_Function *wglSwapIntervalEXT = 0; - +#if 0 internal void win32_init_gl(HDC hdc){ - LOG("trying to load wgl extensions...\n"); + //LOG("trying to load wgl extensions...\n"); #define GLInitFail(s) system_error_box(FNLN "\nOpenGL init fail - " s ) @@ -1561,14 +1382,14 @@ win32_init_gl(HDC hdc){ LoadWGL(wglChoosePixelFormatARB, true); LoadWGL(wglGetExtensionsStringEXT, true); - LOG("got wgl functions\n"); + //LOG("got wgl functions\n"); char *extensions_c = wglGetExtensionsStringEXT(); String extensions = make_string_slowly(extensions_c); if (has_substr(extensions, make_lit_string("WGL_EXT_swap_interval"))){ LoadWGL(wglSwapIntervalEXT, false); if (wglSwapIntervalEXT != 0){ - LOG("got wglSwapIntervalEXT\n"); + //LOG("got wglSwapIntervalEXT\n"); } } @@ -1609,7 +1430,7 @@ win32_init_gl(HDC hdc){ wglMakeCurrent(hdc, context); if (wglSwapIntervalEXT != 0){ - LOGF("setting swap interval %d\n", 1); + //LOGF("setting swap interval %d\n", 1); wglSwapIntervalEXT(1); } @@ -1617,8 +1438,9 @@ win32_init_gl(HDC hdc){ DestroyWindow(hwglwnd); wglDeleteContext(wglcontext); - LOG("successfully enabled opengl\n"); + //LOG("successfully enabled opengl\n"); } +#endif internal void Win32SetCursorFromUpdate(Application_Mouse_Cursor cursor){ @@ -1907,7 +1729,7 @@ win32_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){ i32 new_width = LOWORD(lParam); i32 new_height = HIWORD(lParam); - Win32Resize(new_width, new_height); + win32_resize(new_width, new_height); }break; case WM_DISPLAYCHANGE: @@ -1970,6 +1792,241 @@ win32_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){ return(result); } +//////////////////////////////// + +internal b32 +win32_wgl_good(Void_Func *f){ + return(f != 0 && + f != (Void_Func*)1 && + f != (Void_Func*)2 && + f != (Void_Func*)3 && + f != (Void_Func*)-1); +} + +typedef HGLRC (wglCreateContextAttribsARB_Function)(HDC,HGLRC,i32*); +typedef BOOL (wglChoosePixelFormatARB_Function)(HDC,i32*,f32*,u32,i32*,u32*); +typedef char* (wglGetExtensionsStringEXT_Function)(); +typedef VOID (wglSwapIntervalEXT_Function)(i32); + +global wglCreateContextAttribsARB_Function *wglCreateContextAttribsARB = 0; +global wglChoosePixelFormatARB_Function *wglChoosePixelFormatARB = 0; +global wglGetExtensionsStringEXT_Function *wglGetExtensionsStringEXT = 0; +global wglSwapIntervalEXT_Function *wglSwapIntervalEXT = 0; + +// TODO(allen): This requires all windows to be handled on a single thread. +// We would need a platform side thread context to get around this which would +// probably mean thread local storage would have to get involved. +global HWND win32_current_gl_window = 0; + +internal b32 +win32_gl_create_window(HWND *wnd_out, HGLRC *context_out, DWORD style, RECT rect){ + HINSTANCE this_instance = GetModuleHandle(0); + + local_persist b32 srgb_support = false; + local_persist b32 register_success = true; + local_persist b32 first_call = true; + if (first_call){ + first_call = false; + + // NOTE(allen): Create the GL bootstrap window + WNDCLASSW wglclass = {}; + wglclass.lpfnWndProc = DefWindowProcW; + wglclass.hInstance = this_instance; + wglclass.lpszClassName = L"wgl-loader"; + if (RegisterClassW(&wglclass) == 0){ + register_success = false; + goto fail_register; + } + + HWND wglwindow = CreateWindowW(wglclass.lpszClassName, L"", 0, 0, 0, 0, 0, + 0, 0, this_instance, 0); + if (wglwindow == 0){ + register_success = false; + goto fail_register; + } + + // NOTE(allen): Create the GL bootstrap context + HDC wgldc = GetDC(wglwindow); + + PIXELFORMATDESCRIPTOR format = {}; + format.nSize = sizeof(format); + format.nVersion = 1; + format.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER; + format.iPixelType = PFD_TYPE_RGBA; + format.cColorBits = 32; + format.cAlphaBits = 8; + format.cDepthBits = 24; + format.iLayerType = PFD_MAIN_PLANE; + i32 suggested_format_index = ChoosePixelFormat(wgldc, &format); + if (!SetPixelFormat(wgldc, suggested_format_index, &format)){ + register_success = false; + goto fail_register; + } + + HGLRC wglcontext = wglCreateContext(wgldc); + if (wglcontext == 0){ + register_success = false; + goto fail_register; + } + + if (!wglMakeCurrent(wgldc, wglcontext)){ + register_success = false; + goto fail_register; + } + + // NOTE(allen): Load wgl extensions +#define LoadWGL(f,l) Stmnt((f) = (f##_Function*)wglGetProcAddress(#f); \ + (l) = (l) && win32_wgl_good((Void_Func*)(f));) + + b32 load_success = true; + LoadWGL(wglCreateContextAttribsARB, load_success); + LoadWGL(wglChoosePixelFormatARB, load_success); + LoadWGL(wglGetExtensionsStringEXT, load_success); + + if (!load_success){ + register_success = false; + goto fail_register; + } + + char *extensions_c = wglGetExtensionsStringEXT(); + String_Const_u8 extensions = SCu8((u8*)extensions_c); + + { + String_Const_u8 s = string_skip_whitespace(extensions); + for (;s.size > 0;){ + umem end = string_find_first_whitespace(s); + String_Const_u8 m = string_prefix(s, end); + if (string_match(m, string_u8_litexpr("WGL_EXT_framebuffer_sRGB")) || + string_match(m, string_u8_litexpr("WGL_ARB_framebuffer_sRGB"))){ + srgb_support = true; + } + else if (string_match(m, string_u8_litexpr("WGL_EXT_swap_interval"))){ + b32 wgl_swap_interval_ext = true; + LoadWGL(wglSwapIntervalEXT, wgl_swap_interval_ext); + if (!wgl_swap_interval_ext){ + wglSwapIntervalEXT = 0; + } + } + s = string_skip_whitespace(string_skip(s, end)); + } + } + + // NOTE(allen): Load gl functions +#define GL_FUNC(f,R,P) LoadWGL(f,load_success); +#include "opengl/4ed_opengl_funcs.h" + + if (!load_success){ + register_success = false; + goto fail_register; + } + + // NOTE(allen): Cleanup the GL bootstrap resources + ReleaseDC(wglwindow, wgldc); + DestroyWindow(wglwindow); + wglDeleteContext(wglcontext); + + // NOTE(allen): Register the graphics window class + WNDCLASSW wndclass = {}; + wndclass.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS; + wndclass.lpfnWndProc = win32_proc; + wndclass.hInstance = this_instance; + wndclass.lpszClassName = L"GRAPHICS-WINDOW-NAME"; + if (RegisterClassW(&wndclass) == 0){ + register_success = false; + goto fail_register; + } + } + fail_register:; + + b32 result = false; + if (register_success){ + // NOTE(allen): Create the graphics window + HWND wnd = CreateWindowExW(0, L"GRAPHICS-WINDOW-NAME", L"GRAPHICS", style, + CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, + 0, 0, this_instance, 0); + + *wnd_out = 0; + *context_out = 0; + if (wnd != 0){ + HDC dc = GetDC(wnd); + + PIXELFORMATDESCRIPTOR format = {}; + + i32 pixel_attrib_list[] = { + /* 0*/WGL_DRAW_TO_WINDOW_ARB, TRUE, + /* 2*/WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, + /* 4*/WGL_SUPPORT_OPENGL_ARB, TRUE, + /* 6*/WGL_DOUBLE_BUFFER_ARB, false, + /* 8*/WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, + /*10*/WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, GL_TRUE, + /*12*/0, + }; + if (!srgb_support){ + pixel_attrib_list[10] = 0; + } + + i32 suggested_format_index = 0; + u32 ignore = 0; + if (!wglChoosePixelFormatARB(dc, pixel_attrib_list, 0, 1, &suggested_format_index, &ignore)){ + goto fail_window_init; + } + + DescribePixelFormat(dc, suggested_format_index, sizeof(format), &format); + if (!SetPixelFormat(dc, suggested_format_index, &format)){ + goto fail_window_init; + } + +#if 1 + i32 context_attrib_list[] = { + /*0*/WGL_CONTEXT_MAJOR_VERSION_ARB, 3, + /*2*/WGL_CONTEXT_MINOR_VERSION_ARB, 2, + /*4*/WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB +#if GL_DEBUG_MODE + |WGL_CONTEXT_DEBUG_BIT_ARB +#endif + , + /*6*/WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, + /*8*/0 + }; +#else + i32 context_attrib_list[] = { + WGL_CONTEXT_MAJOR_VERSION_ARB, 2, + WGL_CONTEXT_MINOR_VERSION_ARB, 1, + WGL_CONTEXT_FLAGS_ARB, 0, + WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, + 0 + }; +#endif + + HGLRC context = wglCreateContextAttribsARB(dc, 0, context_attrib_list); + if (context == 0){ + goto fail_window_init; + } + + wglMakeCurrent(dc, context); + win32_current_gl_window = wnd; + if (wglSwapIntervalEXT != 0){ + wglSwapIntervalEXT(1); + } + *wnd_out = wnd; + *context_out = context; + result = true; + + if (false){ + fail_window_init:; + DWORD error = GetLastError(); + ReleaseDC(wnd, dc); + DestroyWindow(wnd); + SetLastError(error); + } + } + } + + return(result); +} + +//////////////////////////////// + #include "4ed_link_system_functions.cpp" #include "4ed_shared_init_logic.cpp" @@ -2053,17 +2110,6 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS // Window and GL Initialization // - WNDCLASS window_class = {}; - window_class.style = CS_HREDRAW|CS_VREDRAW; - window_class.lpfnWndProc = (WNDPROC)(win32_proc); - window_class.hInstance = hInstance; - window_class.lpszClassName = L"4coder-win32-wndclass"; - window_class.hIcon = LoadIcon(hInstance, L"main"); - - if (!RegisterClass(&window_class)){ - exit(1); - } - RECT window_rect = {}; if (plat_settings.set_window_size){ window_rect.right = plat_settings.window_w; @@ -2075,7 +2121,24 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS } if (!AdjustWindowRect(&window_rect, WS_OVERLAPPEDWINDOW, false)){ - LOG("Could not get adjusted window.\n"); + //LOG("Could not get adjusted window.\n"); + } + + i32 window_style = WS_OVERLAPPEDWINDOW; + if (!plat_settings.fullscreen_window && plat_settings.maximize_window){ + window_style |= WS_MAXIMIZE; + } + +#if 0 + WNDCLASS window_class = {}; + window_class.style = CS_HREDRAW|CS_VREDRAW; + window_class.lpfnWndProc = (WNDPROC)(win32_proc); + window_class.hInstance = hInstance; + window_class.lpszClassName = L"4coder-win32-wndclass"; + window_class.hIcon = LoadIcon(hInstance, L"main"); + + if (!RegisterClass(&window_class)){ + exit(1); } i32 window_x = CW_USEDEFAULT; @@ -2084,22 +2147,18 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS if (plat_settings.set_window_pos){ window_x = plat_settings.window_x; window_y = plat_settings.window_y; - LOGF("Setting window position (%d, %d)\n", window_x, window_y); + //LOGF("Setting window position (%d, %d)\n", window_x, window_y); } - LOG("Creating window... "); - i32 window_style = WS_OVERLAPPEDWINDOW; - if (!plat_settings.fullscreen_window && plat_settings.maximize_window){ - window_style |= WS_MAXIMIZE; - } + //LOG("Creating window... "); win32vars.window_handle = CreateWindowEx(0, window_class.lpszClassName, L_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){ - LOG("Failed\n"); + //LOG("Failed\n"); exit(1); } else{ - LOG("Success\n"); + //LOG("Success\n"); } { @@ -2116,26 +2175,22 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS ReleaseDC(win32vars.window_handle, hdc); } +#endif - Win32Resize(window_rect.right - window_rect.left, window_rect.bottom - window_rect.top); + HGLRC window_opengl_context = 0; + if (!win32_gl_create_window(&win32vars.window_handle, &window_opengl_context, window_style, window_rect)){ + //LOG("Window creation failed\n"); + exit(1); + } - // - // Font System Init - // - - LOG("Initializing fonts\n"); - Arena *scratch = &shared_vars.scratch; - Temp_Memory temp = begin_temp(scratch); - Font_Setup_List font_setup = system_font_get_local_stubs(scratch); - win32_get_loadable_fonts(scratch, &font_setup); - system_font_init(&sysfunc.font, plat_settings.font_size, plat_settings.use_hinting, font_setup); - end_temp(temp); + GetClientRect(win32vars.window_handle, &window_rect); + win32_resize(window_rect.right - window_rect.left, window_rect.bottom - window_rect.top); // // Misc System Initializations // - LOG("Initializing clipboard\n"); + //LOG("Initializing clipboard\n"); if (!AddClipboardFormatListener(win32vars.window_handle)){ win32_output_error_string(ErrorString_UseLog); } @@ -2158,7 +2213,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS win32_read_clipboard_contents(); } - Win32KeycodeInit(); + win32_keycode_init(); win32vars.cursor_ibeam = LoadCursor(NULL, IDC_IBEAM); win32vars.cursor_arrow = LoadCursor(NULL, IDC_ARROW); @@ -2168,12 +2223,12 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS LARGE_INTEGER f; if (QueryPerformanceFrequency(&f)){ win32vars.count_per_usecond = (f32)f.QuadPart / 1000000.f; - LOGF("Got performance frequency %f\n", win32vars.count_per_usecond); + //LOGF("Got performance frequency %f\n", win32vars.count_per_usecond); } else{ // NOTE(allen): Just guess. win32vars.count_per_usecond = 1.f; - LOG("Did not get performance frequency, just guessing with 1.\n"); + //LOG("Did not get performance frequency, just guessing with 1.\n"); } Assert(win32vars.count_per_usecond > 0.f); @@ -2189,8 +2244,8 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS String_Const_u8 curdir = SCu8(cwd, size); curdir = string_mod_replace_character(curdir, '\\', '/'); - LOG("Initializing application variables\n"); - app.init(&sysfunc, &target, &memory_vars, string_new_u8_from_old(win32vars.clipboard_contents), curdir, custom_api); + //LOG("Initializing application variables\n"); + app.init(&sysfunc, &target, &memory_vars, win32vars.clipboard_contents, curdir, custom_api); // // Main loop @@ -2208,7 +2263,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS SetActiveWindow(win32vars.window_handle); ShowWindow(win32vars.window_handle, SW_SHOW); - LOG("Beginning main loop\n"); + //LOG("Beginning main loop\n"); u64 timer_start = system_now_time(); system_acquire_lock(FRAME_LOCK); MSG msg; @@ -2389,7 +2444,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS win32vars.clipboard_sequence = new_number; } } - input.clipboard = string_new_u8_from_old(win32vars.clipboard_contents); + input.clipboard = win32vars.clipboard_contents; win32vars.clip_post.size = 0; @@ -2400,7 +2455,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS result = app.step(&sysfunc, &target, &memory_vars, &input); } else{ - LOG("app.step == 0 -- skipping\n"); + //LOG("app.step == 0 -- skipping\n"); } // NOTE(allen): Finish the Loop @@ -2448,7 +2503,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdS // NOTE(allen): render HDC hdc = GetDC(win32vars.window_handle); - interpret_render_buffer(&target, &shared_vars.pixel_scratch); + gl_render(&target, &shared_vars.pixel_scratch); SwapBuffers(hdc); ReleaseDC(win32vars.window_handle, hdc); diff --git a/platform_win32/win32_4ed_functions.cpp b/platform_win32/win32_4ed_functions.cpp index c201f8e4..0aea4f5a 100644 --- a/platform_win32/win32_4ed_functions.cpp +++ b/platform_win32/win32_4ed_functions.cpp @@ -84,54 +84,34 @@ Sys_Get_4ed_Path_Sig(system_get_4ed_path){ u8 *memory = (u8*)system_memory_allocate(binary_path_capacity); i32 size = GetModuleFileName_utf8(&shared_vars.scratch, 0, memory, binary_path_capacity); Assert(size <= binary_path_capacity - 1); - win32vars.binary_path = make_string(memory, size); - remove_last_folder(&win32vars.binary_path); - terminate_with_null(&win32vars.binary_path); + win32vars.binary_path = SCu8(memory, size); + win32vars.binary_path = string_remove_last_folder(win32vars.binary_path); + win32vars.binary_path.str[win32vars.binary_path.size] = 0; } - i32 copy_size = Min(win32vars.binary_path.size, capacity); + i32 copy_size = Min((i32)(win32vars.binary_path.size), capacity); block_copy(out, win32vars.binary_path.str, copy_size); - return(win32vars.binary_path.size); -} - -// -// Logging -// - -internal -Sys_Log_Sig(system_log){ - if (plat_settings.use_log){ - u8 space[4096]; - String str = make_fixed_width_string(space); - str.size = system_get_4ed_path(str.str, str.memory_size); - append_sc(&str, "4coder_log.txt"); - terminate_with_null(&str); - HANDLE file = CreateFile_utf8(&shared_vars.scratch, space, GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); - if (file != INVALID_HANDLE_VALUE){ - SetFilePointer(file, win32vars.log_position, 0, FILE_BEGIN); - win32vars.log_position += length; - DWORD written = 0; - DWORD total_written = 0; - do{ - WriteFile(file, message + total_written, length - total_written, &written, 0); - total_written += written; - }while (total_written < length); - CloseHandle(file); - } - } + return((i32)(win32vars.binary_path.size)); } // // Files // -internal String -win32_remove_unc_prefix_characters(String path){ - if (match_part(path, make_lit_string("\\\\?\\UNC"))){ +internal String_Const_u8 +win32_remove_unc_prefix_characters(String_Const_u8 path){ + if (string_match(string_prefix(path, 7), string_u8_litexpr("\\\\?\\UNC"))){ +#if 0 + // TODO(allen): Why no just do + path = string_skip(path, 7); + path.str[0] = '\\'; + // ? +#endif path.size -= 7; memmove(path.str, path.str + 7, path.size); path.str[0] = '\\'; } - else if (match_part(path, make_lit_string("\\\\?\\"))){ + else if (string_match(string_prefix(path, 4), string_u8_litexpr("\\\\?\\"))){ + // TODO(allen): Same questions essentially. path.size -= 4; memmove(path.str, path.str + 4, path.size); } @@ -142,27 +122,27 @@ internal Sys_Set_File_List_Sig(system_set_file_list){ b32 clear_list = true; if (directory != 0){ - char dir_space[MAX_PATH + 32]; - String dir = make_string_cap(dir_space, 0, MAX_PATH + 32); - append_sc(&dir, directory); - terminate_with_null(&dir); + u8 dir_space[MAX_PATH + 32]; + umem directory_original_length = cstring_length(directory); + block_copy(dir_space, directory, directory_original_length); + String_Const_u8 dir = SCu8(dir_space, directory_original_length); - HANDLE dir_handle = CreateFile_utf8(&shared_vars.scratch, (u8*)dir.str, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, 0); + HANDLE dir_handle = CreateFile_utf8(&shared_vars.scratch, dir.str, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, 0); if (dir_handle != INVALID_HANDLE_VALUE){ - DWORD final_length = GetFinalPathNameByHandle_utf8(&shared_vars.scratch, dir_handle, (u8*)dir_space, sizeof(dir_space), 0); + DWORD final_length = GetFinalPathNameByHandle_utf8(&shared_vars.scratch, dir_handle, dir_space, sizeof(dir_space), 0); CloseHandle(dir_handle); if (final_length + 3 < sizeof(dir_space)){ - u8 *c_str_dir = (u8*)dir_space; + u8 *c_str_dir = dir_space; if (c_str_dir[final_length - 1] == 0){ --final_length; } - String str_dir = make_string(c_str_dir, final_length); - String adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); + String_Const_u8 str_dir = SCu8(c_str_dir, final_length); + String_Const_u8 adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); - c_str_dir = (u8*)adjusted_str_dir.str; - final_length = adjusted_str_dir.size; + c_str_dir = adjusted_str_dir.str; + final_length = (DWORD)(adjusted_str_dir.size); c_str_dir[final_length] = '\\'; c_str_dir[final_length + 1] = '*'; c_str_dir[final_length + 2] = 0; @@ -177,9 +157,9 @@ Sys_Set_File_List_Sig(system_set_file_list){ *canon_directory_size_out = final_length; } else{ - u32 length = copy_fast_unsafe_cc(canon_directory_out, directory); - canon_directory_out[length] = 0; - *canon_directory_size_out = length; + block_copy(canon_directory_out, directory, directory_original_length); + canon_directory_out[directory_original_length] = 0; + *canon_directory_size_out = (i32)directory_original_length; } } @@ -244,8 +224,8 @@ Sys_Set_File_List_Sig(system_set_file_list){ info->filename_len = length; *name++ = 0; - String fname = make_string_cap(info->filename, length, length+1); - replace_char(&fname, '\\', '/'); + String_Const_u8 fname = SCu8(info->filename, length); + fname = string_mod_replace_character(fname, '\\', '/'); ++info; ++corrected_file_count; } @@ -293,10 +273,10 @@ Sys_Get_Canonical_Sig(system_get_canonical){ if (buffer[final_length - 1] == 0){ --final_length; } - String str_dir = make_string(buffer, final_length); - String adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); - buffer = adjusted_str_dir.str; - final_length = adjusted_str_dir.size; + String_Const_u8 str_dir = SCu8(buffer, final_length); + String_Const_u8 adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); + buffer = (char*)adjusted_str_dir.str; + final_length = (i32)adjusted_str_dir.size; buffer[final_length] = 0; result = final_length; } @@ -304,9 +284,9 @@ Sys_Get_Canonical_Sig(system_get_canonical){ CloseHandle(file); } else{ - String src_str = make_string(filename, len); - String path_str = path_of_directory(src_str); - String front_str = front_of_directory(src_str); + String_Const_u8 src_str = SCu8(filename, len); + String_Const_u8 path_str = string_remove_last_folder(src_str); + String_Const_u8 front_str = string_front_of_path(src_str); memcpy(src_space, path_str.str, path_str.size); src_space[path_str.size] = 0; @@ -320,13 +300,13 @@ Sys_Get_Canonical_Sig(system_get_canonical){ if (buffer[final_length-1] == 0){ --final_length; } - String str_dir = make_string(buffer, final_length); - String adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); - buffer = adjusted_str_dir.str; - final_length = adjusted_str_dir.size; + String_Const_u8 str_dir = SCu8(buffer, final_length); + String_Const_u8 adjusted_str_dir = win32_remove_unc_prefix_characters(str_dir); + buffer = (char*)adjusted_str_dir.str; + final_length = (i32)adjusted_str_dir.size; buffer[final_length++] = '\\'; memcpy(buffer + final_length, front_str.str, front_str.size); - final_length += front_str.size; + final_length += (i32)(front_str.size); buffer[final_length] = 0; result = final_length; } diff --git a/platform_win32/win32_error_box.cpp b/platform_win32/win32_error_box.cpp index 20ceb116..ad6771ec 100644 --- a/platform_win32/win32_error_box.cpp +++ b/platform_win32/win32_error_box.cpp @@ -11,7 +11,7 @@ internal void system_error_box(char *msg, b32 shutdown = true){ - LOGF("error box: %s\n", msg); + //LOGF("error box: %s\n", msg); MessageBox_utf8(&shared_vars.scratch, 0, (u8*)msg, (u8*)"Error", 0); if (shutdown){ exit(1); diff --git a/platform_win32/win32_gl.h b/platform_win32/win32_gl.h index 040a1832..636743b9 100644 --- a/platform_win32/win32_gl.h +++ b/platform_win32/win32_gl.h @@ -59,16 +59,18 @@ #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C -#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001 -#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002 -#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 -#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 -#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 -#define WGL_CONTEXT_FLAGS_ARB 0x2094 -#define ERROR_INVALID_VERSION_ARB 0x2095 -#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 -#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 +#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 +#define ERROR_INVALID_VERSION_ARB 0x2095 +#define ERROR_INVALID_PROFILE_ARB 0x2096 // BOTTOM diff --git a/platform_win32/win32_utf8.cpp b/platform_win32/win32_utf8.cpp index 97a58e96..e0cc6841 100644 --- a/platform_win32/win32_utf8.cpp +++ b/platform_win32/win32_utf8.cpp @@ -39,8 +39,8 @@ input_8_to_16(Arena *scratch, u8 *in){ } internal Win32_UTF16 -input_8_to_16(Arena *scratch, String in){ - return(input_8_to_16(scratch, (u8*)in.str, in.size)); +input_8_to_16(Arena *scratch, String_Const_u8 in){ + return(input_8_to_16(scratch, in.str, (u32)in.size)); } internal HANDLE @@ -217,7 +217,7 @@ internal BOOL GetFileAttributesEx_utf8String(Arena *scratch, String_Const_u8 file_name, GET_FILEEX_INFO_LEVELS info_level_id, LPVOID file_info){ BOOL result = FALSE; Temp_Memory temp = begin_temp(scratch); - Win32_UTF16 string_16 = input_8_to_16(scratch, string_old_from_new(file_name)); + Win32_UTF16 string_16 = input_8_to_16(scratch, file_name); if (string_16.success){ result = GetFileAttributesExW((LPWSTR)string_16.utf16, info_level_id, file_info); }