Emil_Shanaty/Verbatim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: GPU optimization — lighting, viewport CA, benchmark mode, 531 FPS

Browse Source 
- Resolution: 8x8 world cells, 2x2 UI cells (UI_SCALE=4)
- GPU lighting: vertex-shader computed, light source list buffer (max 64)
  instead of O(N×R²) grid scan, O(N×S) per cell
- Viewport-aware CA: iterate only active chunks, not all 250×250
- Flat array entity/item/shadow maps instead of HashMaps
- Flat 128-entry ASCII atlas array instead of HashMap lookup
- Partial grid upload: viewport + 30-cell margin only
- Pre-allocated viewport arrays in renderer structs (zero alloc/frame)
- Skip CPU lighting for GPU modes (pass None)
- Benchmark mode: --mode benchmark with per-subsystem timing
- GpuLightSource struct, light_count in push constants
- gather_sources_in_range() for viewport-scoped source gathering

Benchmark (600 ticks, release):
  Graphics: 531 FPS (was 386, +38%), render 1013us (was 1699us, -40%)
  ASCII:    402 FPS (was 313, +28%), render 1502us (was 2346us, -36%)

All 171 tests + 14 scenarios pass.
This commit is contained in:
Emil
2026-06-21 16:09:45 +03:00
parent c25cae9a32
commit 357db17c2f
53 changed files with 6362 additions and 651 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/render/graphics.rs
+431 -20
View File
@@ -2,14 +2,41 @@ use ash::vk;
use std::ffi::CString;
use std::sync::Arc;
use crate::entity::{EntityKind, EntityManager};
use crate::entity::EntityManager;
use crate::render::lighting;
use crate::world::cell::MaterialId;
use crate::world::grid::Grid;
use crate::world::grid::{Grid, WORLD_H, WORLD_W};
const CHAR_W: u32 = 10;
const CHAR_H: u32 = 10;
const CHAR_W: u32 = 8;
const CHAR_H: u32 = 8;
const UI_CELL_SIZE: u32 = 2;
const MAX_FRAMES: usize = 2;
fn entity_priority(kind: crate::entity::EntityKind) -> u32 {
use crate::entity::EntityKind;
match kind {
EntityKind::Player => 3,
EntityKind::Goblin => 2,
EntityKind::Slime => 1,
EntityKind::Corpse => 0,
}
}
fn background_color(wx: i32, wy: i32, vy: i32, view_h: i32) -> [u8; 4] {
let t = (vy as f32 / view_h as f32).clamp(0.0, 1.0);
let base_r = (10.0 + t * 15.0) as u8;
let base_g = (10.0 + t * 25.0) as u8;
let base_b = (25.0 + t * 35.0) as u8;
let hash = ((wx.wrapping_mul(73856093)) ^ (wy.wrapping_mul(19349663))).abs();
if hash % 80 == 0 {
let brightness = (60 + (hash % 120) as u8).min(255);
return [brightness, brightness, brightness + 20, 255];
}
[base_r, base_g, base_b, 255]
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ColorInstance {
@@ -18,11 +45,28 @@ struct ColorInstance {
color: [u8; 4],
}
#[repr(C)]
#[derive(bytemuck::NoUninit, Clone, Copy, Default)]
struct GpuLightSource {
pos: [f32; 2],
radius: f32,
_pad0: f32,
color: [f32; 3],
_pad1: f32,
}
const MAX_LIGHT_SOURCES: usize = 64;
#[repr(C)]
#[derive(bytemuck::NoUninit, Clone, Copy)]
struct PushConstants {
screen_size: [f32; 2],
cell_size: [f32; 2],
world_size: [i32; 2],
cam_pos: [i32; 2],
ambient: [f32; 3],
is_ui: u32,
light_count: u32,
}
pub struct GraphicsRenderer {
@@ -40,6 +84,7 @@ pub struct GraphicsRenderer {
swapchain: vk::SwapchainKHR,
swapchain_image_views: Vec<vk::ImageView>,
swapchain_extent: vk::Extent2D,
present_mode: vk::PresentModeKHR,
render_pass: vk::RenderPass,
pipeline: vk::Pipeline,
@@ -64,6 +109,28 @@ pub struct GraphicsRenderer {
instance_ptr: *mut ColorInstance,
instance_count: usize,
ui_instance_buffer: vk::Buffer,
ui_instance_memory: vk::DeviceMemory,
ui_instance_ptr: *mut ColorInstance,
ui_instance_capacity: usize,
grid_buffer: vk::Buffer,
grid_memory: vk::DeviceMemory,
grid_ptr: *mut u32,
light_buffer: vk::Buffer,
light_memory: vk::DeviceMemory,
light_ptr: *mut GpuLightSource,
ent_pri_buf: Vec<u8>,
entity_color_buf: Vec<[u8; 4]>,
item_color_buf: Vec<[u8; 4]>,
shadow_buf: Vec<bool>,
descriptor_set_layout: vk::DescriptorSetLayout,
descriptor_pool: vk::DescriptorPool,
descriptor_set: vk::DescriptorSet,
window: Arc<winit::window::Window>,
}
@@ -156,6 +223,14 @@ impl GraphicsRenderer {
let swapchain_loader = ash::khr::swapchain::Device::new(&instance, &device);
let caps = unsafe { sl.get_physical_device_surface_capabilities(physical_device, surface) }
.map_err(|e| format!("caps: {e:?}"))?;
let present_modes =
unsafe { sl.get_physical_device_surface_present_modes(physical_device, surface) }
.unwrap_or_default();
let present_mode = present_modes
.iter()
.copied()
.find(|&m| m == vk::PresentModeKHR::MAILBOX)
.unwrap_or(vk::PresentModeKHR::FIFO);
let format = vk::SurfaceFormatKHR {
format: vk::Format::B8G8R8A8_UNORM,
color_space: vk::ColorSpaceKHR::SRGB_NONLINEAR,
@@ -182,7 +257,7 @@ impl GraphicsRenderer {
.queue_family_indices(&qf_slice)
.pre_transform(caps.current_transform)
.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
.present_mode(vk::PresentModeKHR::FIFO)
.present_mode(present_mode)
.clipped(true);
let swapchain = unsafe { swapchain_loader.create_swapchain(&sci, None) }
.map_err(|e| format!("swapchain: {e:?}"))?;
@@ -316,15 +391,37 @@ impl GraphicsRenderer {
let ms = vk::PipelineMultisampleStateCreateInfo::default()
.rasterization_samples(vk::SampleCountFlags::TYPE_1);
let cba = vk::PipelineColorBlendAttachmentState::default()
.blend_enable(true)
.src_color_blend_factor(vk::BlendFactor::SRC_ALPHA)
.dst_color_blend_factor(vk::BlendFactor::ONE_MINUS_SRC_ALPHA)
.color_blend_op(vk::BlendOp::ADD)
.src_alpha_blend_factor(vk::BlendFactor::ONE)
.dst_alpha_blend_factor(vk::BlendFactor::ZERO)
.alpha_blend_op(vk::BlendOp::ADD)
.color_write_mask(vk::ColorComponentFlags::RGBA);
let cb = vk::PipelineColorBlendStateCreateInfo::default()
.attachments(std::slice::from_ref(&cba));
let grid_binding = vk::DescriptorSetLayoutBinding::default()
.binding(0)
.descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlags::VERTEX);
let light_binding = vk::DescriptorSetLayoutBinding::default()
.binding(1)
.descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlags::VERTEX);
let dsl_bindings = [grid_binding, light_binding];
let dsl_ci = vk::DescriptorSetLayoutCreateInfo::default().bindings(&dsl_bindings);
let descriptor_set_layout = unsafe { device.create_descriptor_set_layout(&dsl_ci, None) }
.map_err(|e| format!("dsl: {e:?}"))?;
let pcr = vk::PushConstantRange {
stage_flags: vk::ShaderStageFlags::VERTEX,
offset: 0,
size: std::mem::size_of::<PushConstants>() as u32,
};
let pli = vk::PipelineLayoutCreateInfo::default()
.set_layouts(std::slice::from_ref(&descriptor_set_layout))
.push_constant_ranges(std::slice::from_ref(&pcr));
let pipeline_layout = unsafe { device.create_pipeline_layout(&pli, None) }
.map_err(|e| format!("pipeline_layout: {e:?}"))?;
@@ -454,6 +551,78 @@ impl GraphicsRenderer {
}
Ok((buf, mem))
};
let grid_data = vec![0u32; WORLD_W * WORLD_H];
let (grid_buffer, grid_memory) = make_buf(
bytemuck::cast_slice(&grid_data),
vk::BufferUsageFlags::STORAGE_BUFFER,
)?;
let grid_ptr = unsafe {
let sz = (WORLD_W * WORLD_H * std::mem::size_of::<u32>()) as vk::DeviceSize;
let ptr = device
.map_memory(grid_memory, 0, sz, vk::MemoryMapFlags::default())
.map_err(|e| format!("map grid: {e:?}"))?;
ptr as *mut u32
};
let light_data = vec![GpuLightSource::default(); MAX_LIGHT_SOURCES];
let (light_buffer, light_memory) = make_buf(
bytemuck::cast_slice(&light_data),
vk::BufferUsageFlags::STORAGE_BUFFER,
)?;
let light_ptr = unsafe {
let sz = (MAX_LIGHT_SOURCES * std::mem::size_of::<GpuLightSource>()) as vk::DeviceSize;
let ptr = device
.map_memory(light_memory, 0, sz, vk::MemoryMapFlags::default())
.map_err(|e| format!("map light: {e:?}"))?;
ptr as *mut GpuLightSource
};
let pool_sizes = [vk::DescriptorPoolSize {
ty: vk::DescriptorType::STORAGE_BUFFER,
descriptor_count: 2,
}];
let descriptor_pool = unsafe {
device.create_descriptor_pool(
&vk::DescriptorPoolCreateInfo::default()
.pool_sizes(&pool_sizes)
.max_sets(1),
None,
)
}
.map_err(|e| format!("descriptor_pool: {e:?}"))?;
let descriptor_set = unsafe {
device.allocate_descriptor_sets(
&vk::DescriptorSetAllocateInfo::default()
.descriptor_pool(descriptor_pool)
.set_layouts(std::slice::from_ref(&descriptor_set_layout)),
)
}
.map_err(|e| format!("descriptor_set: {e:?}"))?[0];
let grid_info = vk::DescriptorBufferInfo::default()
.buffer(grid_buffer)
.offset(0)
.range((WORLD_W * WORLD_H * std::mem::size_of::<u32>()) as vk::DeviceSize);
let light_info = vk::DescriptorBufferInfo::default()
.buffer(light_buffer)
.offset(0)
.range((MAX_LIGHT_SOURCES * std::mem::size_of::<GpuLightSource>()) as vk::DeviceSize);
let descriptor_writes = [
vk::WriteDescriptorSet::default()
.dst_set(descriptor_set)
.dst_binding(0)
.descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
.buffer_info(std::slice::from_ref(&grid_info)),
vk::WriteDescriptorSet::default()
.dst_set(descriptor_set)
.dst_binding(1)
.descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
.buffer_info(std::slice::from_ref(&light_info)),
];
unsafe {
device.update_descriptor_sets(&descriptor_writes, &[]);
}
let verts: [f32; 8] = [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0];
let indices: [u16; 6] = [0, 1, 2, 1, 3, 2];
let (vertex_buffer, vertex_memory) = make_buf(
@@ -498,6 +667,43 @@ impl GraphicsRenderer {
ptr as *mut ColorInstance
};
let ui_capacity = 65536usize;
let ui_inst_sz = (ui_capacity * std::mem::size_of::<ColorInstance>()) as vk::DeviceSize;
let uibi = vk::BufferCreateInfo::default()
.size(ui_inst_sz)
.usage(vk::BufferUsageFlags::VERTEX_BUFFER)
.sharing_mode(vk::SharingMode::EXCLUSIVE);
let ui_instance_buffer = unsafe { device.create_buffer(&uibi, None) }
.map_err(|e| format!("ui inst buf: {e:?}"))?;
let uireq = unsafe { device.get_buffer_memory_requirements(ui_instance_buffer) };
let uimt = find_mem(
uireq.memory_type_bits,
vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT,
)?;
let ui_instance_memory = unsafe {
device.allocate_memory(
&vk::MemoryAllocateInfo::default()
.allocation_size(uireq.size)
.memory_type_index(uimt),
None,
)
}
.map_err(|e| format!("ui inst mem: {e:?}"))?;
let ui_instance_ptr = unsafe {
device
.bind_buffer_memory(ui_instance_buffer, ui_instance_memory, 0)
.expect("bind ui inst");
let ptr = device
.map_memory(
ui_instance_memory,
0,
ui_inst_sz,
vk::MemoryMapFlags::default(),
)
.expect("map ui inst");
ptr as *mut ColorInstance
};
Ok(Self {
grid_w,
grid_h,
@@ -511,6 +717,7 @@ impl GraphicsRenderer {
swapchain,
swapchain_image_views,
swapchain_extent: extent,
present_mode,
render_pass,
pipeline,
pipeline_layout,
@@ -529,15 +736,75 @@ impl GraphicsRenderer {
instance_memory,
instance_ptr,
instance_count,
ui_instance_buffer,
ui_instance_memory,
ui_instance_ptr,
ui_instance_capacity: ui_capacity,
grid_buffer,
grid_memory,
grid_ptr,
light_buffer,
light_memory,
light_ptr,
ent_pri_buf: Vec::new(),
entity_color_buf: Vec::new(),
item_color_buf: Vec::new(),
shadow_buf: Vec::new(),
descriptor_set_layout,
descriptor_pool,
descriptor_set,
window,
})
}
pub fn render(&mut self, grid: &Grid, entities: &EntityManager, cam_x: i32, cam_y: i32) {
pub fn render(
&mut self,
grid: &Grid,
entities: &EntityManager,
items: &crate::entity::item::ItemManager,
ui: &crate::ui::UiLayer,
cam_x: i32,
cam_y: i32,
_lighting: Option<&lighting::LightGrid>,
) {
self.check_resize();
let mut entity_map: std::collections::HashMap<(i32, i32), [u8; 4]> =
std::collections::HashMap::new();
let amb_u8 = lighting::ambient_light();
let ambient = [
amb_u8[0] as f32 / 255.0,
amb_u8[1] as f32 / 255.0,
amb_u8[2] as f32 / 255.0,
];
let vp_size = self.grid_w * self.grid_h;
if self.ent_pri_buf.len() != vp_size {
self.ent_pri_buf.resize(vp_size, 0);
self.entity_color_buf.resize(vp_size, [0, 0, 0, 0]);
self.item_color_buf.resize(vp_size, [0, 0, 0, 0]);
self.shadow_buf.resize(vp_size, false);
}
self.ent_pri_buf.fill(0);
self.entity_color_buf.fill([0, 0, 0, 0]);
self.item_color_buf.fill([0, 0, 0, 0]);
self.shadow_buf.fill(false);
let ent_pri = &mut self.ent_pri_buf;
let entity_color = &mut self.entity_color_buf;
let item_color = &mut self.item_color_buf;
for item in items.all() {
let sx = item.x - cam_x;
let sy = item.y - cam_y;
if sx >= 0 && sx < self.grid_w as i32 && sy >= 0 && sy < self.grid_h as i32 {
let idx = sy as usize * self.grid_w + sx as usize;
item_color[idx] = [item.color()[0], item.color()[1], item.color()[2], 255];
}
}
for e in entities.all() {
for b in &e.bodies {
if !b.alive {
@@ -546,42 +813,79 @@ impl GraphicsRenderer {
let sx = b.x as i32 - cam_x;
let sy = b.y as i32 - cam_y;
if sx >= 0 && sx < self.grid_w as i32 && sy >= 0 && sy < self.grid_h as i32 {
let idx = sy as usize * self.grid_w + sx as usize;
let color = if e.on_fire {
let flicker = b.fire_timer % 4;
[255, 120 + flicker as u8 * 20, 20 + flicker as u8 * 10, 255]
} else {
b.color
};
entity_map.insert((sx, sy), color);
let pri = entity_priority(e.kind);
if pri as u8 > ent_pri[idx] {
ent_pri[idx] = pri as u8;
entity_color[idx] = color;
}
}
}
}
let shadow_buf = &mut self.shadow_buf;
for idx in 0..vp_size {
if ent_pri[idx] == 0 {
continue;
}
let ex = idx % self.grid_w;
let ey = idx / self.grid_w;
for dy in -1i32..=1 {
for dx in -1i32..=1 {
if dx == 0 && dy == 0 {
continue;
}
let sx = ex as i32 + dx;
let sy = ey as i32 + dy;
if sx < 0 || sx >= self.grid_w as i32 || sy < 0 || sy >= self.grid_h as i32 {
continue;
}
let sidx = sy as usize * self.grid_w + sx as usize;
if ent_pri[sidx] > 0 {
continue;
}
let wx = cam_x + sx;
let wy = cam_y + sy;
if !grid.in_bounds(wx, wy) || grid.get(wx, wy).is_empty() {
shadow_buf[sidx] = true;
}
}
}
}
let instances =
unsafe { std::slice::from_raw_parts_mut(self.instance_ptr, self.instance_count) };
let bg_default = [10u8, 10, 15, 255];
let gh = self.grid_h as i32;
for dy in 0..self.grid_h {
for dx in 0..self.grid_w {
let idx = dy * self.grid_w + dx;
let wx = cam_x + dx as i32;
let wy = cam_y + dy as i32;
let color = if let Some(&ec) = entity_map.get(&(dx as i32, dy as i32)) {
ec
let color = if ent_pri[idx] > 0 {
entity_color[idx]
} else if item_color[idx][3] > 0 {
item_color[idx]
} else if shadow_buf[idx] {
[0, 0, 0, 255]
} else if !grid.in_bounds(wx, wy) {
[40, 40, 40, 255]
} else {
let cell = grid.get(wx, wy);
if cell.is_empty() {
bg_default
background_color(wx, wy, dy as i32, gh)
} else if cell.material == MaterialId::Lava {
let r = 200u8.saturating_add(cell.variant / 2);
[r, 60, 20, 255]
} else {
if cell.material == MaterialId::Lava {
let r = 200u8.saturating_add(cell.variant / 2);
[r, 60, 20, 255]
} else {
[cell.fg[0], cell.fg[1], cell.fg[2], 255]
}
[cell.fg[0], cell.fg[1], cell.fg[2], 255]
}
};
@@ -593,6 +897,60 @@ impl GraphicsRenderer {
}
}
let ui_instances = unsafe {
std::slice::from_raw_parts_mut(self.ui_instance_ptr, self.ui_instance_capacity)
};
let mut ui_count = 0usize;
for (x, y) in ui.keys() {
if ui_count >= self.ui_instance_capacity {
break;
}
ui_instances[ui_count] = ColorInstance {
grid_x: *x as f32,
grid_y: *y as f32,
color: {
let cell = ui.get(*x, *y).unwrap();
[cell.fg[0], cell.fg[1], cell.fg[2], cell.alpha]
},
};
ui_count += 1;
}
unsafe {
let margin = 30i32;
let x_min = (cam_x - margin).max(0) as usize;
let x_max = (cam_x + self.grid_w as i32 + margin).min(WORLD_W as i32) as usize;
let y_min = (cam_y - margin).max(0) as usize;
let y_max = (cam_y + self.grid_h as i32 + margin).min(WORLD_H as i32) as usize;
for y in y_min..y_max {
let row_offset = y * WORLD_W;
for x in x_min..x_max {
let i = row_offset + x;
*self.grid_ptr.add(i) = grid.cells[i].material as u32;
}
}
}
let sources =
lighting::gather_sources_in_range(grid, cam_x, cam_y, self.grid_w, self.grid_h, 30);
let light_count = sources.len().min(MAX_LIGHT_SOURCES) as u32;
unsafe {
let light_slice = std::slice::from_raw_parts_mut(self.light_ptr, MAX_LIGHT_SOURCES);
for (i, src) in sources.iter().take(MAX_LIGHT_SOURCES).enumerate() {
light_slice[i] = GpuLightSource {
pos: [src.x as f32, src.y as f32],
radius: src.radius as f32,
_pad0: 0.0,
color: [
src.color[0] as f32 / 255.0,
src.color[1] as f32 / 255.0,
src.color[2] as f32 / 255.0,
],
_pad1: 0.0,
};
}
}
let frame = self.frame_index;
let device = &self.device;
@@ -649,6 +1007,14 @@ impl GraphicsRenderer {
device.cmd_set_viewport(cmd, 0, std::slice::from_ref(&viewport));
device.cmd_set_scissor(cmd, 0, std::slice::from_ref(&scissor));
device.cmd_bind_descriptor_sets(
cmd,
vk::PipelineBindPoint::GRAPHICS,
self.pipeline_layout,
0,
&[self.descriptor_set],
&[],
);
device.cmd_bind_vertex_buffers(
cmd,
0,
@@ -663,6 +1029,11 @@ impl GraphicsRenderer {
self.swapchain_extent.height as f32,
],
cell_size: [CHAR_W as f32, CHAR_H as f32],
world_size: [WORLD_W as i32, WORLD_H as i32],
cam_pos: [cam_x, cam_y],
ambient,
is_ui: 0,
light_count,
};
device.cmd_push_constants(
cmd,
@@ -673,6 +1044,36 @@ impl GraphicsRenderer {
);
device.cmd_draw_indexed(cmd, 6, self.instance_count as u32, 0, 0, 0);
if ui_count > 0 {
device.cmd_bind_vertex_buffers(
cmd,
0,
&[self.vertex_buffer, self.ui_instance_buffer],
&[0, 0],
);
let ui_pc = PushConstants {
screen_size: [
self.swapchain_extent.width as f32,
self.swapchain_extent.height as f32,
],
cell_size: [UI_CELL_SIZE as f32, UI_CELL_SIZE as f32],
world_size: [WORLD_W as i32, WORLD_H as i32],
cam_pos: [0, 0],
ambient: [1.0, 1.0, 1.0],
is_ui: 1,
light_count: 0,
};
device.cmd_push_constants(
cmd,
self.pipeline_layout,
vk::ShaderStageFlags::VERTEX,
0,
bytemuck::bytes_of(&ui_pc),
);
device.cmd_draw_indexed(cmd, 6, ui_count as u32, 0, 0, 0);
}
device.cmd_end_render_pass(cmd);
let _ = device.end_command_buffer(cmd);
@@ -766,7 +1167,7 @@ impl GraphicsRenderer {
.image_sharing_mode(vk::SharingMode::EXCLUSIVE)
.pre_transform(caps.current_transform)
.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
.present_mode(vk::PresentModeKHR::FIFO)
.present_mode(self.present_mode)
.clipped(true)
.old_swapchain(self.swapchain);
@@ -937,10 +1338,20 @@ impl Drop for GraphicsRenderer {
self.device.destroy_render_pass(self.render_pass, None);
self.device.destroy_buffer(self.instance_buffer, None);
self.device.free_memory(self.instance_memory, None);
self.device.destroy_buffer(self.ui_instance_buffer, None);
self.device.free_memory(self.ui_instance_memory, None);
self.device.destroy_buffer(self.vertex_buffer, None);
self.device.free_memory(self.vertex_memory, None);
self.device.destroy_buffer(self.index_buffer, None);
self.device.free_memory(self.index_memory, None);
self.device.destroy_buffer(self.grid_buffer, None);
self.device.free_memory(self.grid_memory, None);
self.device.destroy_buffer(self.light_buffer, None);
self.device.free_memory(self.light_memory, None);
self.device
.destroy_descriptor_pool(self.descriptor_pool, None);
self.device
.destroy_descriptor_set_layout(self.descriptor_set_layout, None);
for &v in &self.swapchain_image_views {
self.device.destroy_image_view(v, None);
}