use crate::math::{Color, Position, Size, Rect};
use crate::entity::{Transform, Sprite, EntityId};
use crate::{Window, EngineResult};
use wgpu::util::DeviceExt;
use bytemuck::{Pod, Zeroable};
#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
pub struct Vertex {
position: [f32; 2],
color: [f32; 4],
tex_coords: [f32; 2],
}
impl Vertex {
pub fn new(position: [f32; 2], color: [f32; 4], tex_coords: [f32; 2]) -> Self {
Self {
position,
color,
tex_coords,
}
}
fn desc() -> wgpu::VertexBufferLayout<'static> {
use std::mem;
wgpu::VertexBufferLayout {
array_stride: 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: mem::size_of::<[f32; 2]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 6]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
}
}
pub struct Renderer {
surface: wgpu::Surface<'static>,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: (u32, u32),
render_pipeline: wgpu::RenderPipeline,
vertex_buffer: wgpu::Buffer,
index_buffer: wgpu::Buffer,
vertices: Vec<Vertex>,
indices: Vec<u16>,
clear_color: Color,
}
impl Renderer {
pub fn draw_circle(&mut self, x: f32, y: f32, radius: f32, color: [f32; 4]) {
let rect = crate::math::Rect::new(x - radius, y - radius, radius * 2.0, radius * 2.0);
let c = Color::new(color[0], color[1], color[2], color[3]);
self.draw_rect(rect, c);
}
pub async fn new(window: &Window) -> EngineResult<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.window.clone())?;
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
compatible_surface: Some(&surface),
force_fallback_adapter: false,
})
.await
.ok_or("Failed to find an appropriate adapter")?;
let (device, queue) = adapter
.request_device(
&wgpu::DeviceDescriptor {
label: None,
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
memory_hints: wgpu::MemoryHints::default(),
},
None,
)
.await?;
let surface_caps = surface.get_capabilities(&adapter);
let surface_format = surface_caps
.formats
.iter()
.find(|f| f.is_srgb())
.copied()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface_format,
width: size.0,
height: size.1,
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/sprite.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: Some("vs_main"),
buffers: &[Vertex::desc()],
compilation_options: wgpu::PipelineCompilationOptions::default(),
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_main"),
targets: &[Some(wgpu::ColorTargetState {
format: config.format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
compilation_options: wgpu::PipelineCompilationOptions::default(),
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: wgpu::PolygonMode::Fill,
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
multiview: None,
cache: None,
});
let vertex_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Vertex Buffer"),
size: 1024,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let index_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Index Buffer"),
size: 1024,
usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
Ok(Self {
surface,
device,
queue,
config,
size,
render_pipeline,
vertex_buffer,
index_buffer,
vertices: Vec::new(),
indices: Vec::new(),
clear_color: Color::BLACK,
})
}
pub fn resize(&mut self, new_size: (u32, u32)) {
if new_size.0 > 0 && new_size.1 > 0 {
self.size = new_size;
self.config.width = new_size.0;
self.config.height = new_size.1;
self.surface.configure(&self.device, &self.config);
}
}
pub fn set_clear_color(&mut self, color: Color) {
self.clear_color = color;
}
pub fn begin_frame(&mut self) {
self.vertices.clear();
self.indices.clear();
}
pub fn draw_sprite(&mut self, transform: &Transform, sprite: &Sprite) {
let pos = transform.position;
let size = sprite.size * transform.scale;
let color = sprite.color.as_array();
let ndc_x = (pos.x / self.size.0 as f32) * 2.0 - 1.0;
let ndc_y = 1.0 - (pos.y / self.size.1 as f32) * 2.0;
let ndc_w = (size.x / self.size.0 as f32) * 2.0;
let ndc_h = (size.y / self.size.1 as f32) * 2.0;
println!("🎨 NDC coords: x={:.3}, y={:.3}, w={:.3}, h={:.3} (window: {}x{})",
ndc_x, ndc_y, ndc_w, ndc_h, self.size.0, self.size.1);
let vertex_start = self.vertices.len() as u16;
self.vertices.push(Vertex::new([ndc_x, ndc_y], color, [0.0, 0.0]));
self.vertices.push(Vertex::new([ndc_x + ndc_w, ndc_y], color, [1.0, 0.0]));
self.vertices.push(Vertex::new([ndc_x + ndc_w, ndc_y - ndc_h], color, [1.0, 1.0]));
self.vertices.push(Vertex::new([ndc_x, ndc_y - ndc_h], color, [0.0, 1.0]));
self.indices.extend_from_slice(&[
vertex_start, vertex_start + 1, vertex_start + 2,
vertex_start, vertex_start + 2, vertex_start + 3,
]);
}
pub fn draw_rect(&mut self, rect: Rect, color: Color) {
let transform = crate::entity::Transform::new(Position::new(rect.x, rect.y));
let sprite = Sprite::new(color, Size::new(rect.width, rect.height));
self.draw_sprite(&transform, &sprite);
}
pub fn end_frame(&mut self) -> EngineResult<()> {
if !self.vertices.is_empty() {
let vertex_data = bytemuck::cast_slice(&self.vertices);
if vertex_data.len() > self.vertex_buffer.size() as usize {
self.vertex_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: vertex_data,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
});
} else {
self.queue.write_buffer(&self.vertex_buffer, 0, vertex_data);
}
}
if !self.indices.is_empty() {
let index_data = bytemuck::cast_slice(&self.indices);
if index_data.len() > self.index_buffer.size() as usize {
self.index_buffer = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: index_data,
usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
});
} else {
self.queue.write_buffer(&self.index_buffer, 0, index_data);
}
}
let output = match self.surface.get_current_texture() {
Ok(output) => output,
Err(wgpu::SurfaceError::Lost) => {
self.surface.configure(&self.device, &self.config);
return Ok(());
}
Err(wgpu::SurfaceError::OutOfMemory) => {
return Err("WGPU out of memory".into());
}
Err(e) => {
eprintln!("Surface error: {:?}", e);
return Ok(());
}
};
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 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: self.clear_color.r as f64,
g: self.clear_color.g as f64,
b: self.clear_color.b as f64,
a: self.clear_color.a as f64,
}),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
occlusion_query_set: None,
timestamp_writes: None,
});
if !self.indices.is_empty() {
render_pass.set_pipeline(&self.render_pipeline);
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..self.indices.len() as u32, 0, 0..1);
}
}
self.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
}
pub fn draw_entities(&mut self, entities: Vec<(EntityId, &Transform, &Sprite)>) {
println!("🎨 Renderer: Drawing {} entities", entities.len());
self.draw_test_rectangle();
for (id, transform, sprite) in entities {
println!("🎨 Drawing entity {}: pos({}, {}), size({}, {}), color({}, {}, {}, {})",
id, transform.position.x, transform.position.y,
sprite.size.x, sprite.size.y,
sprite.color.r, sprite.color.g, sprite.color.b, sprite.color.a);
self.draw_sprite(transform, sprite);
}
}
fn draw_test_rectangle(&mut self) {
let color = [0.0, 1.0, 0.0, 1.0];
let vertex_start = self.vertices.len() as u16;
let left = -0.2;
let right = 0.2;
let top = 0.2;
let bottom = -0.2;
self.vertices.push(Vertex::new([left, top], color, [0.0, 0.0]));
self.vertices.push(Vertex::new([right, top], color, [1.0, 0.0]));
self.vertices.push(Vertex::new([right, bottom], color, [1.0, 1.0]));
self.vertices.push(Vertex::new([left, bottom], color, [0.0, 1.0]));
self.indices.extend_from_slice(&[
vertex_start, vertex_start + 1, vertex_start + 2,
vertex_start, vertex_start + 2, vertex_start + 3,
]);
println!("🎨 Added test rectangle: vertices={}, indices={}", self.vertices.len(), self.indices.len());
}
}