use crate::ecs::World;
use crate::math::{Color, Transform, Vec2};
use crate::ui::{UIPanel, UIProgressBar, UITransform};
use std::sync::Arc;
use wgpu::util::DeviceExt;
use winit::window::Window;
use glyphon::{FontSystem, SwashCache, TextAtlas, TextRenderer};
pub struct Renderer {
surface: wgpu::Surface<'static>,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize<u32>,
render_pipeline: wgpu::RenderPipeline,
#[allow(dead_code)]
font_system: FontSystem,
#[allow(dead_code)]
swash_cache: SwashCache,
#[allow(dead_code)]
text_atlas: TextAtlas,
#[allow(dead_code)]
text_renderer: TextRenderer,
}
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
position: [f32; 2],
color: [f32; 4],
}
impl Vertex {
fn desc() -> wgpu::VertexBufferLayout<'static> {
wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 2]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float32x4,
},
],
}
}
}
impl Renderer {
pub async fn new(window: Arc<Window>) -> Self {
let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..Default::default()
});
let surface = instance.create_surface(window).unwrap();
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
})
.await
.unwrap();
let (device, queue) = adapter
.request_device(
&wgpu::DeviceDescriptor {
label: None,
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
},
None,
)
.await
.unwrap();
let surface_caps = surface.get_capabilities(&adapter);
let surface_format = surface_caps
.formats
.iter()
.copied()
.find(|f| f.is_srgb())
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface_format,
width: size.width,
height: size.height,
present_mode: surface_caps.present_modes[0],
alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
desired_maximum_frame_latency: 2,
};
surface.configure(&device, &config);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/basic.wgsl").into()),
});
let render_pipeline_layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Render Pipeline Layout"),
bind_group_layouts: &[],
push_constant_ranges: &[],
});
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Render Pipeline"),
layout: Some(&render_pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: "vs_main",
buffers: &[Vertex::desc()],
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: "fs_main",
targets: &[Some(wgpu::ColorTargetState {
format: config.format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: Some(wgpu::Face::Back),
polygon_mode: wgpu::PolygonMode::Fill,
unclipped_depth: false,
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
multiview: None,
});
let font_system = FontSystem::new();
let swash_cache = SwashCache::new();
let mut cache = TextAtlas::new(&device, &queue, config.format);
let text_renderer = TextRenderer::new(&mut cache, &device, wgpu::MultisampleState::default(), None);
Self {
surface,
device,
queue,
config,
size,
render_pipeline,
font_system,
swash_cache,
text_atlas: cache,
text_renderer,
}
}
pub fn size(&self) -> winit::dpi::PhysicalSize<u32> {
self.size
}
pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
if new_size.width > 0 && new_size.height > 0 {
self.size = new_size;
self.config.width = new_size.width;
self.config.height = new_size.height;
self.surface.configure(&self.device, &self.config);
}
}
pub fn render(&mut self, world: &World) -> Result<(), wgpu::SurfaceError> {
let output = self.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut buffers = Vec::new();
for entity in world.entities() {
if let (Some(transform), Some(sprite)) =
(entity.get::<Transform>(), entity.get::<Sprite>())
{
let vertices = self.create_sprite_vertices(transform, sprite);
let vertex_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
let indices: &[u16] = &[0, 1, 2, 0, 2, 3];
let index_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(indices),
usage: wgpu::BufferUsages::INDEX,
});
buffers.push((vertex_buffer, index_buffer));
}
}
for entity in world.entities() {
if let (Some(ui_transform), Some(panel)) =
(entity.get::<UITransform>(), entity.get::<UIPanel>())
{
let pos = ui_transform.get_screen_position(self.size.width as f32, self.size.height as f32);
let transform = Transform::new(
pos.x + ui_transform.size.x / 2.0 - self.size.width as f32 / 2.0,
pos.y + ui_transform.size.y / 2.0 - self.size.height as f32 / 2.0
);
let sprite = Sprite {
size: ui_transform.size,
color: panel.background_color,
};
let vertices = self.create_sprite_vertices(&transform, &sprite);
let vertex_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Vertex Buffer"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
let indices: &[u16] = &[0, 1, 2, 0, 2, 3];
let index_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Index Buffer"),
contents: bytemuck::cast_slice(indices),
usage: wgpu::BufferUsages::INDEX,
});
buffers.push((vertex_buffer, index_buffer));
}
}
for entity in world.entities() {
if let (Some(ui_transform), Some(bar)) =
(entity.get::<UITransform>(), entity.get::<UIProgressBar>())
{
let pos = ui_transform.get_screen_position(self.size.width as f32, self.size.height as f32);
let bg_transform = Transform::new(
pos.x + ui_transform.size.x / 2.0 - self.size.width as f32 / 2.0,
pos.y + ui_transform.size.y / 2.0 - self.size.height as f32 / 2.0
);
let bg_sprite = Sprite {
size: ui_transform.size,
color: bar.background_color,
};
let vertices = self.create_sprite_vertices(&bg_transform, &bg_sprite);
let vertex_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Bar BG Vertex Buffer"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
let indices: &[u16] = &[0, 1, 2, 0, 2, 3];
let index_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Bar BG Index Buffer"),
contents: bytemuck::cast_slice(indices),
usage: wgpu::BufferUsages::INDEX,
});
buffers.push((vertex_buffer, index_buffer));
let fill_width = ui_transform.size.x * bar.get_fill_percentage();
if fill_width > 0.0 {
let fill_transform = Transform::new(
pos.x + fill_width / 2.0 - self.size.width as f32 / 2.0,
pos.y + ui_transform.size.y / 2.0 - self.size.height as f32 / 2.0
);
let fill_sprite = Sprite {
size: Vec2::new(fill_width, ui_transform.size.y),
color: bar.fill_color,
};
let vertices = self.create_sprite_vertices(&fill_transform, &fill_sprite);
let vertex_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Bar Fill Vertex Buffer"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
let indices: &[u16] = &[0, 1, 2, 0, 2, 3];
let index_buffer =
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("UI Bar Fill Index Buffer"),
contents: bytemuck::cast_slice(indices),
usage: wgpu::BufferUsages::INDEX,
});
buffers.push((vertex_buffer, index_buffer));
}
}
}
{
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.1,
g: 0.1,
b: 0.1,
a: 1.0,
}),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
occlusion_query_set: None,
timestamp_writes: None,
});
render_pass.set_pipeline(&self.render_pipeline);
for (vertex_buffer, index_buffer) in &buffers {
render_pass.set_vertex_buffer(0, vertex_buffer.slice(..));
render_pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..6, 0, 0..1);
}
}
self.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
}
fn create_sprite_vertices(&self, transform: &Transform, sprite: &Sprite) -> Vec<Vertex> {
let half_width = sprite.size.x / 2.0;
let half_height = sprite.size.y / 2.0;
let _aspect = self.size.width as f32 / self.size.height as f32;
let x = transform.position.x / (self.size.width as f32 / 2.0);
let y = -transform.position.y / (self.size.height as f32 / 2.0);
let w = half_width / (self.size.width as f32 / 2.0);
let h = half_height / (self.size.height as f32 / 2.0);
let color = [sprite.color.r, sprite.color.g, sprite.color.b, sprite.color.a];
vec![
Vertex {
position: [x - w, y - h],
color,
},
Vertex {
position: [x + w, y - h],
color,
},
Vertex {
position: [x + w, y + h],
color,
},
Vertex {
position: [x - w, y + h],
color,
},
]
}
}
#[derive(Clone, Debug)]
pub struct Sprite {
pub size: Vec2,
pub color: Color,
}
impl Sprite {
pub fn new(width: f32, height: f32) -> Self {
Self {
size: Vec2::new(width, height),
color: Color::WHITE,
}
}
pub fn with_color(mut self, color: Color) -> Self {
self.color = color;
self
}
}
impl crate::ecs::Component for Sprite {}