/* * Mr. 4th Dimention - Allen Webster * * 12.12.2014 * * Application layer for project codename "4ed" * */ // TOP internal void init_command_line_settings(App_Settings *settings, Plat_Settings *plat_settings, i32 argc, char **argv){ char *arg = 0; Command_Line_Mode mode = CLMode_App; Command_Line_Action action = CLAct_Nothing; b32 strict = false; settings->init_files_max = ArrayCount(settings->init_files); for (i32 i = 1; i <= argc; ++i){ if (i == argc){ arg = ""; } else{ arg = argv[i]; } if (arg[0] == '-' && arg[1] == '-'){ char *long_arg_name = arg+2; if (string_match(SCu8(long_arg_name), string_u8_litexpr("custom"))){ mode = CLMode_Custom; continue; } } switch (mode){ case CLMode_App: { switch (action){ case CLAct_Nothing: { if (arg[0] == '-'){ action = CLAct_Ignore; switch (arg[1]){ case 'd': action = CLAct_CustomDLL; strict = false; break; case 'D': action = CLAct_CustomDLL; strict = true; break; case 'w': action = CLAct_WindowSize; break; case 'W': action = CLAct_WindowMaximize; break; case 'p': action = CLAct_WindowPosition; break; case 'F': action = CLAct_WindowFullscreen; break; case 'f': action = CLAct_FontSize; break; case 'h': action = CLAct_FontUseHinting; --i; break; case 'U': action = CLAct_UserDirectory; break; //case 'L': enables log, parsed before this is called (because I'm a dumbass) } } else if (arg[0] != 0){ if (settings->init_files_count < settings->init_files_max){ i32 index = settings->init_files_count++; settings->init_files[index] = arg; } } }break; case CLAct_CustomDLL: { plat_settings->custom_dll_is_strict = (b8)strict; if (i < argc){ plat_settings->custom_dll = argv[i]; } action = CLAct_Nothing; }break; case CLAct_WindowSize: { if (i + 1 < argc){ plat_settings->set_window_size = true; i32 w = (i32)string_to_integer(SCu8(argv[i]), 10); i32 h = (i32)string_to_integer(SCu8(argv[i + 1]), 10); if (w > 0){ plat_settings->window_w = w; } if (h > 0){ plat_settings->window_h = h; } ++i; } action = CLAct_Nothing; }break; case CLAct_WindowMaximize: { --i; plat_settings->maximize_window = true; action = CLAct_Nothing; }break; case CLAct_WindowPosition: { if (i + 1 < argc){ plat_settings->set_window_pos = true; i32 x = (i32)string_to_integer(SCu8(argv[i]), 10); i32 y = (i32)string_to_integer(SCu8(argv[i + 1]), 10); if (x > 0){ plat_settings->window_x = x; } if (y > 0){ plat_settings->window_y = y; } ++i; } action = CLAct_Nothing; }break; case CLAct_WindowFullscreen: { --i; plat_settings->fullscreen_window = true; action = CLAct_Nothing; }break; case CLAct_FontSize: { if (i < argc){ settings->font_size = (i32)string_to_integer(SCu8(argv[i]), 10); } action = CLAct_Nothing; }break; case CLAct_FontUseHinting: { plat_settings->use_hinting = true; settings->use_hinting = plat_settings->use_hinting; action = CLAct_Nothing; }break; case CLAct_UserDirectory: { if (i < argc){ plat_settings->user_directory = argv[i]; } action = CLAct_Nothing; }break; } }break; case CLMode_Custom: { settings->custom_flags = argv + i; settings->custom_flags_count = argc - i; i = argc; mode = CLMode_App; }break; } } } //////////////////////////////// internal Models* models_init(void){ Arena arena = make_arena_system(); Models *models = push_array_zero(&arena, Models, 1); models->arena_ = arena; models->arena = &models->arena_; heap_init(&models->heap, get_base_allocator_system()); return(models); } internal void app_load_vtables(API_VTable_system *vtable_system, API_VTable_font *vtable_font, API_VTable_graphics *vtable_graphics){ system_api_read_vtable(vtable_system); font_api_read_vtable(vtable_font); graphics_api_read_vtable(vtable_graphics); } internal Log_Function* app_get_logger(void){ log_init(); return(log_string); } App_Read_Command_Line_Sig(app_read_command_line){ Models *models = models_init(); App_Settings *settings = &models->settings; block_zero_struct(settings); if (argc > 1){ init_command_line_settings(&models->settings, plat_settings, argc, argv); } *files = models->settings.init_files; *file_count = &models->settings.init_files_count; return(models); } App_Init_Sig(app_init){ Models *models = (Models*)base_ptr; models->keep_playing = true; models->hard_exit = false; models->config_api = api; models->virtual_event_arena = make_arena_system(); profile_init(&models->profile_list); managed_ids_init(tctx->allocator, &models->managed_id_set); API_VTable_custom custom_vtable = {}; custom_api_fill_vtable(&custom_vtable); API_VTable_system system_vtable = {}; system_api_fill_vtable(&system_vtable); Custom_Layer_Init_Type *custom_init = api.init_apis(&custom_vtable, &system_vtable); Assert(custom_init != 0); // NOTE(allen): coroutines coroutine_system_init(&models->coroutines); // NOTE(allen): font set font_set_init(&models->font_set); // NOTE(allen): live set Arena *arena = models->arena; { models->view_set.count = 0; models->view_set.max = MAX_VIEWS; models->view_set.views = push_array(arena, View, models->view_set.max); //dll_init_sentinel models->view_set.free_sentinel.next = &models->view_set.free_sentinel; models->view_set.free_sentinel.prev = &models->view_set.free_sentinel; i32 max = models->view_set.max; View *view = models->view_set.views; for (i32 i = 0; i < max; ++i, ++view){ //dll_insert(&models->view_set.free_sentinel, view); view->next = models->view_set.free_sentinel.next; view->prev = &models->view_set.free_sentinel; models->view_set.free_sentinel.next = view; view->next->prev = view; } } lifetime_allocator_init(tctx->allocator, &models->lifetime_allocator); dynamic_workspace_init(&models->lifetime_allocator, DynamicWorkspace_Global, 0, &models->dynamic_workspace); // NOTE(allen): file setup working_set_init(models, &models->working_set); Mutex_Lock file_order_lock(models->working_set.mutex); // NOTE(allen): global_history_init(&models->global_history); text_layout_init(tctx, &models->text_layouts); // NOTE(allen): style setup { Scratch_Block scratch(tctx, arena); String8 binary_path = system_get_path(scratch, SystemPath_Binary); String8 full_path = push_u8_stringf(arena, "%.*sfonts/liberation-mono.ttf", string_expand(binary_path)); Face_Description description = {}; description.font.file_name = full_path; description.parameters.pt_size = 12; Face *new_face = font_set_new_face(&models->font_set, &description); if (new_face == 0){ system_error_box("Could not load the required fallback font"); } models->global_face_id = new_face->id; } // NOTE(allen): title space models->has_new_title = true; models->title_capacity = KB(4); models->title_space = push_array(arena, char, models->title_capacity); block_copy(models->title_space, WINDOW_NAME, sizeof(WINDOW_NAME)); // NOTE(allen): miscellaneous init hot_directory_init(arena, &models->hot_directory, current_directory); child_process_container_init(tctx->allocator, &models->child_processes); models->period_wakeup_timer = system_wake_up_timer_create(); // NOTE(allen): custom layer init Application_Links app = {}; app.tctx = tctx; app.cmd_context = models; custom_init(&app); // NOTE(allen): init baked in buffers File_Init init_files[] = { { str8_lit("*messages*"), &models->message_buffer , true , }, { str8_lit("*scratch*") , &models->scratch_buffer , false, }, { str8_lit("*log*") , &models->log_buffer , true , }, { str8_lit("*keyboard*"), &models->keyboard_buffer, true , }, }; Buffer_Hook_Function *begin_buffer_func = models->begin_buffer; models->begin_buffer = 0; Heap *heap = &models->heap; for (i32 i = 0; i < ArrayCount(init_files); ++i){ Editing_File *file = working_set_allocate_file(&models->working_set, &models->lifetime_allocator); buffer_bind_name(tctx, models, arena, &models->working_set, file, init_files[i].name); if (init_files[i].ptr != 0){ *init_files[i].ptr = file; } File_Attributes attributes = {}; file_create_from_string(tctx, models, file, SCu8(), attributes); if (init_files[i].read_only){ file->settings.read_only = true; history_free(tctx, &file->state.history); } file->settings.never_kill = true; file_set_unimportant(file, true); } models->begin_buffer = begin_buffer_func; // NOTE(allen): setup first panel { Panel *panel = layout_initialize(arena, &models->layout); View *new_view = live_set_alloc_view(&models->lifetime_allocator, &models->view_set, panel); view_init(tctx, models, new_view, models->scratch_buffer, models->view_event_handler); } } App_Step_Sig(app_step){ Models *models = (Models*)base_ptr; Mutex_Lock file_order_lock(models->working_set.mutex); Scratch_Block scratch(tctx); models->next_animate_delay = max_u32; models->animate_next_frame = false; // NOTE(allen): per-frame update of models state begin_frame(target, &models->font_set); models->target = target; models->input = input; // NOTE(allen): OS clipboard event handling if (input->clipboard.str != 0){ co_send_core_event(tctx, models, CoreCode_NewClipboardContents, input->clipboard); } // NOTE(allen): reorganizing panels on screen Vec2_i32 prev_dim = layout_get_root_size(&models->layout); Vec2_i32 current_dim = V2i32(target->width, target->height); layout_set_root_size(&models->layout, current_dim); // NOTE(allen): update child processes f32 dt = input->dt; if (dt > 0){ Temp_Memory_Block temp(scratch); Child_Process_Container *child_processes = &models->child_processes; Child_Process **processes_to_free = push_array(scratch, Child_Process*, child_processes->active_child_process_count); i32 processes_to_free_count = 0; u32 max = KB(128); char *dest = push_array(scratch, char, max); for (Node *node = child_processes->child_process_active_list.next; node != &child_processes->child_process_active_list; node = node->next){ Child_Process *child_process = CastFromMember(Child_Process, node, node); Editing_File *file = child_process->out_file; CLI_Handles *cli = &child_process->cli; // TODO(allen): do(call a 'child process updated hook' let that hook populate the buffer if it so chooses) b32 edited_file = false; u32 amount = 0; system_cli_begin_update(cli); if (system_cli_update_step(cli, dest, max, &amount)){ if (file != 0 && amount > 0){ output_file_append(tctx, models, file, SCu8(dest, amount)); edited_file = true; } } if (system_cli_end_update(cli)){ if (file != 0){ String_Const_u8 str = push_u8_stringf(scratch, "exited with code %d", cli->exit); output_file_append(tctx, models, file, str); edited_file = true; } processes_to_free[processes_to_free_count++] = child_process; child_process_set_return_code(models, child_processes, child_process->id, cli->exit); } if (child_process->cursor_at_end && file != 0){ file_cursor_to_end(tctx, models, file); } } for (i32 i = 0; i < processes_to_free_count; ++i){ child_process_free(child_processes, processes_to_free[i]->id); } } // NOTE(allen): simulated events Input_List input_list = input->events; Input_Modifier_Set modifiers = system_get_keyboard_modifiers(scratch); if (input->mouse.press_l){ Input_Event event = {}; event.kind = InputEventKind_MouseButton; event.mouse.code = MouseCode_Left; event.mouse.p = input->mouse.p; event.mouse.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } else if (input->mouse.release_l){ Input_Event event = {}; event.kind = InputEventKind_MouseButtonRelease; event.mouse.code = MouseCode_Left; event.mouse.p = input->mouse.p; event.mouse.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } if (input->mouse.press_r){ Input_Event event = {}; event.kind = InputEventKind_MouseButton; event.mouse.code = MouseCode_Right; event.mouse.p = input->mouse.p; event.mouse.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } else if (input->mouse.release_r){ Input_Event event = {}; event.kind = InputEventKind_MouseButtonRelease; event.mouse.code = MouseCode_Right; event.mouse.p = input->mouse.p; event.mouse.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } if (input->mouse.wheel != 0){ Input_Event event = {}; event.kind = InputEventKind_MouseWheel; event.mouse_wheel.value = (f32)(input->mouse.wheel); event.mouse_wheel.p = input->mouse.p; event.mouse_wheel.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } if (input->mouse.p != models->prev_p){ b32 was_in_window = rect_contains_point(Ri32(0, 0, prev_dim.x, prev_dim.y), models->prev_p); b32 is_in_window = rect_contains_point(Ri32(0, 0, current_dim.x, current_dim.y), input->mouse.p); if (is_in_window || was_in_window){ Input_Event event = {}; event.kind = InputEventKind_MouseMove; event.mouse_move.p = input->mouse.p; event.mouse_move.modifiers = copy_modifier_set(scratch, &modifiers); push_input_event(scratch, &input_list, &event); } } if (models->animated_last_frame){ Input_Event event = {}; event.kind = InputEventKind_Core; event.core.code = CoreCode_Animate; push_input_event(scratch, &input_list, &event); } // NOTE(allen): expose layout Layout *layout = &models->layout; // NOTE(allen): mouse hover status Panel *mouse_panel = 0; Panel *divider_panel = 0; b32 mouse_in_margin = false; Vec2_i32 mouse = input->mouse.p; { for (Panel *panel = layout_get_first_open_panel(layout); panel != 0; panel = layout_get_next_open_panel(layout, panel)){ if (rect_contains_point(panel->rect_full, mouse)){ mouse_panel = panel; if (!rect_contains_point(panel->rect_inner, mouse)){ mouse_in_margin = true; for (divider_panel = mouse_panel->parent; divider_panel != 0; divider_panel = divider_panel->parent){ if (rect_contains_point(divider_panel->rect_inner, mouse)){ break; } } } } if (mouse_panel != 0){ break; } } } // NOTE(allen): First frame initialization if (input->first_step){ Temp_Memory_Block temp(scratch); String_Const_u8_Array file_names = {}; file_names.count = models->settings.init_files_count; file_names.vals = push_array(scratch, String_Const_u8, file_names.count); for (i32 i = 0; i < file_names.count; i += 1){ file_names.vals[i] = SCu8(models->settings.init_files[i]); } String_Const_u8_Array flags = {}; flags.count = models->settings.custom_flags_count; flags.vals = push_array(scratch, String_Const_u8, flags.count); for (i32 i = 0; i < flags.count; i += 1){ flags.vals[i] = SCu8(models->settings.custom_flags[i]); } Input_Event event = {}; event.kind = InputEventKind_Core; event.core.code = CoreCode_Startup; event.core.flag_strings = flags; event.core.file_names = file_names; co_send_event(tctx, models, &event); // NOTE(allen): Actually do the buffer settings for the built ins now. Buffer_Hook_Function *begin_buffer_func = models->begin_buffer; if (begin_buffer_func != 0){ Application_Links app = {}; app.tctx = tctx; app.cmd_context = models; begin_buffer_func(&app, models->message_buffer->id); begin_buffer_func(&app, models->scratch_buffer->id); begin_buffer_func(&app, models->log_buffer->id); begin_buffer_func(&app, models->keyboard_buffer->id); } } // NOTE(allen): consume event stream Input_Event_Node *input_node = input_list.first; Input_Event_Node *input_node_next = 0; for (;; input_node = input_node_next){ // NOTE(allen): first handle any events coming from the view command // function queue Model_View_Command_Function cmd_func = models_pop_view_command_function(models); if (cmd_func.custom_func != 0){ View *view = imp_get_view(models, cmd_func.view_id); if (view != 0){ input_node_next = input_node; Input_Event cmd_func_event = {}; cmd_func_event.kind = InputEventKind_CustomFunction; cmd_func_event.custom_func = cmd_func.custom_func; co_send_event(tctx, models, view, &cmd_func_event); continue; } } Temp_Memory_Block temp(scratch); Input_Event *simulated_input = 0; Input_Event virtual_event = models_pop_virtual_event(scratch, models); if (virtual_event.kind != InputEventKind_None){ virtual_event.virtual_event = true; simulated_input = &virtual_event; } else{ if (input_node == 0){ break; } input_node_next = input_node->next; simulated_input = &input_node->event; if (simulated_input->kind == InputEventKind_TextInsert && simulated_input->text.blocked){ continue; } // NOTE(allen): record to keyboard history if (simulated_input->kind == InputEventKind_KeyStroke || simulated_input->kind == InputEventKind_KeyRelease || simulated_input->kind == InputEventKind_TextInsert){ Temp_Memory_Block temp_key_line(scratch); String_Const_u8 key_line = stringize_keyboard_event(scratch, simulated_input); output_file_append(tctx, models, models->keyboard_buffer, key_line); } } b32 event_was_handled = false; Input_Event *event = simulated_input; Panel *active_panel = layout_get_active_panel(layout); View *view = active_panel->view; Assert(view != 0); switch (models->state){ case APP_STATE_EDIT: { typedef i32 Event_Consume_Rule; enum{ EventConsume_None, EventConsume_BeginResize, EventConsume_ClickChangeView, EventConsume_CustomCommand, }; Event_Consume_Rule consume_rule = EventConsume_CustomCommand; if (match_mouse_code(event, MouseCode_Left) && (divider_panel != 0)){ consume_rule = EventConsume_BeginResize; } else if (match_mouse_code(event, MouseCode_Left) && mouse_panel != 0 && mouse_panel != active_panel){ consume_rule = EventConsume_ClickChangeView; } switch (consume_rule){ case EventConsume_BeginResize: { models->state = APP_STATE_RESIZING; models->resizing_intermediate_panel = divider_panel; event_was_handled = true; }break; case EventConsume_ClickChangeView: { // NOTE(allen): run deactivate command co_send_core_event(tctx, models, view, CoreCode_ClickDeactivateView); layout->active_panel = mouse_panel; models->animate_next_frame = true; active_panel = mouse_panel; view = active_panel->view; // NOTE(allen): run activate command co_send_core_event(tctx, models, view, CoreCode_ClickActivateView); event_was_handled = true; }break; case EventConsume_CustomCommand: { event_was_handled = co_send_event(tctx, models, view, event); }break; } }break; case APP_STATE_RESIZING: { Event_Property event_flags = get_event_properties(event); if (HasFlag(event_flags, EventProperty_AnyKey) || match_mouse_code_release(event, MouseCode_Left)){ models->state = APP_STATE_EDIT; } else if (event->kind == InputEventKind_MouseMove){ if (input->mouse.l){ Panel *split = models->resizing_intermediate_panel; Range_i32 limits = layout_get_limiting_range_on_split(layout, split); i32 mouse_position = (split->vertical_split)?(mouse.x):(mouse.y); mouse_position = clamp(limits.min, mouse_position, limits.max); layout_set_split_absolute_position(layout, split, mouse_position); } else{ models->state = APP_STATE_EDIT; } } }break; } if (event_was_handled && event->kind == InputEventKind_KeyStroke){ for (Input_Event *dependent_text = event->key.first_dependent_text; dependent_text != 0; dependent_text = dependent_text->text.next_text){ Assert(dependent_text->kind == InputEventKind_TextInsert); dependent_text->text.blocked = true; } } } linalloc_clear(&models->virtual_event_arena); models->free_virtual_event = 0; models->first_virtual_event = 0; models->last_virtual_event = 0; // NOTE(allen): send panel size update if (models->layout.panel_state_dirty){ models->layout.panel_state_dirty = false; if (models->buffer_viewer_update != 0){ Application_Links app = {}; app.tctx = tctx; app.cmd_context = models; models->buffer_viewer_update(&app); } } // NOTE(allen): dt f32 literal_dt = 0.f; u64 now_usecond_stamp = system_now_time(); if (!input->first_step){ u64 elapsed_useconds = now_usecond_stamp - models->last_render_usecond_stamp; literal_dt = (f32)((f64)(elapsed_useconds)/1000000.f); } models->last_render_usecond_stamp = now_usecond_stamp; f32 animation_dt = 0.f; if (models->animated_last_frame){ animation_dt = literal_dt; } // NOTE(allen): on the first frame there should be no scrolling if (input->first_step){ for (Panel *panel = layout_get_first_open_panel(layout); panel != 0; panel = layout_get_next_open_panel(layout, panel)){ View *view = panel->view; File_Edit_Positions edit_pos = view_get_edit_pos(view); edit_pos.scroll.position = view_normalize_buffer_point(tctx, models, view, edit_pos.scroll.target); block_zero_struct(&edit_pos.scroll.target); view_set_edit_pos(view, edit_pos); } } // NOTE(allen): hook for files reloaded { Working_Set *working_set = &models->working_set; Assert(working_set->has_external_mod_sentinel.next != 0); if (working_set->has_external_mod_sentinel.next != &working_set->has_external_mod_sentinel){ for (Node *node = working_set->has_external_mod_sentinel.next, *next = 0; node != &working_set->has_external_mod_sentinel; node = next){ next = node->next; Editing_File *file = CastFromMember(Editing_File, external_mod_node, node); dll_remove(node); block_zero_struct(node); co_send_core_event(tctx, models, CoreCode_FileExternallyModified, file->id); } } } // NOTE(allen): if the exit signal has been sent, run the exit hook. if (!models->keep_playing || input->trying_to_kill){ co_send_core_event(tctx, models, CoreCode_TryExit); models->keep_playing = true; } // NOTE(allen): rendering { Frame_Info frame = {}; frame.index = models->frame_counter; frame.literal_dt = literal_dt; frame.animation_dt = animation_dt; Application_Links app = {}; app.tctx = tctx; app.cmd_context = models; if (models->tick != 0){ models->tick(&app, frame); } begin_render_section(target, models->frame_counter, literal_dt, animation_dt); models->in_render_mode = true; Live_Views *live_views = &models->view_set; for (Node *node = layout->open_panels.next; node != &layout->open_panels; node = node->next){ Panel *panel = CastFromMember(Panel, node, node); View *view = panel->view; View_Context_Node *ctx = view->ctx; if (ctx != 0){ Render_Caller_Function *render_caller = ctx->ctx.render_caller; if (render_caller != 0){ render_caller(&app, frame, view_get_id(live_views, view)); } } } if (models->whole_screen_render_caller != 0){ models->whole_screen_render_caller(&app, frame); } models->in_render_mode = false; end_render_section(target); } // TODO(allen): This is dumb. Let's rethink view cleanup strategy. // NOTE(allen): wind down coroutines for (;;){ Model_Wind_Down_Co *node = models->wind_down_stack; if (node == 0){ break; } sll_stack_pop(models->wind_down_stack); Coroutine *co = node->co; for (i32 j = 0; co != 0; j += 1){ Co_In in = {}; in.user_input.abort = true; Co_Out ignore = {}; co = co_run(tctx, models, co, &in, &ignore); if (j == 100){ Application_Links app = {}; app.tctx = tctx; app.cmd_context = models; #define M "SERIOUS ERROR: coroutine wind down did not complete\n" print_message(&app, string_u8_litexpr(M)); #undef M break; } } sll_stack_push(models->free_wind_downs, node); } // NOTE(allen): flush the log log_flush(tctx, models); // NOTE(allen): set the app_result Application_Step_Result app_result = {}; app_result.mouse_cursor_type = APP_MOUSE_CURSOR_DEFAULT; app_result.lctrl_lalt_is_altgr = models->settings.lctrl_lalt_is_altgr; // NOTE(allen): get new window title if (models->has_new_title){ models->has_new_title = false; app_result.has_new_title = true; app_result.title_string = models->title_space; } // NOTE(allen): get cursor type if (mouse_panel != 0 && !mouse_in_margin){ app_result.mouse_cursor_type = APP_MOUSE_CURSOR_ARROW; } else if (divider_panel != 0){ if (divider_panel->vertical_split){ app_result.mouse_cursor_type = APP_MOUSE_CURSOR_LEFTRIGHT; } else{ app_result.mouse_cursor_type = APP_MOUSE_CURSOR_UPDOWN; } } else{ app_result.mouse_cursor_type = APP_MOUSE_CURSOR_ARROW; } models->prev_mouse_panel = mouse_panel; app_result.lctrl_lalt_is_altgr = models->settings.lctrl_lalt_is_altgr; app_result.perform_kill = models->hard_exit; app_result.animating = models->animate_next_frame; if (models->animate_next_frame){ // NOTE(allen): Silence the timer, because we're going to do another frame right away anyways. system_wake_up_timer_set(models->period_wakeup_timer, max_u32); } else{ // NOTE(allen): Set the timer's wakeup period, possibly to max_u32 thus effectively silencing it. system_wake_up_timer_set(models->period_wakeup_timer, models->next_animate_delay); } // NOTE(allen): Update Frame to Frame States models->prev_p = input->mouse.p; models->animated_last_frame = app_result.animating; models->frame_counter += 1; // end-of-app_step return(app_result); } extern "C" App_Get_Functions_Sig(app_get_functions){ App_Functions result = {}; result.load_vtables = app_load_vtables; result.get_logger = app_get_logger; result.read_command_line = app_read_command_line; result.init = app_init; result.step = app_step; return(result); } // BOTTOM