310 lines
8.1 KiB
Rust
310 lines
8.1 KiB
Rust
use anyhow::Result;
|
|
use bytemuck;
|
|
use galactica_system::{data::ShipState, phys::PhysSimShipHandle};
|
|
use glyphon::Resolution;
|
|
use nalgebra::Point2;
|
|
use std::iter;
|
|
use wgpu;
|
|
|
|
use crate::{globaluniform::GlobalDataContent, vertexbuffer::consts::SPRITE_INDICES, RenderInput};
|
|
|
|
impl<'a> super::GPUState {
|
|
/// Render routines while player is flying
|
|
fn render_flying(&'a mut self, input: &RenderInput) -> Result<()> {
|
|
let output = self.surface.get_current_texture()?;
|
|
let view = output.texture.create_view(&Default::default());
|
|
|
|
let mut encoder = self
|
|
.device
|
|
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
|
label: Some("render encoder"),
|
|
});
|
|
|
|
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
label: Some("render pass"),
|
|
|
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
|
view: &view,
|
|
resolve_target: None,
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(wgpu::Color {
|
|
r: 0.0,
|
|
g: 0.0,
|
|
b: 0.0,
|
|
a: 1.0,
|
|
}),
|
|
store: wgpu::StoreOp::Store,
|
|
},
|
|
})],
|
|
depth_stencil_attachment: None,
|
|
occlusion_query_set: None,
|
|
timestamp_writes: None,
|
|
});
|
|
|
|
// Create sprite instances
|
|
|
|
// Game coordinates (relative to camera) of ne and sw corners of screen.
|
|
// Used to skip off-screen sprites.
|
|
let clip_ne = Point2::new(-self.state.window_aspect, 1.0) * input.camera_zoom;
|
|
let clip_sw = Point2::new(self.state.window_aspect, -1.0) * input.camera_zoom;
|
|
|
|
// Order matters, it determines what is drawn on top.
|
|
// The order inside ships and projectiles doesn't matter,
|
|
// but ships should always be under projectiles.
|
|
self.phys_push_system(&input, (clip_ne, clip_sw));
|
|
self.phys_push_ships(&input, (clip_ne, clip_sw));
|
|
self.phys_push_projectiles(&input, (clip_ne, clip_sw));
|
|
self.phys_push_effects(&input, (clip_ne, clip_sw));
|
|
self.ui.draw(&input, &mut self.state);
|
|
|
|
// These should match the indices in each shader,
|
|
// and should each have a corresponding bind group layout.
|
|
render_pass.set_bind_group(0, &self.texture_array.bind_group, &[]);
|
|
render_pass.set_bind_group(1, &self.state.global_uniform.bind_group, &[]);
|
|
|
|
// Starfield pipeline
|
|
self.state
|
|
.vertex_buffers
|
|
.get_starfield()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.starfield_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_starfield_counter(),
|
|
);
|
|
|
|
// Sprite pipeline
|
|
self.state
|
|
.vertex_buffers
|
|
.get_object()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.object_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_object_counter(),
|
|
);
|
|
|
|
// Ui pipeline
|
|
self.state
|
|
.vertex_buffers
|
|
.get_ui()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.ui_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_ui_counter(),
|
|
);
|
|
|
|
// Radial progress bars
|
|
// TODO: do we need to do this every time?
|
|
self.state
|
|
.vertex_buffers
|
|
.get_radialbar()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.radialbar_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_radialbar_counter(),
|
|
);
|
|
|
|
let textareas = self.ui.get_textareas(input, &self.state);
|
|
self.state
|
|
.text_renderer
|
|
.prepare(
|
|
&self.device,
|
|
&self.state.queue,
|
|
&mut self.state.text_font_system,
|
|
&mut self.state.text_atlas,
|
|
Resolution {
|
|
width: self.state.window_size.width,
|
|
height: self.state.window_size.height,
|
|
},
|
|
textareas,
|
|
&mut self.state.text_cache,
|
|
)
|
|
.unwrap();
|
|
|
|
self.state
|
|
.text_renderer
|
|
.render(&self.state.text_atlas, &mut render_pass)
|
|
.unwrap();
|
|
|
|
// begin_render_pass borrows encoder mutably,
|
|
// so we need to drop it before calling finish.
|
|
drop(render_pass);
|
|
|
|
self.state.queue.submit(iter::once(encoder.finish()));
|
|
output.present();
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
/// Render routines while player is landed
|
|
fn render_landed(&'a mut self, input: &RenderInput) -> Result<()> {
|
|
let output = self.surface.get_current_texture()?;
|
|
let view = output.texture.create_view(&Default::default());
|
|
|
|
let mut encoder = self
|
|
.device
|
|
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
|
label: Some("render encoder"),
|
|
});
|
|
|
|
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
label: Some("render pass"),
|
|
|
|
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
|
view: &view,
|
|
resolve_target: None,
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(wgpu::Color {
|
|
r: 0.0,
|
|
g: 0.0,
|
|
b: 0.0,
|
|
a: 1.0,
|
|
}),
|
|
store: wgpu::StoreOp::Store,
|
|
},
|
|
})],
|
|
depth_stencil_attachment: None,
|
|
occlusion_query_set: None,
|
|
timestamp_writes: None,
|
|
});
|
|
|
|
// Create sprite instances
|
|
self.ui.draw(&input, &mut self.state);
|
|
|
|
// These should match the indices in each shader,
|
|
// and should each have a corresponding bind group layout.
|
|
render_pass.set_bind_group(0, &self.texture_array.bind_group, &[]);
|
|
render_pass.set_bind_group(1, &self.state.global_uniform.bind_group, &[]);
|
|
|
|
// Starfield pipeline
|
|
self.state
|
|
.vertex_buffers
|
|
.get_starfield()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.starfield_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_starfield_counter(),
|
|
);
|
|
|
|
// Ui pipeline
|
|
self.state
|
|
.vertex_buffers
|
|
.get_ui()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.ui_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_ui_counter(),
|
|
);
|
|
|
|
// Radial progress bars
|
|
self.state
|
|
.vertex_buffers
|
|
.get_radialbar()
|
|
.set_in_pass(&mut render_pass);
|
|
render_pass.set_pipeline(&self.radialbar_pipeline);
|
|
render_pass.draw_indexed(
|
|
0..SPRITE_INDICES.len() as u32,
|
|
0,
|
|
0..self.state.get_radialbar_counter(),
|
|
);
|
|
|
|
let textareas = self.ui.get_textareas(input, &self.state);
|
|
self.state
|
|
.text_renderer
|
|
.prepare(
|
|
&self.device,
|
|
&self.state.queue,
|
|
&mut self.state.text_font_system,
|
|
&mut self.state.text_atlas,
|
|
Resolution {
|
|
width: self.state.window_size.width,
|
|
height: self.state.window_size.height,
|
|
},
|
|
textareas,
|
|
&mut self.state.text_cache,
|
|
)
|
|
.unwrap();
|
|
|
|
self.state
|
|
.text_renderer
|
|
.render(&self.state.text_atlas, &mut render_pass)
|
|
.unwrap();
|
|
|
|
// begin_render_pass borrows encoder mutably,
|
|
// so we need to drop it before calling finish.
|
|
drop(render_pass);
|
|
|
|
self.state.queue.submit(iter::once(encoder.finish()));
|
|
output.present();
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
/// Main render function. Draws sprites on a window.
|
|
pub fn render(&mut self, input: RenderInput) -> Result<(), wgpu::SurfaceError> {
|
|
// Update global values
|
|
self.state.queue.write_buffer(
|
|
&self.state.global_uniform.data_buffer,
|
|
0,
|
|
bytemuck::cast_slice(&[GlobalDataContent {
|
|
camera_position: input.camera_pos.into(),
|
|
camera_zoom: [input.camera_zoom, 0.0],
|
|
camera_zoom_limits: [
|
|
input.ct.get_config().zoom_min,
|
|
input.ct.get_config().zoom_max,
|
|
],
|
|
window_size: [
|
|
self.state.window_size.width as f32,
|
|
self.state.window_size.height as f32,
|
|
],
|
|
window_scale: [self.state.window.scale_factor() as f32, 0.0],
|
|
window_aspect: [self.state.window_aspect, 0.0],
|
|
starfield_sprite: [input.ct.get_config().starfield_texture.into(), 0],
|
|
starfield_tile_size: [input.ct.get_config().starfield_size, 0.0],
|
|
starfield_size_limits: [
|
|
input.ct.get_config().starfield_min_size,
|
|
input.ct.get_config().starfield_max_size,
|
|
],
|
|
current_time: [input.current_time, 0.0],
|
|
}]),
|
|
);
|
|
|
|
self.state.frame_reset();
|
|
self.ui.update_state(&input, &mut self.state);
|
|
|
|
match input
|
|
.phys_img
|
|
.get_ship(&PhysSimShipHandle(input.player.ship.unwrap()))
|
|
.unwrap()
|
|
.ship
|
|
.get_data()
|
|
.get_state()
|
|
{
|
|
ShipState::Collapsing
|
|
| ShipState::Dead
|
|
| ShipState::Landing { .. }
|
|
| ShipState::UnLanding { .. }
|
|
| ShipState::Flying { .. } => {
|
|
self.render_flying(&input).unwrap();
|
|
}
|
|
|
|
ShipState::Landed { .. } => {
|
|
self.render_landed(&input).unwrap();
|
|
}
|
|
}
|
|
|
|
return Ok(());
|
|
}
|
|
}
|