diff --git a/assets/fonts/Crisp.ttf b/assets/fonts/Crisp.ttf new file mode 100644 index 0000000..36f3a53 Binary files /dev/null and b/assets/fonts/Crisp.ttf differ diff --git a/assets/fonts/roboto/LICENSE.txt b/assets/fonts/roboto/LICENSE.txt deleted file mode 100644 index d645695..0000000 --- a/assets/fonts/roboto/LICENSE.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/assets/fonts/roboto/Roboto-Regular.ttf b/assets/fonts/roboto/Roboto-Regular.ttf deleted file mode 100644 index ddf4bfa..0000000 Binary files a/assets/fonts/roboto/Roboto-Regular.ttf and /dev/null differ diff --git a/kubi/src/connecting_screen.rs b/kubi/src/connecting_screen.rs index 047311b..4b8fa7c 100644 --- a/kubi/src/connecting_screen.rs +++ b/kubi/src/connecting_screen.rs @@ -1,12 +1,48 @@ -use kubi_shared::networking::state::ClientJoinState; -use shipyard::{UniqueViewMut, UniqueView}; -use crate::state::{NextState, GameState}; - -pub fn switch_to_loading_if_connected( - mut next_state: UniqueViewMut, - client_state: UniqueView, -) { - if *client_state == ClientJoinState::Joined { - next_state.0 = Some(GameState::LoadingWorld); - } -} +use hui::element::text::Text; +use kubi_shared::networking::state::ClientJoinState; +use shipyard::{IntoWorkload, NonSendSync, UniqueView, UniqueViewMut, Workload}; +use crate::{ + hui_integration::UiState, + loading_screen::loading_screen_base, + networking::ServerAddress, + rendering::WindowSize, + state::{GameState, NextState} +}; + +fn render_connecting_ui( + addr: UniqueView, + mut ui: NonSendSync>, + size: UniqueView, +) { + let font_handle = ui.fonts[0]; + ui.hui.add( + loading_screen_base(vec![ + Box::new(Text { + text: format!( + "Connecting to {}...", + addr.0, + ).into(), + font: font_handle, + text_size: 16, + ..Default::default() + }), + ], 1.), + size.0.as_vec2(), + ); +} + +fn switch_to_loading_if_connected( + mut next_state: UniqueViewMut, + client_state: UniqueView, +) { + if *client_state == ClientJoinState::Joined { + next_state.0 = Some(GameState::LoadingWorld); + } +} + +pub fn update_connecting_screen() -> Workload { + ( + render_connecting_ui, + switch_to_loading_if_connected, + ).into_workload() +} diff --git a/kubi/src/hui_integration.rs b/kubi/src/hui_integration.rs index 46a085f..35683d8 100644 --- a/kubi/src/hui_integration.rs +++ b/kubi/src/hui_integration.rs @@ -1,12 +1,15 @@ -use hui::UiInstance; +use std::{io::{BufReader, prelude::*}, path::Path}; +use hui::{text::FontHandle, UiInstance}; use hui_glium::GliumUiRenderer; use shipyard::{AllStoragesView, Unique, UniqueView, NonSendSync, UniqueViewMut}; -use crate::rendering::{Renderer, RenderTarget, WindowSize}; +use crate::{filesystem::AssetManager, rendering::{RenderTarget, Renderer, WindowSize}}; #[derive(Unique)] pub struct UiState { pub hui: UiInstance, pub renderer: GliumUiRenderer, + //HACK: This is a temporary solution, i don't think fonts should be stored here + pub fonts: Vec, } pub fn kubi_ui_init( @@ -15,10 +18,23 @@ pub fn kubi_ui_init( let renderer = storages.borrow::>>().unwrap(); storages.add_unique_non_send_sync(UiState { hui: UiInstance::new(), - renderer: GliumUiRenderer::new(&renderer.display) + renderer: GliumUiRenderer::new(&renderer.display), + fonts: vec![], }); } +//TODO: Use prefab system for this +pub fn kubi_ui_load_assets( + asset_manager: UniqueView, + mut ui: NonSendSync> +) { + let asset_handle = asset_manager.open_asset(Path::new("fonts/Crisp.ttf")).unwrap(); + let mut font_data = vec![]; + BufReader::new(asset_handle).read_to_end(&mut font_data).unwrap(); + let font_handle = ui.hui.add_font_from_bytes(&font_data); + ui.fonts.push(font_handle); +} + pub fn kubi_ui_begin( mut ui: NonSendSync> ) { @@ -29,7 +45,7 @@ pub fn kubi_ui_end( mut ui: NonSendSync> ) { let ui: &mut UiState = &mut ui; - let UiState { hui, renderer } = ui; + let UiState { hui, renderer, .. } = ui; hui.end(); renderer.update(hui); } diff --git a/kubi/src/lib.rs b/kubi/src/lib.rs index a8422bb..cc5ae8d 100644 --- a/kubi/src/lib.rs +++ b/kubi/src/lib.rs @@ -77,9 +77,9 @@ use control_flow::{exit_on_esc, insert_control_flow_unique, RequestExit}; use state::{is_ingame, is_ingame_or_loading, is_loading, init_state, update_state, is_connecting}; use networking::{update_networking, update_networking_late, is_multiplayer, disconnect_on_exit, is_singleplayer}; use init::initialize_from_args; -use hui_integration::{kubi_ui_init, kubi_ui_begin, kubi_ui_end, kubi_ui_draw}; +use hui_integration::{kubi_ui_begin, kubi_ui_draw, kubi_ui_end, kubi_ui_init, kubi_ui_load_assets}; use loading_screen::update_loading_screen; -use connecting_screen::switch_to_loading_if_connected; +use connecting_screen::update_connecting_screen; use fixed_timestamp::init_fixed_timestamp_storage; use filesystem::AssetManager; use client_physics::{init_client_physics, update_client_physics_late}; @@ -97,6 +97,7 @@ fn startup() -> Workload { initial_resize_event, init_window_size, kubi_ui_init, + kubi_ui_load_assets, load_prefabs, init_primitives, insert_lock_state, @@ -124,7 +125,7 @@ fn update() -> Workload { ).into_sequential_workload().run_if(is_ingame_or_loading), update_networking().run_if(is_multiplayer), ( - switch_to_loading_if_connected + update_connecting_screen, ).into_sequential_workload().run_if(is_connecting), ( update_loading_screen, diff --git a/kubi/src/loading_screen.rs b/kubi/src/loading_screen.rs index f47c34b..328eac1 100644 --- a/kubi/src/loading_screen.rs +++ b/kubi/src/loading_screen.rs @@ -1,16 +1,17 @@ use hui::{ element::{container::Container, progress_bar::ProgressBar, text::Text, UiElement}, layout::{Alignment, UiDirection, UiSize}, - rectangle::{Corners, Sides}, UiInstance + rectangle::{Corners, Sides}, }; use shipyard::{UniqueView, UniqueViewMut, Workload, NonSendSync, IntoWorkload}; use winit::keyboard::KeyCode; use crate::{ - world::ChunkStorage, - state::{GameState, NextState}, - rendering::WindowSize, - input::RawKbmInputState, hui_integration::UiState, + input::RawKbmInputState, + networking::ServerAddress, + rendering::WindowSize, + state::{GameState, NextState}, + world::ChunkStorage }; pub fn loading_screen_base(elements: Vec>, bg_alpha: f32) -> Container { @@ -21,7 +22,7 @@ pub fn loading_screen_base(elements: Vec>, bg_alpha: f32) -> elements: vec![ Box::new(Container { padding: Sides::all(10.), - gap: 10., + gap: 5., background: (0.2, 0.2, 0.2).into(), corner_radius: Corners::all(8.), elements, @@ -33,8 +34,9 @@ pub fn loading_screen_base(elements: Vec>, bg_alpha: f32) -> } fn render_loading_ui( - mut ui: NonSendSync>, + addr: Option>, world: UniqueView, + mut ui: NonSendSync>, size: UniqueView ) { let loaded = world.chunks.iter().fold(0, |acc, (&_, chunk)| { @@ -43,9 +45,16 @@ fn render_loading_ui( let total = world.chunks.len(); let value = loaded as f32 / total as f32; let percentage = value * 100.; + + let font_handle = ui.fonts[0]; ui.hui.add(loading_screen_base(vec![ Box::new(Text { - text: "Loading...".into(), + text: match addr { + Some(addr) => format!("Connected to {}\nDownloading world data...", addr.0).into(), + _ => "Loading...".into(), + }, + font: font_handle, + text_size: 16, ..Default::default() }), Box::new(ProgressBar { @@ -61,11 +70,20 @@ fn render_loading_ui( elements: vec![ Box::new(Text { text: format!("{loaded}/{total} ({percentage:.1}%)").into(), + font: font_handle, + text_size: 16, ..Default::default() }) ], ..Default::default() }), + // Box::new(Text { + // text: "--------------------------------------------------\nTip: You can press F to skip this loading screen".into(), + // font: font_handle, + // text_size: 16, + // color: (0.5, 0.5, 0.5, 1.).into(), + // ..Default::default() + // }) ], 1. - (value - 0.75).max(0.)), size.0.as_vec2()); }