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

back to single threaded renderer, client server good now

Browse Source
This commit is contained in:
shadow cat
2024-06-14 16:31:16 -04:00
parent 24a7e299fa
commit 219213ee24
25 changed files with 435 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/client/render/command.rs Normal file
View File

@@ -0,0 +1,83 @@
use crate::client::camera::Camera;
use super::{voxel::VoxelColor, Renderer};
use bevy_ecs::entity::Entity;
use nalgebra::{Rotation3, Vector3};
use std::sync::Arc;
use winit::window::Window;
#[derive(Debug, Clone)]
pub enum RenderCommand {
CreateVoxelGrid(CreateVoxelGrid),
UpdateGridTransform(UpdateGridTransform),
ViewUpdate(Camera),
}
#[derive(Debug, Clone)]
pub struct CreateVoxelGrid {
pub id: Entity,
pub pos: Vector3<f32>,
pub orientation: Rotation3<f32>,
pub dimensions: Vector3<usize>,
pub grid: Vec<VoxelColor>,
}
#[derive(Debug, Clone)]
pub struct UpdateGridTransform {
pub id: Entity,
pub pos: Vector3<f32>,
pub orientation: Rotation3<f32>,
}
impl<'a> Renderer<'a> {
pub fn spawn(window: Arc<Window>) -> Renderer<'a> {
let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::PRIMARY,
..Default::default()
});
let surface = instance
.create_surface(window)
.expect("Could not create window surface!");
Self::new(instance, surface, size)
}
pub fn handle_commands(&mut self, commands: Vec<RenderCommand>) {
let mut new_camera = false;
for cmd in commands {
match cmd {
RenderCommand::CreateVoxelGrid(desc) => {
self.voxel_pipeline.add_group(
&self.device,
&mut self.encoder,
&mut self.staging_belt,
desc,
);
}
RenderCommand::ViewUpdate(camera) => {
new_camera = true;
self.camera = camera;
}
RenderCommand::UpdateGridTransform(update) => {
self.voxel_pipeline.update_transform(
&self.device,
&mut self.encoder,
&mut self.staging_belt,
update,
);
}
}
}
if new_camera {
self.voxel_pipeline.update_view(
&self.device,
&mut self.encoder,
&mut self.staging_belt,
self.size,
&self.camera,
);
}
}
}

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

@@ -1,14 +1,13 @@
mod thread;
mod command;
mod util;
pub mod voxel;
pub use thread::*;
pub use command::*;
use super::camera::Camera;
use crate::client::rsc::{CLEAR_COLOR, FRAME_TIME};
use crate::client::rsc::CLEAR_COLOR;
use nalgebra::Vector2;
use smaa::{SmaaMode, SmaaTarget};
use std::time::{Duration, Instant};
use voxel::VoxelPipeline;
use winit::dpi::PhysicalSize;
@@ -23,9 +22,6 @@ pub struct Renderer<'a> {
voxel_pipeline: VoxelPipeline,
smaa_target: SmaaTarget,
camera: Camera,
frame_time: Duration,
target: Instant,
}
impl<'a> Renderer<'a> {
@@ -102,8 +98,6 @@ impl<'a> Renderer<'a> {
config,
queue,
smaa_target,
frame_time: FRAME_TIME,
target: Instant::now(),
}
}

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

