Galactica/crates/render/src/gpustate/render.rs

use anyhow::Result;
use bytemuck;
use cgmath::Point2;
use galactica_util::constants::PARTICLE_SPRITE_INSTANCE_LIMIT;
use glyphon::Resolution;
use std::iter;
use wgpu;

use crate::{
	globaluniform::GlobalDataContent,
	vertexbuffer::{consts::SPRITE_INDICES, types::ParticleInstance, BufferObject},
	RenderInput,
};

impl super::GPUState {
	/// Main render function. Draws sprites on a window.
	pub fn render(&mut self, input: RenderInput) -> Result<(), wgpu::SurfaceError> {
		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,
		});

		self.state.vertex_buffers.object_counter = 0;
		self.state.vertex_buffers.ui_counter = 0;
		self.state.vertex_buffers.radialbar_counter = 0;
		// Don't reset particle counter, it's special

		let s = input.ct.get_starfield_handle();

		// 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: [s.get_index(), 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],
			}]),
		);

		// Write all new particles to GPU buffer
		for i in input.particles.iter() {
			self.state.queue.write_buffer(
				&self.state.vertex_buffers.particle.instances,
				ParticleInstance::SIZE * self.state.vertex_buffers.particle_counter,
				bytemuck::cast_slice(&[ParticleInstance {
					position: [i.pos.x, i.pos.y],
					velocity: i.velocity.into(),
					angle: i.angle.0,
					angvel: i.angvel.0,
					size: i.size,
					sprite_index: i.sprite.get_index(),
					created: input.current_time,
					expires: input.current_time + i.lifetime,
					fade: i.fade,
				}]),
			);
			self.state.vertex_buffers.particle_counter += 1;
			if self.state.vertex_buffers.particle_counter == PARTICLE_SPRITE_INSTANCE_LIMIT {
				self.state.vertex_buffers.particle_counter = 0;
			}
		}

		// 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::from((-self.state.window_aspect, 1.0)) * input.camera_zoom;
		let clip_sw = Point2::from((self.state.window_aspect, -1.0)) * input.camera_zoom;

		// TODO: sorting. We don't need to sort ships, but we do need to sort system objects by z-level
		// (which we don't yet draw)
		// that should probably be done in iter_system().

		// 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_ship(&input, (clip_ne, clip_sw));
		self.phys_push_projectile(&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
			.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.starfield.instance_count,
		);

		// Sprite pipeline
		self.state
			.vertex_buffers
			.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.vertex_buffers.object_counter as _,
		);

		// Particle pipeline
		self.state
			.vertex_buffers
			.particle
			.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&self.particle_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..PARTICLE_SPRITE_INSTANCE_LIMIT as _,
		);

		// Ui pipeline
		self.state.vertex_buffers.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.vertex_buffers.ui_counter as _,
		);

		// Radial progress bars
		// TODO: do we need to do this every time?
		self.state
			.vertex_buffers
			.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.vertex_buffers.radialbar_counter as _,
		);

		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,
				},
				self.ui.get_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 can't call finish()
		// without dropping this variable.
		drop(render_pass);

		self.state.queue.submit(iter::once(encoder.finish()));
		output.present();

		Ok(())
	}
}