voxel/kubi
1
1
Fork 0
mirror of https://github.com/griffi-gh/kubi.git synced 2024-12-22 03:48:21 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #8 from griffi-gh/upgrade-deps0

Browse source 
Upgrade to latest `glium`/`glutin`/`winit`, use `android-activity` instead of `ndk_glue`
This commit is contained in:
griffi-gh 2023-11-21 22:41:32 +01:00 committed by GitHub
parent 5678b0c06f 6f982d4308
commit fe1427249b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 1131 additions and 935 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored
View file

@ -15,3 +15,6 @@ _src
_visualizer.json
*.kubi
/*_log*.txt
/*.log

1679
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

2
kubi-server/Cargo.toml
View file

@ -8,7 +8,7 @@ publish = false
kubi-shared = { path = "../kubi-shared" }
kubi-logging = { path = "../kubi-logging" }
log = "0.4"
shipyard = { git = "https://github.com/leudz/shipyard", rev = "0934b426eb9a8", default-features = false, features = ["std", "proc", "thread_local"] }
shipyard = { git = "https://github.com/leudz/shipyard", rev = "8ef90ea6c4d1eb6c9cb0988f0d2f873f75044d49", default-features = false, features = ["std", "proc", "thread_local"] }
serde = { version = "1.0", default-features = false, features = ["alloc", "derive"] }
toml = "0.8"
glam = { version = "0.24", features = ["debug-glam-assert", "fast-math"] }

2
kubi-shared/Cargo.toml
View file

@ -6,7 +6,7 @@ publish = false
[dependencies]
glam = { version = "0.24", features = ["debug-glam-assert", "fast-math", "serde"] }
shipyard = { git = "https://github.com/leudz/shipyard", rev = "0934b426eb9a8", default-features = false, features = ["std"] }
shipyard = { git = "https://github.com/leudz/shipyard", rev = "8ef90ea6c4d1eb6c9cb0988f0d2f873f75044d49", default-features = false, features = ["std"] }
strum = { version = "0.25", features = ["derive"] }
num_enum = "0.7"
postcard = { version = "1.0", features = ["alloc"] }

2
kubi-ui/Cargo.toml
View file

@ -8,7 +8,7 @@ publish = false
hashbrown = "0.14"
nohash-hasher = "0.2"
glam = { version = "0.24", features = ["approx"] }
glium = { git = "https://github.com/glium/glium", rev = "5d50e7", optional = true }
glium = { git = "https://github.com/glium/glium", rev = "968fc92378caf", optional = true }
[features]
default = ["backend_glium", "builtin_elements"]

20
kubi/Cargo.toml
View file

@ -13,14 +13,18 @@ kubi-shared = { path = "../kubi-shared" }
kubi-logging = { path = "../kubi-logging" }
kubi-ui = { path = "../kubi-ui" }
log = "0.4"
glium = { git = "https://github.com/glium/glium", rev = "5d50e7" }
glium = { git = "https://github.com/glium/glium", rev = "968fc92378caf" }
glutin = "0.31"
winit = { version = "0.29", features = ["android-native-activity"] }
glutin-winit = "0.4"
raw-window-handle = "0.5"
glam = { version = "0.24", features = ["debug-glam-assert", "fast-math"] }
image = { version = "0.24", default_features = false, features = ["png"] }
strum = { version = "0.25", features = ["derive"] }
hashbrown = "0.14"
nohash-hasher = "0.2"
rayon = "1.7"
shipyard = { git = "https://github.com/leudz/shipyard", rev = "0934b426eb9a8", default-features = false, features = ["std", "proc", "thread_local"] }
shipyard = { git = "https://github.com/leudz/shipyard", rev = "8ef90ea6c4d1eb6c9cb0988f0d2f873f75044d49", default-features = false, features = ["std", "proc", "thread_local"] }
anyhow = "1.0"
flume = "0.11"
gilrs = { version = "0.10", default_features = false, features = ["xinput"] }
@ -32,8 +36,8 @@ tinyset = "0.4"
serde_json = { version = "1.0", optional = true } #only used for `generate_visualizer_data`
[target.'cfg(target_os = "android")'.dependencies]
ndk = "0.7"
ndk-glue = "0.7"
android-activity = "0.5"
ndk = "0.8"
[target.'cfg(target_os = "windows")'.dependencies]
winapi = "0.3"
@ -64,6 +68,14 @@ target_sdk_version = 30
required = true
glEsVersion = 0x00030000
[[package.metadata.android.uses_feature]]
name = "android.hardware.touchscreen.multitouch"
required = true
[[package.metadata.android.uses_feature]]
name = "android.hardware.touchscreen.multitouch.distinct"
required = true
[package.metadata.android.application.activity]
config_changes = "orientation|keyboardHidden|screenLayout|screenSize"
exported = true

34
kubi/src/block_placement.rs
View file

@ -1,26 +1,32 @@
use shipyard::{UniqueViewMut, UniqueView, View, IntoIter, ViewMut, EntitiesViewMut, Workload, IntoWorkload};
use glium::glutin::event::VirtualKeyCode;
use winit::keyboard::KeyCode;
use kubi_shared::{
block::Block,
queue::QueuedBlock,
queue::QueuedBlock,
player::PlayerHolding,
};
use crate::{
player::MainPlayer,
world::{raycast::{LookingAtBlock, RAYCAST_STEP}, queue::BlockUpdateQueue},
input::{Inputs, PrevInputs, RawKbmInputState},
events::{EventComponent, player_actions::PlayerActionEvent},
world::{
raycast::{LookingAtBlock, RAYCAST_STEP},
queue::BlockUpdateQueue
},
input::{Inputs, PrevInputs, RawKbmInputState},
events::{
EventComponent,
player_actions::PlayerActionEvent
},
};
const BLOCK_KEY_MAP: &[(VirtualKeyCode, Block)] = &[
(VirtualKeyCode::Key1, Block::Cobblestone),
(VirtualKeyCode::Key2, Block::Planks),
(VirtualKeyCode::Key3, Block::Dirt),
(VirtualKeyCode::Key4, Block::Grass),
(VirtualKeyCode::Key5, Block::Sand),
(VirtualKeyCode::Key6, Block::Stone),
(VirtualKeyCode::Key7, Block::Torch),
(VirtualKeyCode::Key8, Block::Leaf),
const BLOCK_KEY_MAP: &[(KeyCode, Block)] = &[
(KeyCode::Digit1, Block::Cobblestone),
(KeyCode::Digit2, Block::Planks),
(KeyCode::Digit3, Block::Dirt),
(KeyCode::Digit4, Block::Grass),
(KeyCode::Digit5, Block::Sand),
(KeyCode::Digit6, Block::Stone),
(KeyCode::Digit7, Block::Torch),
(KeyCode::Digit8, Block::Leaf),
];
fn pick_block_with_number_keys(

12
kubi/src/control_flow.rs
View file

@ -1,21 +1,21 @@
use shipyard::{UniqueView, UniqueViewMut, Unique, AllStoragesView};
use glium::glutin::{event::VirtualKeyCode, event_loop::ControlFlow};
use winit::{keyboard::KeyCode, event_loop::ControlFlow};
use crate::input::RawKbmInputState;
#[derive(Unique)]
pub struct SetControlFlow(pub Option<ControlFlow>);
pub struct RequestExit(pub bool);
pub fn exit_on_esc(
raw_inputs: UniqueView<RawKbmInputState>,
mut control_flow: UniqueViewMut<SetControlFlow>
mut exit: UniqueViewMut<RequestExit>
) {
if raw_inputs.keyboard_state.contains(VirtualKeyCode::Escape as u32) {
control_flow.0 = Some(ControlFlow::Exit);
if raw_inputs.keyboard_state.contains(KeyCode::Escape as u32) {
exit.0 = true;
}
}
pub fn insert_control_flow_unique(
storages: AllStoragesView
) {
storages.add_unique(SetControlFlow(None))
storages.add_unique(RequestExit(false))
}

6
kubi/src/cursor_lock.rs
View file

@ -1,6 +1,6 @@
use shipyard::{AllStoragesView, Unique, NonSendSync, UniqueView, UniqueViewMut};
use crate::rendering::Renderer;
use glium::glutin::window::CursorGrabMode;
use winit::window::CursorGrabMode;
#[derive(Unique)]
pub struct CursorLock(pub bool);
@ -13,8 +13,8 @@ pub fn update_cursor_lock_state(
return
}
if lock.is_inserted_or_modified() {
let gl_window = display.display.gl_window();
let window = gl_window.window();
//TODO MIGRATION
let window = &display.window;
window.set_cursor_grab(match lock.0 {
true => CursorGrabMode::Confined,
false => CursorGrabMode::None,

20
kubi/src/events.rs
View file

@ -1,6 +1,6 @@
use glam::UVec2;
use shipyard::{World, Component, AllStoragesViewMut, SparseSet, NonSendSync, UniqueView};
use glium::glutin::event::{Event, DeviceEvent, DeviceId, WindowEvent, Touch};
use winit::event::{Event, DeviceEvent, DeviceId, WindowEvent, Touch, RawKeyEvent, TouchPhase};
use crate::rendering::Renderer;
pub mod player_actions;
@ -24,7 +24,7 @@ pub struct TouchEvent(pub Touch);
#[derive(Component, Clone, Copy, Debug, Default)]
pub struct WindowResizedEvent(pub UVec2);
pub fn process_glutin_events(world: &mut World, event: &Event<'_, ()>) {
pub fn process_glutin_events(world: &mut World, event: &Event<()>) {
#[allow(clippy::collapsible_match, clippy::single_match)]
match event {
Event::WindowEvent { window_id: _, event } => match event {
@ -36,17 +36,25 @@ pub fn process_glutin_events(world: &mut World, event: &Event<'_, ()>) {
},
#[cfg(not(feature = "raw-evt"))]
WindowEvent::KeyboardInput { device_id, input, is_synthetic } => {
WindowEvent::KeyboardInput { device_id, event, .. } => {
world.add_entity((
EventComponent,
InputDeviceEvent {
device_id: *device_id,
event: DeviceEvent::Key(*input)
event: DeviceEvent::Key(RawKeyEvent {
physical_key: event.physical_key,
state: event.state,
})
}
));
}
WindowEvent::Touch(touch) => {
// if matches!(touch.phase, TouchPhase::Started | TouchPhase::Cancelled | TouchPhase::Ended) {
// println!("TOUCH ==================== {:#?}", touch);
// } else {
// println!("TOUCH MOVED {:?} {}", touch.phase, touch.id);
// }
world.add_entity((
EventComponent,
TouchEvent(*touch)
@ -67,13 +75,13 @@ pub fn process_glutin_events(world: &mut World, event: &Event<'_, ()>) {
));
},
Event::LoopDestroyed => {
Event::LoopExiting => {
world.add_entity((
EventComponent,
OnBeforeExitEvent
));
},
_ => (),
}
}

34
kubi/src/filesystem.rs
View file

@ -1,21 +1,29 @@
use std::{fs::File, path::Path, io::{Read, Seek}};
use anyhow::Result;
use shipyard::{Unique, AllStoragesView};
pub trait ReadOnly: Read + Seek {}
impl<T: Read + Seek> ReadOnly for T {}
pub fn open_asset(path: &Path) -> Result<Box<dyn ReadOnly>> {
#[cfg(target_os = "android")] {
use anyhow::Context;
use std::ffi::CString;
let asset_manager = ndk_glue::native_activity().asset_manager();
let path_cstr = CString::new(path.to_string_lossy().as_bytes())?;
let handle = asset_manager.open(&path_cstr).context("Asset doesn't exist")?;
Ok(Box::new(handle))
}
#[cfg(not(target_os = "android"))] {
let asset_path = Path::new("./assets/").join(path);
Ok(Box::new(File::open(asset_path)?))
#[derive(Unique)]
pub struct AssetManager {
#[cfg(target_os = "android")]
pub(crate) app: android_activity::AndroidApp,
}
impl AssetManager {
pub fn open_asset(&self, path: &Path) -> Result<Box<dyn ReadOnly>> {
#[cfg(target_os = "android")] {
use anyhow::Context;
use std::ffi::CString;
let asset_manager = self.app.asset_manager();
let path_cstr = CString::new(path.to_string_lossy().as_bytes())?;
let handle = asset_manager.open(&path_cstr).context("Asset doesn't exist")?;
Ok(Box::new(handle))
}
#[cfg(not(target_os = "android"))] {
let asset_path = Path::new("./assets/").join(path);
Ok(Box::new(File::open(asset_path)?))
}
}
}

33
kubi/src/input.rs
View file

@ -1,6 +1,9 @@
use gilrs::{Gilrs, GamepadId, Button, Event, Axis};
use glam::{Vec2, DVec2, vec2, dvec2};
use glium::glutin::event::{DeviceEvent, DeviceId, VirtualKeyCode, ElementState, TouchPhase};
use winit::{
keyboard::{KeyCode, PhysicalKey},
event::{DeviceEvent, DeviceId, ElementState, TouchPhase}
};
use hashbrown::HashMap;
use tinyset::{SetU32, SetU64};
use nohash_hasher::BuildNoHashHasher;
@ -94,21 +97,21 @@ fn process_events(
) {
input_state.mouse_delta = DVec2::ZERO;
for event in device_events.iter() {
match event.event {
match &event.event {
DeviceEvent::MouseMotion { delta } => {
input_state.mouse_delta = DVec2::from(delta);
input_state.mouse_delta = DVec2::from(*delta);
},
DeviceEvent::Key(input) => {
if let Some(keycode) = input.virtual_keycode {
if let PhysicalKey::Code(code) = input.physical_key {
match input.state {
ElementState::Pressed => input_state.keyboard_state.insert(keycode as u32),
ElementState::Released => input_state.keyboard_state.remove(keycode as u32),
ElementState::Pressed => input_state.keyboard_state.insert(code as u32),
ElementState::Released => input_state.keyboard_state.remove(code as u32),
};
}
},
DeviceEvent::Button { button, state } => {
if button < 32 {
input_state.button_state[button as usize] = matches!(state, ElementState::Pressed);
if *button < 32 {
input_state.button_state[*button as usize] = matches!(*state, ElementState::Pressed);
}
},
_ => ()
@ -127,6 +130,7 @@ fn process_touch_events(
let position = dvec2(event.0.location.x, event.0.location.y);
match event.0.phase {
TouchPhase::Started => {
//println!("touch started: finger {}", event.0.id);
touch_state.fingers.insert(event.0.id, Finger {
id: event.0.id,
device_id: event.0.device_id,
@ -143,6 +147,7 @@ fn process_touch_events(
}
},
TouchPhase::Ended | TouchPhase::Cancelled => {
//println!("touch ended: finger {}", event.0.id);
touch_state.fingers.remove(&event.0.id);
},
}
@ -173,14 +178,14 @@ fn update_input_state (
mut inputs: UniqueViewMut<Inputs>,
) {
inputs.movement += Vec2::new(
raw_inputs.keyboard_state.contains(VirtualKeyCode::D as u32) as u32 as f32 -
raw_inputs.keyboard_state.contains(VirtualKeyCode::A as u32) as u32 as f32,
raw_inputs.keyboard_state.contains(VirtualKeyCode::W as u32) as u32 as f32 -
raw_inputs.keyboard_state.contains(VirtualKeyCode::S as u32) as u32 as f32
raw_inputs.keyboard_state.contains(KeyCode::KeyD as u32) as u32 as f32 -
raw_inputs.keyboard_state.contains(KeyCode::KeyA as u32) as u32 as f32,
raw_inputs.keyboard_state.contains(KeyCode::KeyW as u32) as u32 as f32 -
raw_inputs.keyboard_state.contains(KeyCode::KeyS as u32) as u32 as f32
);
inputs.look += raw_inputs.mouse_delta.as_vec2();
inputs.action_a |= raw_inputs.button_state[1];
inputs.action_b |= raw_inputs.button_state[3];
inputs.action_a |= raw_inputs.button_state[0];
inputs.action_b |= raw_inputs.button_state[1];
}
fn update_input_state_gamepad (

100
kubi/src/lib.rs
View file

@ -6,7 +6,7 @@ use shipyard::{
NonSendSync, WorkloadModificator,
SystemModificator
};
use glium::glutin::{
use winit::{
event_loop::{EventLoop, ControlFlow},
event::{Event, WindowEvent}
};
@ -72,7 +72,7 @@ use rendering::{
use block_placement::update_block_placement;
use delta_time::{DeltaTime, init_delta_time};
use cursor_lock::{insert_lock_state, update_cursor_lock_state, lock_cursor_now};
use control_flow::{exit_on_esc, insert_control_flow_unique, SetControlFlow};
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;
@ -80,6 +80,7 @@ use legacy_gui::{render_gui, init_gui, update_gui};
use loading_screen::update_loading_screen;
use connecting_screen::switch_to_loading_if_connected;
use fixed_timestamp::init_fixed_timestamp_storage;
use filesystem::AssetManager;
/// stuff required to init the renderer and other basic systems
fn pre_startup() -> Workload {
@ -169,8 +170,15 @@ fn attach_console() {
}
#[no_mangle]
#[cfg_attr(target_os = "android", ndk_glue::main(backtrace = "on"))]
pub fn kubi_main() {
#[cfg(target_os = "android")]
pub fn android_main(app: android_activity::AndroidApp) {
use android_activity::WindowManagerFlags;
app.set_window_flags(WindowManagerFlags::FULLSCREEN, WindowManagerFlags::empty());
kubi_main(app)
}
#[no_mangle]
pub fn kubi_main(#[cfg(target_os = "android")] app: android_activity::AndroidApp) {
//Attach console on release builds on windows
#[cfg(all(windows, not(debug_assertions)))] attach_console();
@ -182,26 +190,19 @@ pub fn kubi_main() {
//Create a shipyard world
let mut world = World::new();
//Init assman
world.add_unique(AssetManager {
#[cfg(target_os = "android")]
app: app.clone()
});
//Register workloads
world.add_workload(pre_startup);
world.add_workload(startup);
world.add_workload(update);
world.add_workload(render);
world.add_workload(after_frame_end);
//Run pre-startup procedure
world.run_workload(pre_startup).unwrap();
//Create event loop
let event_loop = EventLoop::new();
//Initialize renderer
{
let settings = world.borrow::<UniqueView<GameSettings>>().unwrap();
world.add_unique_non_send_sync(Renderer::init(&event_loop, &settings));
}
world.add_unique(BackgroundColor(vec3(0.5, 0.5, 1.)));
//Save _visualizer.json
#[cfg(feature = "generate_visualizer_data")]
@ -210,24 +211,65 @@ pub fn kubi_main() {
serde_json::to_string(&world.workloads_info()).unwrap(),
).unwrap();
//Run startup systems
world.run_workload(startup).unwrap();
//Run pre-startup procedure
world.run_workload(pre_startup).unwrap();
//Create event loop
let event_loop ={
#[cfg(not(target_os = "android"))] { EventLoop::new().unwrap() }
#[cfg(target_os = "android")] {
use winit::{
platform::android::EventLoopBuilderExtAndroid,
event_loop::EventLoopBuilder
};
EventLoopBuilder::new().with_android_app(app).build().unwrap()
}
};
//Run the event loop
let mut last_update = Instant::now();
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Poll;
let mut ready = false;
event_loop.run(move |event, window_target| {
//Wait for the window to become active (required for android)
if !ready {
if Event::Resumed != event {
window_target.set_control_flow(ControlFlow::Wait);
return
}
//Initialize renderer
{
let settings = world.borrow::<UniqueView<GameSettings>>().unwrap();
world.add_unique_non_send_sync(Renderer::init(window_target, &settings));
}
world.add_unique(BackgroundColor(vec3(0.5, 0.5, 1.)));
//Run startup systems
world.run_workload(startup).unwrap();
ready = true;
}
window_target.set_control_flow(ControlFlow::Poll);
process_glutin_events(&mut world, &event);
#[allow(clippy::collapsible_match, clippy::single_match)]
match event {
#[cfg(target_os = "android")]
Event::Suspended => {
window_target.exit();
}
Event::WindowEvent { event, .. } => match event {
WindowEvent::CloseRequested => {
log::info!("exit requested");
*control_flow = ControlFlow::Exit;
window_target.exit();
},
_ => (),
},
Event::MainEventsCleared => {
Event::AboutToWait => {
//Update delta time (maybe move this into a system?)
{
let mut dt_view = world.borrow::<UniqueViewMut<DeltaTime>>().unwrap();
@ -235,10 +277,10 @@ pub fn kubi_main() {
dt_view.0 = now - last_update;
last_update = now;
}
//Run update workflows
world.run_workload(update).unwrap();
//Start rendering (maybe use custom views for this?)
let target = {
let renderer = world.borrow::<NonSendSync<UniqueView<Renderer>>>().unwrap();
@ -257,11 +299,11 @@ pub fn kubi_main() {
world.run_workload(after_frame_end).unwrap();
//Process control flow changes
if let Some(flow) = world.borrow::<UniqueView<SetControlFlow>>().unwrap().0 {
*control_flow = flow;
if world.borrow::<UniqueView<RequestExit>>().unwrap().0 {
window_target.exit();
}
},
_ => (),
};
});
}).unwrap();
}

6
kubi/src/loading_screen.rs
View file

@ -1,12 +1,12 @@
use shipyard::{UniqueView, UniqueViewMut, Workload, IntoWorkload, EntityId, Unique, AllStoragesViewMut, ViewMut, Get, SystemModificator, track};
use glium::glutin::event::VirtualKeyCode;
use winit::keyboard::KeyCode;
use glam::{Mat3, vec2};
use crate::{
world::ChunkStorage,
state::{GameState, NextState, is_changing_state},
transform::Transform2d,
legacy_gui::{
GuiComponent,
GuiComponent,
progressbar::ProgressbarComponent
},
rendering::{WindowSize, if_resized},
@ -76,7 +76,7 @@ fn override_loading(
kbm_state: UniqueView<RawKbmInputState>,
mut state: UniqueViewMut<NextState>
) {
if kbm_state.keyboard_state.contains(VirtualKeyCode::F as u32) {
if kbm_state.keyboard_state.contains(KeyCode::KeyF as u32) {
state.0 = Some(GameState::InGame);
}
}

14
kubi/src/networking.rs
View file

@ -1,5 +1,5 @@
use shipyard::{Unique, AllStoragesView, UniqueView, UniqueViewMut, Workload, IntoWorkload, EntitiesViewMut, Component, ViewMut, SystemModificator, View, IntoIter, WorkloadModificator};
use glium::glutin::event_loop::ControlFlow;
use winit::event_loop::ControlFlow;
use std::net::SocketAddr;
use uflow::{
client::{Client, Config as ClientConfig, Event as ClientEvent},
@ -12,7 +12,7 @@ use kubi_shared::networking::{
};
use crate::{
events::EventComponent,
control_flow::SetControlFlow,
control_flow::RequestExit,
world::tasks::ChunkTaskManager,
state::is_ingame_or_loading,
fixed_timestamp::FixedTimestamp
@ -155,10 +155,11 @@ pub fn update_networking_late() -> Workload {
}
pub fn disconnect_on_exit(
control_flow: UniqueView<SetControlFlow>,
exit: UniqueView<RequestExit>,
mut client: UniqueViewMut<UdpClient>,
) {
if let Some(ControlFlow::ExitWithCode(_)) = control_flow.0 {
//TODO check if this works
if exit.0 {
if client.0.is_active() {
client.0.flush();
client.0.disconnect();
@ -167,11 +168,6 @@ pub fn disconnect_on_exit(
} else {
log::info!("Client inactive")
}
// if let Err(error) = client.0. {
// log::error!("failed to disconnect: {}", error);
// } else {
// log::info!("Client disconnected");
// }
}
}

8
kubi/src/prefabs.rs
View file

@ -1,7 +1,7 @@
use shipyard::{NonSendSync, UniqueView, Unique, AllStoragesView};
use glium::{texture::{SrgbTexture2dArray, MipmapsOption}, Program};
use kubi_shared::block::BlockTexture;
use crate::rendering::Renderer;
use crate::{rendering::Renderer, filesystem::AssetManager};
mod texture;
mod shaders;
@ -54,12 +54,14 @@ pub struct ProgressbarShaderPrefab(pub Program);
pub fn load_prefabs(
storages: AllStoragesView,
renderer: NonSendSync<UniqueView<Renderer>>
renderer: NonSendSync<UniqueView<Renderer>>,
assman: UniqueView<AssetManager>
) {
log::info!("Loading textures...");
storages.add_unique_non_send_sync(BlockTexturesPrefab(
load_texture2darray_prefab::<BlockTexture, _>(
"blocks".into(),
&assman,
"blocks".into(),
&renderer.display,
MipmapsOption::AutoGeneratedMipmaps
)

5
kubi/src/prefabs/texture.rs
View file

@ -2,13 +2,14 @@ use strum::IntoEnumIterator;
use rayon::prelude::*;
use std::{path::PathBuf, io::BufReader};
use glium::{texture::{SrgbTexture2dArray, RawImage2d, MipmapsOption}, backend::Facade};
use crate::filesystem::open_asset;
use crate::filesystem::AssetManager;
use super::AssetPaths;
pub fn load_texture2darray_prefab<
T: AssetPaths + IntoEnumIterator,
E: Facade
>(
assman: &AssetManager,
directory: PathBuf,
facade: &E,
mipmaps: MipmapsOption,
@ -21,7 +22,7 @@ pub fn load_texture2darray_prefab<
//Get path to the image and open the file
let reader = {
let path = directory.join(file_name);
BufReader::new(open_asset(&path).expect("Failed to open texture file"))
BufReader::new(assman.open_asset(&path).expect("Failed to open texture file"))
};
//Parse image data
let (image_data, dimensions) = {

78
kubi/src/rendering.rs
View file

@ -1,12 +1,17 @@
use std::num::NonZeroU32;
use raw_window_handle::HasRawWindowHandle;
use shipyard::{Unique, NonSendSync, UniqueView, UniqueViewMut, View, IntoIter, AllStoragesView};
use glium::{
Display, Surface,
Version, Api,
glutin::{
event_loop::EventLoop,
window::{WindowBuilder, Fullscreen},
ContextBuilder, GlProfile, GlRequest, dpi::PhysicalSize
},
use winit::{
event_loop::EventLoopWindowTarget,
window::{WindowBuilder, Fullscreen, Window},
dpi::PhysicalSize
};
use glium::{Display, Surface, Version, Api};
use glutin::{
prelude::*,
context::ContextAttributesBuilder,
surface::{WindowSurface, SurfaceAttributesBuilder},
display::GetGlDisplay,
};
use glam::{Vec3, UVec2};
use crate::{events::WindowResizedEvent, settings::{GameSettings, FullscreenMode}};
@ -30,12 +35,14 @@ pub struct WindowSize(pub UVec2);
#[derive(Unique)]
pub struct Renderer {
pub display: Display
pub window: Window,
pub display: Display<WindowSurface>,
}
impl Renderer {
pub fn init(event_loop: &EventLoop<()>, settings: &GameSettings) -> Self {
pub fn init(event_loop: &EventLoopWindowTarget<()>, settings: &GameSettings) -> Self {
log::info!("initializing display");
let wb = WindowBuilder::new()
.with_title("kubi")
.with_maximized(true)
@ -82,16 +89,43 @@ impl Renderer {
}
});
let cb = ContextBuilder::new()
//.with_srgb(false)
.with_depth_buffer(24)
.with_multisampling(settings.msaa.unwrap_or_default())
.with_vsync(settings.vsync)
.with_gl_profile(GlProfile::Core)
.with_gl(GlRequest::Latest);
// First we start by opening a new Window
let display_builder = glutin_winit::DisplayBuilder::new().with_window_builder(Some(wb));
let config_template_builder = glutin::config::ConfigTemplateBuilder::new();
let (window, gl_config) = display_builder
.build(event_loop, config_template_builder, |mut configs| {
configs.next().unwrap()
})
.unwrap();
let window = window.unwrap();
let display = Display::new(wb, cb, event_loop)
.expect("Failed to create a glium Display");
// Now we get the window size to use as the initial size of the Surface
let (width, height): (u32, u32) = window.inner_size().into();
let attrs = SurfaceAttributesBuilder::<WindowSurface>::new().build(
window.raw_window_handle(),
NonZeroU32::new(width).unwrap(),
NonZeroU32::new(height).unwrap(),
);
// Finally we can create a Surface, use it to make a PossiblyCurrentContext and create the glium Display
let surface = unsafe { gl_config.display().create_window_surface(&gl_config, &attrs).unwrap() };
let context_attributes = ContextAttributesBuilder::new().build(Some(window.raw_window_handle()));
let current_context = unsafe {
gl_config.display().create_context(&gl_config, &context_attributes).expect("failed to create context")
}.make_current(&surface).unwrap();
let display = Display::from_context_surface(current_context, surface).unwrap();
//TODO MIGRATION
// let cb = ContextBuilder::new()
// //.with_srgb(false)
// .with_depth_buffer(24)
// .with_multisampling(settings.msaa.unwrap_or_default())
// .with_vsync(settings.vsync)
// .with_gl_profile(GlProfile::Core)
// .with_gl(GlRequest::Latest);
// let display = Display::new(wb, cb)
// .expect("Failed to create a glium Display");
log::info!("Vendor: {}", display.get_opengl_vendor_string());
log::info!("Renderer: {}", display.get_opengl_renderer_string());
@ -101,10 +135,10 @@ impl Renderer {
if display.is_context_loss_possible() { log::warn!("OpenGL context loss possible") }
if display.is_robust() { log::warn!("OpenGL implementation is not robust") }
if display.is_debug() { log::info!("OpenGL context is in debug mode") }
assert!(display.is_glsl_version_supported(&Version(Api::GlEs, 3, 0)), "GLSL ES 3.0 is not supported");
Self { display }
Self { window, display }
}
}

8
kubi/src/settings.rs
View file

@ -27,9 +27,13 @@ impl Default for GameSettings {
fullscreen: None,
msaa: Some(4),
max_anisotropy: Some(16),
render_distance: 6,
render_distance: match true {
cfg!(debug_assertions) => 5,
cfg!(target_os = "android") => 6,
#[allow(unreachable_patterns)] _ => 8,
},
mouse_sensitivity: 1.,
debug_draw_current_chunk_border: cfg!(not(target_os = "android")) && cfg!(debug_assertions),
debug_draw_current_chunk_border: false, //cfg!(not(target_os = "android")) && cfg!(debug_assertions),
}
}
}