@@ -1,108 +0,0 @@
use crate::client::camera::Camera;
use super::{voxel::VoxelColor, Renderer};
use nalgebra::{Rotation3, Vector3};
use std::{
sync::{
mpsc::{channel, Receiver, Sender},
Arc,
},
thread::JoinHandle,
time::Instant,
};
use winit::{dpi::PhysicalSize, window::Window};
#[derive(Debug, Clone)]
pub enum RenderMessage {
Resize(PhysicalSize<u32>),
Draw,
CreateVoxelGrid(CreateVoxelGrid),
ViewUpdate(Camera),
Exit,
}
#[derive(Debug, Clone)]
pub struct CreateVoxelGrid {
pub pos: Vector3<f32>,
pub orientation: Rotation3<f32>,
pub dimensions: Vector3<usize>,
pub grid: Vec<VoxelColor>,
}
impl Renderer<'_> {
pub fn spawn(window: Arc<Window>) -> (RendererChannel, JoinHandle<()>) {
let (s, mut r) = channel();
let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::PRIMARY,
..Default::default()
});
let surface = instance
.create_surface(window)
.expect("Could not create window surface!");
(
RendererChannel(s),
std::thread::spawn(move || {
Self::new(instance, surface, size).start(&mut r);
}),
)
}
pub fn start(&mut self, reciever: &mut Receiver<RenderMessage>) {
let mut new_camera = false;
'main: loop {
let now = Instant::now();
for msg in reciever.try_iter() {
match msg {
RenderMessage::CreateVoxelGrid(desc) => {
self.voxel_pipeline.add_group(
&self.device,
&mut self.encoder,
&mut self.staging_belt,
desc,
);
}
RenderMessage::Draw => {
self.draw();
}
RenderMessage::Resize(size) => {
self.resize(size);
}
RenderMessage::Exit => {
break 'main;
}
RenderMessage::ViewUpdate(camera) => {
new_camera = true;
self.camera = camera;
}
}
}
if now >= self.target {
self.target = now + self.frame_time;
if new_camera {
self.voxel_pipeline.update_view(
&self.device,
&mut self.encoder,
&mut self.staging_belt,
self.size,
&self.camera,
);
new_camera = false;
}
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");
}
}

38
src/client/render/voxel/mod.rs
View File

@@ -4,11 +4,15 @@ mod group;
mod light;
mod view;
use std::collections::HashMap;
use bevy_ecs::entity::Entity;
pub use color::*;
use light::GlobalLight;
use nalgebra::{Projective3, Transform3, Translation3, Vector2, Vector3};
use super::UpdateGridTransform;
use crate::client::{
camera::Camera,
render::{
@@ -16,6 +20,7 @@ use crate::client::{
CreateVoxelGrid,
},
};
use {group::VoxelGroup, view::View};
pub struct VoxelPipeline {
@@ -26,6 +31,7 @@ pub struct VoxelPipeline {
voxel_groups: Storage<VoxelGroup>,
voxels: Storage<VoxelColor>,
global_lights: Storage<GlobalLight>,
id_map: HashMap<Entity, (usize, VoxelGroup)>,
}
impl VoxelPipeline {
@@ -123,6 +129,7 @@ impl VoxelPipeline {
voxels,
voxel_groups,
global_lights,
id_map: HashMap::new(),
}
}
@@ -132,6 +139,7 @@ impl VoxelPipeline {
encoder: &mut wgpu::CommandEncoder,
belt: &mut wgpu::util::StagingBelt,
CreateVoxelGrid {
id,
pos,
orientation,
dimensions,
@@ -139,6 +147,7 @@ impl VoxelPipeline {
}: CreateVoxelGrid,
) {
let offset = self.voxels.len();
let updates = [ArrBufUpdate {
offset,
data: &grid,
@@ -160,10 +169,13 @@ impl VoxelPipeline {
offset: self.voxel_groups.len(),
data: &[group],
}];
let size = self.voxel_groups.len() + 1;
let i = self.voxel_groups.len();
let size = i + 1;
self.voxel_groups
.update(device, encoder, belt, size, &updates);
self.id_map.insert(id, (i, group));
self.bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.bind_group_layout,
entries: &[
@@ -176,6 +188,30 @@ impl VoxelPipeline {
});
}
pub fn update_transform(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
belt: &mut wgpu::util::StagingBelt,
update: UpdateGridTransform,
) {
if let Some((i, group)) = self.id_map.get_mut(&update.id) {
let proj = Projective3::identity()
* Translation3::from(update.pos)
* update.orientation
* Translation3::from(-group.dimensions.cast() / 2.0);
group.transform = proj;
group.transform_inv = proj.inverse();
let updates = [ArrBufUpdate {
offset: *i,
data: &[*group],
}];
let size = self.voxel_groups.len();
self.voxel_groups
.update(device, encoder, belt, size, &updates);
}
}
pub fn update_view(
&mut self,
device: &wgpu::Device,