update the loading screen

assets/fonts/roboto/LICENSE.txt

@@ -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.

kubi/src/connecting_screen.rs

@@ -1,8 +1,37 @@
+use hui::element::text::Text;
 use kubi_shared::networking::state::ClientJoinState;
-use shipyard::{UniqueViewMut, UniqueView};
+use shipyard::{IntoWorkload, NonSendSync, UniqueView, UniqueViewMut, Workload};
-use crate::state::{NextState, GameState};
+use crate::{
+  hui_integration::UiState,
+  loading_screen::loading_screen_base,
+  networking::ServerAddress,
+  rendering::WindowSize,
+  state::{GameState, NextState}
+};
 
-pub fn switch_to_loading_if_connected(
+fn render_connecting_ui(
+  addr: UniqueView<ServerAddress>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
+  size: UniqueView<WindowSize>,
+) {
+  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<NextState>,
   client_state: UniqueView<ClientJoinState>,
 ) {
@@ -10,3 +39,10 @@ pub fn switch_to_loading_if_connected(
     next_state.0 = Some(GameState::LoadingWorld);
   }
 }
+
+pub fn update_connecting_screen() -> Workload {
+  (
+    render_connecting_ui,
+    switch_to_loading_if_connected,
+  ).into_workload()
+}

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<FontHandle>,
 }
 
 pub fn kubi_ui_init(
@@ -15,10 +18,23 @@ pub fn kubi_ui_init(
   let renderer = storages.borrow::<NonSendSync<UniqueView<Renderer>>>().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<AssetManager>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>
+) {
+  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<UniqueViewMut<UiState>>
 ) {
@@ -29,7 +45,7 @@ pub fn kubi_ui_end(
   mut ui: NonSendSync<UniqueViewMut<UiState>>
 ) {
   let ui: &mut UiState = &mut ui;
-  let UiState { hui, renderer } = ui;
+  let UiState { hui, renderer, .. } = ui;
   hui.end();
   renderer.update(hui);
 }

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,

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<Box<dyn UiElement>>, bg_alpha: f32) -> Container {
@@ -21,7 +22,7 @@ pub fn loading_screen_base(elements: Vec<Box<dyn UiElement>>, 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<Box<dyn UiElement>>, bg_alpha: f32) ->
 }
 
 fn render_loading_ui(
-  mut ui: NonSendSync<UniqueViewMut<UiState>>,
+  addr: Option<UniqueView<ServerAddress>>,
   world: UniqueView<ChunkStorage>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
   size: UniqueView<WindowSize>
 ) {
   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());
 }