shadowcat/voxel-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

idk switching to bevy ecs again

Browse Source
This commit is contained in:
shadow cat
2024-06-13 00:54:52 -04:00
parent df4e433dcc
commit 24a7e299fa
20 changed files with 615 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/client/app.rs
View File

@@ -1,9 +1,4 @@
use std::sync::Arc;
use winit::{
application::ApplicationHandler, event::WindowEvent, event_loop::ControlFlow,
window::WindowAttributes,
};
use winit::{application::ApplicationHandler, event::WindowEvent, event_loop::ControlFlow};
use super::Client;
@@ -24,13 +19,7 @@ impl ClientApp {
impl ApplicationHandler for ClientApp {
fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
if self.client.is_none() {
let window = Arc::new(
event_loop
.create_window(WindowAttributes::default())
.expect("Failed to create window"),
);
let client = Client::new(window);
self.client = Some(client);
self.client = Some(Client::new(event_loop));
}
event_loop.set_control_flow(ControlFlow::Poll);
}
@@ -54,8 +43,6 @@ impl ApplicationHandler for ClientApp {
}
fn about_to_wait(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
if self.client().update() {
event_loop.exit();
}
self.client().update(event_loop);
}
}

10
src/client/component.rs
View File

@@ -1,18 +1,18 @@
use std::ops::{Deref, DerefMut};
use evenio::component::Component;
use bevy_ecs::system::Resource;
use super::render::RendererChannel;
#[derive(Component)]
pub struct RenderComponent(pub RendererChannel);
impl Deref for RenderComponent {
#[derive(Resource)]
pub struct RenderResource(pub RendererChannel);
impl Deref for RenderResource {
type Target = RendererChannel;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for RenderComponent {
impl DerefMut for RenderResource {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}

15
src/client/handle_input.rs
View File

@@ -4,9 +4,9 @@ use nalgebra::Rotation3;
use ndarray::Array3;
use winit::{dpi::PhysicalPosition, keyboard::KeyCode as Key, window::CursorGrabMode};
use crate::world::component::VoxelGrid;
use crate::world::component::{VoxelGrid, VoxelGridBundle};
use super::{render::voxel::VoxelColor, system::voxel_grid::SpawnVoxelGrid, Client};
use super::{render::voxel::VoxelColor, Client};
impl Client {
pub fn handle_input(&mut self, dt: &Duration) {
@@ -102,19 +102,18 @@ impl Client {
}
if state.camera != old_camera {
self.renderer
.send(super::render::RenderMessage::ViewUpdate(state.camera))
.expect("AAAAAAA");
.send(super::render::RenderMessage::ViewUpdate(state.camera));
}
// fun
if input.just_pressed(Key::KeyF) {
self.world.send(SpawnVoxelGrid {
pos: state.camera.pos + 135.0 * 2.0 * *state.camera.forward(),
orientation: state.camera.orientation,
self.world.spawn(VoxelGridBundle {
pos: (state.camera.pos + 135.0 * 2.0 * *state.camera.forward()).into(),
orientation: state.camera.orientation.into(),
grid: VoxelGrid::new(Array3::from_shape_fn((135, 135, 135), |(..)| {
VoxelColor::white()
})),
})
});
}
}
}

73
src/client/init.rs
View File

@@ -1,73 +0,0 @@
use crate::world::component::VoxelGrid;
use evenio::world::World;
use nalgebra::{Rotation3, UnitVector3, Vector3};
use ndarray::Array3;
use crate::client::render::voxel::VoxelColor;
use super::system::voxel_grid::SpawnVoxelGrid;
pub fn init_world(world: &mut World) {
let dim = (15, 10, 10);
world.send(SpawnVoxelGrid {
pos: Vector3::new(0.0, 0.0, 20.0),
orientation: Rotation3::from_axis_angle(&Vector3::y_axis(), 0.5),
grid: VoxelGrid::new(Array3::from_shape_fn(dim, |(x, y, z)| {
if x == z && x == y {
VoxelColor::white()
} else if z == 3 {
VoxelColor {
r: (x as f32 / dim.0 as f32 * 255.0) as u8,
g: (y as f32 / dim.1 as f32 * 255.0) as u8,
b: 100,
a: 255,
}
} else if z == 0 {
VoxelColor {
r: (x as f32 / dim.0 as f32 * 255.0) as u8,
g: (y as f32 / dim.1 as f32 * 255.0) as u8,
b: 0,
a: 100,
}
} else {
VoxelColor::none()
}
})),
});
let dim = (1000, 2, 1000);
world.send(SpawnVoxelGrid {
pos: Vector3::new(0.0, -2.1, 0.0),
orientation: Rotation3::identity(),
grid: VoxelGrid::new(Array3::from_shape_fn(dim, |(x, y, z)| {
if y == 0 {
VoxelColor::random()
} else if (y == dim.1 - 1) && (x == 0 || x == dim.0 - 1 || z == 0 || z == dim.2 - 1) {
VoxelColor {
r: 255,
g: 0,
b: 255,
a: 255,
}
} else {
VoxelColor::none()
}
})),
});
let dim = (3, 3, 3);
world.send(SpawnVoxelGrid {
pos: Vector3::new(0.0, 0.0, 16.5),
orientation: Rotation3::from_axis_angle(&Vector3::y_axis(), std::f32::consts::PI / 4.0)
* Rotation3::from_axis_angle(
&UnitVector3::new_normalize(Vector3::new(1.0, 0.0, 1.0)),
std::f32::consts::PI / 4.0,
),
grid: VoxelGrid::new(Array3::from_shape_fn(dim, |(..)| VoxelColor {
r: 255,
g: 0,
b: 255,
a: 255,
})),
});
}

57
src/client/mod.rs
View File

@@ -2,7 +2,6 @@ mod app;
mod camera;
mod component;
mod handle_input;
mod init;
mod input;
pub mod render;
mod rsc;
@@ -10,15 +9,20 @@ mod state;
mod system;
pub use app::*;
use component::RenderComponent;
use evenio::world::World;
use init::init_world;
use bevy_ecs::{system::SystemId, world::World};
use component::RenderResource;
use render::{RenderMessage, RendererChannel};
pub use state::*;
use system::voxel_grid::update_renderer;
use crate::{server::Server, sync::ServerHandle, world::generation::generate};
use self::{input::Input, render::Renderer, ClientState};
use std::{sync::Arc, thread::JoinHandle, time::Instant};
use winit::{event::WindowEvent, window::Window};
use winit::{
event::WindowEvent,
window::{Window, WindowAttributes},
};
pub struct Client {
window: Arc<Window>,
@@ -31,19 +35,26 @@ pub struct Client {
grabbed_cursor: bool,
keep_cursor: bool,
world: World,
server: ServerHandle,
bruh: SystemId,
}
impl Client {
pub fn new(window: Arc<Window>) -> Self {
pub fn new(event_loop: &winit::event_loop::ActiveEventLoop) -> Self {
let mut world = World::new();
let window = Arc::new(
event_loop
.create_window(WindowAttributes::default())
.expect("Failed to create window"),
);
let (render_channel, render_handle) = Renderer::spawn(window.clone());
let e = world.spawn();
world.insert(e, RenderComponent(render_channel.clone()));
world.add_handler(system::voxel_grid::handle_create_grid);
world.insert_resource(RenderResource(render_channel.clone()));
let bruh = world.register_system(update_renderer);
init_world(&mut world);
let state = ClientState::new();
let server = Server::spawn();
generate(&mut world);
Self {
window,
@@ -56,10 +67,12 @@ impl Client {
grabbed_cursor: false,
keep_cursor: false,
world,
server,
bruh,
}
}
pub fn update(&mut self) -> bool {
pub fn update(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
let now = Instant::now();
let dt = now - self.prev_update;
self.prev_update = now;
@@ -67,8 +80,12 @@ impl Client {
self.handle_input(&dt);
self.input.end();
self.recv();
self.world.run_system(self.bruh).expect("WHAT");
self.world.clear_trackers();
if self.exit {
let _ = self.renderer.send(RenderMessage::Exit);
self.renderer.send(RenderMessage::Exit);
// you know I'd like to do a timeout here...
// only because I have an NVIDIA GPU HELP
self.render_handle
@@ -76,21 +93,19 @@ impl Client {
.expect("uh oh")
.join()
.expect("bruh");
event_loop.exit();
}
self.exit
}
pub fn recv(&mut self) {
for msg in self.server.recv() {}
}
pub fn window_event(&mut self, event: WindowEvent) {
match event {
WindowEvent::CloseRequested => self.exit = true,
WindowEvent::Resized(size) => self
.renderer
.send(RenderMessage::Resize(size))
.expect("render broke"),
WindowEvent::RedrawRequested => self
.renderer
.send(RenderMessage::Draw)
.expect("render broke"),
WindowEvent::Resized(size) => self.renderer.send(RenderMessage::Resize(size)),
WindowEvent::RedrawRequested => self.renderer.send(RenderMessage::Draw),
WindowEvent::CursorLeft { .. } => {
self.input.clear();
}

19
src/client/render/mod.rs
View File

@@ -17,6 +17,7 @@ pub struct Renderer<'a> {
surface: wgpu::Surface<'a>,
device: wgpu::Device,
queue: wgpu::Queue,
encoder: wgpu::CommandEncoder,
config: wgpu::SurfaceConfiguration,
staging_belt: wgpu::util::StagingBelt,
voxel_pipeline: VoxelPipeline,
@@ -96,6 +97,7 @@ impl<'a> Renderer<'a> {
voxel_pipeline: VoxelPipeline::new(&device, &config.format),
staging_belt,
surface,
encoder: Self::create_encoder(&device),
device,
config,
queue,
@@ -105,15 +107,14 @@ impl<'a> Renderer<'a> {
}
}
fn create_encoder(&mut self) -> wgpu::CommandEncoder {
self.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
})
fn create_encoder(device: &wgpu::Device) -> wgpu::CommandEncoder {
device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
})
}
pub fn draw(&mut self, encoder: &mut wgpu::CommandEncoder) {
let mut encoder = std::mem::replace(encoder, self.create_encoder());
pub fn draw(&mut self) {
let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device));
let output = self.surface.get_current_texture().unwrap();
let view = output
.texture
@@ -146,7 +147,7 @@ impl<'a> Renderer<'a> {
self.staging_belt.recall();
}
pub fn resize(&mut self, size: PhysicalSize<u32>, encoder: &mut wgpu::CommandEncoder) {
pub fn resize(&mut self, size: PhysicalSize<u32>) {
self.size = Vector2::new(size.width, size.height);
self.config.width = size.width;
self.config.height = size.height;
@@ -156,7 +157,7 @@ impl<'a> Renderer<'a> {
self.voxel_pipeline.update_view(
&self.device,
encoder,
&mut self.encoder,
&mut self.staging_belt,
self.size,
&self.camera,

30
src/client/render/thread.rs
View File

@@ -12,7 +12,7 @@ use std::{
};
use winit::{dpi::PhysicalSize, window::Window};
#[derive(Debug)]
#[derive(Debug, Clone)]
pub enum RenderMessage {
Resize(PhysicalSize<u32>),
Draw,
@@ -21,9 +21,7 @@ pub enum RenderMessage {
Exit,
}
pub type RendererChannel = Sender<RenderMessage>;
#[derive(Debug)]
#[derive(Debug, Clone)]
pub struct CreateVoxelGrid {
pub pos: Vector3<f32>,
pub orientation: Rotation3<f32>,
@@ -46,7 +44,7 @@ impl Renderer<'_> {
.create_surface(window)
.expect("Could not create window surface!");
(
s,
RendererChannel(s),
std::thread::spawn(move || {
Self::new(instance, surface, size).start(&mut r);
}),
@@ -54,25 +52,24 @@ impl Renderer<'_> {
}
pub fn start(&mut self, reciever: &mut Receiver<RenderMessage>) {
let mut encoder = self.create_encoder();
let mut new_camera = false;
'main: loop {
let now = Instant::now();
while let Ok(msg) = reciever.try_recv() {
for msg in reciever.try_iter() {
match msg {
RenderMessage::CreateVoxelGrid(desc) => {
self.voxel_pipeline.add_group(
&self.device,
&mut encoder,
&mut self.encoder,
&mut self.staging_belt,
desc,
);
}
RenderMessage::Draw => {
self.draw(&mut encoder);
self.draw();
}
RenderMessage::Resize(size) => {
self.resize(size, &mut encoder);
self.resize(size);
}
RenderMessage::Exit => {
break 'main;
@@ -88,15 +85,24 @@ impl Renderer<'_> {
if new_camera {
self.voxel_pipeline.update_view(
&self.device,
&mut encoder,
&mut self.encoder,
&mut self.staging_belt,
self.size,
&self.camera,
);
new_camera = false;
}
self.draw(&mut encoder);
self.draw();
}
}
}
}
#[derive(Clone)]
pub struct RendererChannel(Sender<RenderMessage>);
impl RendererChannel {
pub fn send(&self, msg: RenderMessage) {
// TODO: handle this properly
self.0.send(msg).expect("Failed to send renderer message");
}
}

49
src/client/system/voxel_grid.rs
View File

@@ -1,49 +1,36 @@
use evenio::{
event::{EventMut, GlobalEvent, Insert, ReceiverMut, Sender, Spawn},
fetch::Single,
use bevy_ecs::{
query::{Changed, Or},
system::{Query, Res},
};
use nalgebra::{Rotation3, Vector3};
use nalgebra::Vector3;
use ndarray::Axis;
use crate::{
client::{
component::RenderComponent,
component::RenderResource,
render::{CreateVoxelGrid, RenderMessage},
},
world::component::{Orientation, Pos, VoxelGrid},
};
#[derive(GlobalEvent)]
pub struct SpawnVoxelGrid {
pub pos: Vector3<f32>,
pub orientation: Rotation3<f32>,
pub grid: VoxelGrid,
}
pub fn handle_create_grid(
r: ReceiverMut<SpawnVoxelGrid>,
renderer: Single<&RenderComponent>,
mut s: Sender<(Spawn, Insert<Pos>, Insert<Orientation>, Insert<VoxelGrid>)>,
pub fn update_renderer(
query: Query<
(&Pos, &Orientation, &VoxelGrid),
Or<(Changed<Pos>, Changed<Orientation>, Changed<VoxelGrid>)>,
>,
renderer: Res<RenderResource>,
) {
let SpawnVoxelGrid {
pos,
orientation,
grid,
} = EventMut::take(r.event);
renderer
.send(RenderMessage::CreateVoxelGrid(CreateVoxelGrid {
pos,
orientation,
for (pos, orientation, grid) in query.iter() {
println!("YAY");
renderer.send(RenderMessage::CreateVoxelGrid(CreateVoxelGrid {
pos: **pos,
orientation: **orientation,
dimensions: Vector3::new(
grid.len_of(Axis(0)),
grid.len_of(Axis(1)),
grid.len_of(Axis(2)),
),
grid: grid.iter().cloned().collect(),
}))
.expect("render broke");
let e = s.spawn();
s.insert(e, Pos(pos));
s.insert(e, Orientation(orientation));
s.insert(e, grid);
}));
}
}