use std::borrow::Cow;
use std::error::Error;
use std::fmt;
use std::sync::Arc;
use super::{
Color, LogicalViewport, LogicalViewportRegion, RendererFrameError, Vec2, WgpuRenderer,
is_portable_shader_source, prepared_scene_belongs_to, shader_interval_sum_range,
submit_pending_uploads,
};
const IMAGE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
mod updates;
pub(super) use updates::{batch_retained_bytes, update_image_batch_resources};
mod proof;
use proof::BatchProofCache;
#[cfg(test)]
pub(super) use proof::sprites_are_safe_for_target;
#[cfg(test)]
pub(super) use tests::verify_retained_ui_updates;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageBudget {
max_width: u32,
max_height: u32,
max_bytes: usize,
}
impl ImageBudget {
pub fn new(max_width: u32, max_height: u32, max_bytes: usize) -> Result<Self, ImageError> {
if max_width == 0 || max_height == 0 || max_bytes < 4 {
return Err(ImageError::InvalidBudget);
}
Ok(Self {
max_width,
max_height,
max_bytes,
})
}
pub const fn max_width(self) -> u32 {
self.max_width
}
pub const fn max_height(self) -> u32 {
self.max_height
}
pub const fn max_bytes(self) -> usize {
self.max_bytes
}
}
impl Default for ImageBudget {
fn default() -> Self {
Self {
max_width: 4096,
max_height: 4096,
max_bytes: 64 * 1024 * 1024,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageTexelRect {
x: u32,
y: u32,
width: u32,
height: u32,
}
impl ImageTexelRect {
pub fn new(x: u32, y: u32, width: u32, height: u32) -> Result<Self, ImageError> {
if width == 0 || height == 0 {
return Err(ImageError::ZeroDimension);
}
x.checked_add(width)
.zip(y.checked_add(height))
.ok_or(ImageError::DimensionsTooLarge)?;
Ok(Self {
x,
y,
width,
height,
})
}
pub const fn x(self) -> u32 {
self.x
}
pub const fn y(self) -> u32 {
self.y
}
pub const fn width(self) -> u32 {
self.width
}
pub const fn height(self) -> u32 {
self.height
}
pub(super) fn fits(self, width: u32, height: u32) -> bool {
self.x
.checked_add(self.width)
.is_some_and(|maximum| maximum <= width)
&& self
.y
.checked_add(self.height)
.is_some_and(|maximum| maximum <= height)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ImageSampling {
#[default]
Nearest,
Linear,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ImageBatchPlacement {
translation: crate::LogicalScreenVector,
tint: Color,
}
impl ImageBatchPlacement {
pub fn new(translation: crate::LogicalScreenVector, tint: Color) -> Result<Self, ImageError> {
let offset = translation.to_vec2();
if ![offset.x, offset.y]
.into_iter()
.all(is_portable_shader_source)
|| !tint.is_normalized()
{
return Err(ImageError::InvalidPlacement);
}
Ok(Self { translation, tint })
}
pub const fn translation(self) -> crate::LogicalScreenVector {
self.translation
}
pub const fn tint(self) -> Color {
self.tint
}
}
impl Default for ImageBatchPlacement {
fn default() -> Self {
Self {
translation: crate::LogicalScreenVector::new(0.0, 0.0),
tint: Color::WHITE,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ImageError {
ZeroDimension,
InvalidBudget,
DimensionsTooLarge,
InvalidPixelCount,
BudgetExceeded {
limit: usize,
actual: usize,
},
AllocationFailed {
requested_bytes: usize,
},
RendererMismatch,
RecoverySourceMismatch,
UpdateRegionOutOfBounds,
InvalidSprite,
InvalidPlacement,
BatchBudgetExceeded {
limit: usize,
actual: usize,
},
}
impl fmt::Display for ImageError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ZeroDimension => write!(formatter, "image dimensions must be non-zero"),
Self::InvalidBudget => write!(
formatter,
"resource budget must fit at least one image texel or batch element"
),
Self::DimensionsTooLarge => write!(formatter, "image dimensions exceed limits"),
Self::InvalidPixelCount => write!(formatter, "image RGBA byte count is invalid"),
Self::BudgetExceeded { limit, actual } => {
write!(
formatter,
"image requires {actual} bytes, over limit {limit}"
)
}
Self::AllocationFailed { requested_bytes } => write!(
formatter,
"could not reserve {requested_bytes} bytes for image storage or staging"
),
Self::RendererMismatch => write!(formatter, "image belongs to another renderer"),
Self::RecoverySourceMismatch => {
write!(
formatter,
"image is not a restored copy of the recovery source"
)
}
Self::UpdateRegionOutOfBounds => write!(formatter, "image update is out of bounds"),
Self::InvalidSprite => write!(formatter, "image sprite source or tint is invalid"),
Self::InvalidPlacement => {
write!(formatter, "image batch translation or tint is invalid")
}
Self::BatchBudgetExceeded { limit, actual } => {
write!(formatter, "image batch work {actual} exceeds limit {limit}")
}
}
}
}
impl Error for ImageError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageUploadReport {
uploaded_bytes: usize,
replaced_texture: bool,
}
impl ImageUploadReport {
pub const fn uploaded_bytes(self) -> usize {
self.uploaded_bytes
}
pub const fn replaced_texture(self) -> bool {
self.replaced_texture
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageBatchUploadReport {
uploaded_instance_bytes: usize,
replaced_instance_buffer: bool,
sprite_count: usize,
retained_capacity: usize,
gpu_capacity: usize,
retained_bytes: usize,
peak_retained_bytes: usize,
peak_gpu_bytes: usize,
}
impl ImageBatchUploadReport {
pub const fn uploaded_instance_bytes(self) -> usize {
self.uploaded_instance_bytes
}
pub const fn replaced_instance_buffer(self) -> bool {
self.replaced_instance_buffer
}
pub const fn sprite_count(self) -> usize {
self.sprite_count
}
pub const fn retained_capacity(self) -> usize {
self.retained_capacity
}
pub const fn gpu_capacity(self) -> usize {
self.gpu_capacity
}
pub const fn retained_bytes(self) -> usize {
self.retained_bytes
}
pub const fn peak_retained_bytes(self) -> usize {
self.peak_retained_bytes
}
pub const fn peak_gpu_bytes(self) -> usize {
self.peak_gpu_bytes
}
}
pub struct Image2d {
renderer_identity: Arc<()>,
pub(super) resource_identity: Arc<()>,
pub(super) recovery_identity: Arc<()>,
texture: wgpu::Texture,
pub(super) view: wgpu::TextureView,
width: u32,
height: u32,
pixels: Vec<u8>,
budget: ImageBudget,
}
impl Image2d {
pub const fn width(&self) -> u32 {
self.width
}
pub const fn height(&self) -> u32 {
self.height
}
pub const fn size(&self) -> (u32, u32) {
(self.width, self.height)
}
pub const fn budget(&self) -> ImageBudget {
self.budget
}
pub fn pixels(&self) -> &[u8] {
&self.pixels
}
pub fn recovery_memory_bytes(&self) -> usize {
self.pixels.capacity()
}
pub fn gpu_allocation_bytes(&self) -> usize {
self.pixels.len()
}
pub fn full_rect(&self) -> ImageTexelRect {
ImageTexelRect {
x: 0,
y: 0,
width: self.width,
height: self.height,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ImageSprite2d {
source: ImageTexelRect,
destination: LogicalViewportRegion,
tint: Color,
}
impl ImageSprite2d {
pub fn new(
source: ImageTexelRect,
destination: LogicalViewportRegion,
tint: Color,
) -> Result<Self, ImageError> {
let origin = destination.origin().to_vec2();
let end = origin + destination.viewport().size();
if !tint.is_normalized() || !origin.is_finite() || !end.is_finite() {
return Err(ImageError::InvalidSprite);
}
Ok(Self {
source,
destination,
tint,
})
}
pub const fn source(self) -> ImageTexelRect {
self.source
}
pub const fn destination(self) -> LogicalViewportRegion {
self.destination
}
pub const fn tint(self) -> Color {
self.tint
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageBatchBudget {
max_sprites: usize,
max_retained_bytes: usize,
}
impl ImageBatchBudget {
pub const RETAINED_BYTES_PER_SPRITE: usize =
std::mem::size_of::<ImageSprite2d>() + std::mem::size_of::<ImageInstance>();
pub const GPU_BYTES_PER_SPRITE: usize = std::mem::size_of::<ImageInstance>();
pub fn new(max_sprites: usize, max_retained_bytes: usize) -> Result<Self, ImageError> {
if max_sprites == 0 || max_retained_bytes < batch_retained_bytes(1) {
return Err(ImageError::InvalidBudget);
}
Ok(Self {
max_sprites,
max_retained_bytes,
})
}
pub const fn max_sprites(self) -> usize {
self.max_sprites
}
pub const fn max_retained_bytes(self) -> usize {
self.max_retained_bytes
}
}
impl Default for ImageBatchBudget {
fn default() -> Self {
Self {
max_sprites: 100_000,
max_retained_bytes: 16 * 1024 * 1024,
}
}
}
pub struct ImageBatch2d {
renderer_identity: Arc<()>,
image_identity: Arc<()>,
pub(super) image_recovery_identity: Arc<()>,
pub(super) instance_buffer: wgpu::Buffer,
sprites: Vec<ImageSprite2d>,
instances: Vec<ImageInstance>,
budget: ImageBatchBudget,
geometry_proof: BatchProofCache,
}
impl ImageBatch2d {
pub fn sprite_count(&self) -> usize {
self.sprites.len()
}
pub fn sprites(&self) -> &[ImageSprite2d] {
&self.sprites
}
pub const fn budget(&self) -> ImageBatchBudget {
self.budget
}
pub fn recovery_memory_bytes(&self) -> usize {
self.sprites
.capacity()
.saturating_mul(std::mem::size_of::<ImageSprite2d>())
.saturating_add(
self.instances
.capacity()
.saturating_mul(std::mem::size_of::<ImageInstance>()),
)
}
pub fn gpu_allocation_bytes(&self) -> usize {
self.instance_buffer.size() as usize
}
pub fn capacity(&self) -> usize {
self.sprites.capacity().min(self.instances.capacity())
}
pub(super) fn sprites_are_safe_for_target(
&self,
viewport_origin: Vec2,
clip_transform: [f32; 4],
) -> bool {
self.geometry_proof
.validate(&self.sprites, viewport_origin, clip_transform)
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub(super) struct ImageInstance {
pub(super) destination: [f32; 4],
pub(super) uv_rect: [f32; 4],
pub(super) tint: [f32; 4],
}
impl ImageInstance {
const ATTRIBUTES: [wgpu::VertexAttribute; 3] =
wgpu::vertex_attr_array![0 => Float32x4, 1 => Float32x4, 2 => Float32x4];
const LAYOUT: wgpu::VertexBufferLayout<'static> = wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Instance,
attributes: &Self::ATTRIBUTES,
};
}
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub(super) struct ImageUniform {
pub(super) destination: [f32; 4],
pub(super) uv_rect: [f32; 4],
pub(super) tint: [f32; 4],
pub(super) world_clip_x: [f32; 4],
pub(super) world_clip_y: [f32; 4],
pub(super) world_mode: [f32; 4],
}
pub(super) fn batch_uniform(
target: LogicalViewport,
viewport_origin: Vec2,
placement: ImageBatchPlacement,
) -> Result<ImageUniform, RendererFrameError> {
let origin = viewport_origin + placement.translation().to_vec2();
let destination = [2.0 / target.width(), -2.0 / target.height(), -1.0, 1.0];
if ![origin.x, origin.y]
.into_iter()
.chain(destination)
.all(is_portable_shader_source)
{
return Err(RendererFrameError::InvalidGeometryTransform);
}
Ok(ImageUniform {
destination,
uv_rect: [origin.x, origin.y, 0.0, 0.0],
tint: placement.tint().to_array(),
world_clip_x: [0.0; 4],
world_clip_y: [0.0; 4],
world_mode: [0.0; 4],
})
}
pub(super) struct ImageRenderer {
pub(super) pipeline: wgpu::RenderPipeline,
pub(super) batch_pipeline: wgpu::RenderPipeline,
pub(super) bind_group_layout: wgpu::BindGroupLayout,
nearest_sampler: wgpu::Sampler,
linear_sampler: wgpu::Sampler,
}
impl ImageRenderer {
pub(super) fn new(
device: &wgpu::Device,
format: wgpu::TextureFormat,
sample_count: u32,
) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sim-engine image shader"),
source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../image.wgsl"))),
});
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sim-engine image bind group layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
});
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sim-engine image pipeline layout"),
bind_group_layouts: &[Some(&bind_group_layout)],
immediate_size: 0,
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("sim-engine image pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("image_vs_main"),
compilation_options: wgpu::PipelineCompilationOptions::default(),
buffers: &[],
},
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: sample_count,
..Default::default()
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("image_fs_main"),
compilation_options: wgpu::PipelineCompilationOptions::default(),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
});
let batch_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("sim-engine image batch pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("image_batch_vs_main"),
compilation_options: wgpu::PipelineCompilationOptions::default(),
buffers: &[Some(ImageInstance::LAYOUT)],
},
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: sample_count,
..Default::default()
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("image_fs_main"),
compilation_options: wgpu::PipelineCompilationOptions::default(),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
});
let nearest_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sim-engine nearest image sampler"),
mag_filter: wgpu::FilterMode::Nearest,
min_filter: wgpu::FilterMode::Nearest,
..Default::default()
});
let linear_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sim-engine linear image sampler"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
Self {
pipeline,
batch_pipeline,
bind_group_layout,
nearest_sampler,
linear_sampler,
}
}
pub(super) fn sampler(&self, sampling: ImageSampling) -> &wgpu::Sampler {
match sampling {
ImageSampling::Nearest => &self.nearest_sampler,
ImageSampling::Linear => &self.linear_sampler,
}
}
}
impl WgpuRenderer {
pub fn create_image_rgba8(
&self,
width: u32,
height: u32,
pixels: Vec<u8>,
budget: ImageBudget,
) -> Result<Image2d, ImageError> {
create_image_resources(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
width,
height,
pixels,
budget,
)
}
pub fn create_image_rgba8_from_slice(
&self,
width: u32,
height: u32,
pixels: &[u8],
budget: ImageBudget,
) -> Result<Image2d, ImageError> {
let byte_count = validate_image_shape(
width,
height,
pixels.len(),
budget,
self.device.limits().max_texture_dimension_2d,
)?;
let mut owned = Vec::new();
owned
.try_reserve_exact(byte_count)
.map_err(|_| ImageError::AllocationFailed {
requested_bytes: byte_count,
})?;
owned.extend_from_slice(pixels);
self.create_image_rgba8(width, height, owned, budget)
}
pub fn replace_image_rgba8(
&self,
image: &mut Image2d,
width: u32,
height: u32,
pixels: Vec<u8>,
) -> Result<ImageUploadReport, ImageError> {
self.validate_image(image)?;
let replacement = self.create_image_rgba8(width, height, pixels, image.budget)?;
let uploaded_bytes = replacement.pixels.len();
*image = replacement;
Ok(ImageUploadReport {
uploaded_bytes,
replaced_texture: true,
})
}
pub fn update_image_region(
&self,
image: &mut Image2d,
region: ImageTexelRect,
pixels: &[u8],
) -> Result<ImageUploadReport, ImageError> {
self.validate_image(image)?;
let required = validate_image_region_upload(image, region, pixels.len())?;
write_image_texture(
&self.queue,
&image.texture,
region.x,
region.y,
region.width,
region.height,
pixels,
);
let source_stride = region.width as usize * 4;
let destination_stride = image.width as usize * 4;
for row in 0..region.height as usize {
let source_start = row * source_stride;
let destination_start =
(region.y as usize + row) * destination_stride + region.x as usize * 4;
image.pixels[destination_start..destination_start + source_stride]
.copy_from_slice(&pixels[source_start..source_start + source_stride]);
}
Ok(ImageUploadReport {
uploaded_bytes: required,
replaced_texture: false,
})
}
pub fn restore_image(&self, source: &Image2d) -> Result<Image2d, ImageError> {
let mut restored = self.create_image_rgba8_from_slice(
source.width,
source.height,
&source.pixels,
source.budget,
)?;
restored.recovery_identity = Arc::clone(&source.recovery_identity);
Ok(restored)
}
pub fn create_image_batch(
&self,
image: &Image2d,
sprites: Vec<ImageSprite2d>,
budget: ImageBatchBudget,
) -> Result<ImageBatch2d, ImageError> {
self.validate_image(image)?;
create_image_batch_resources(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
image,
sprites,
budget,
)
}
pub fn replace_image_batch(
&self,
image: &Image2d,
batch: &mut ImageBatch2d,
sprites: Vec<ImageSprite2d>,
) -> Result<ImageBatchUploadReport, ImageError> {
self.update_image_batch(image, batch, &sprites)
}
pub fn restore_image_batch(
&self,
image: &Image2d,
source: &ImageBatch2d,
) -> Result<ImageBatch2d, ImageError> {
self.validate_image(image)?;
restore_image_batch_resources(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
image,
source,
source.budget,
)
}
pub(super) fn validate_image(&self, image: &Image2d) -> Result<(), ImageError> {
prepared_scene_belongs_to(&self.renderer_identity, &image.renderer_identity)
.then_some(())
.ok_or(ImageError::RendererMismatch)
}
pub(super) fn validate_image_batch(
&self,
image: &Image2d,
batch: &ImageBatch2d,
) -> Result<(), ImageError> {
self.validate_image(image)?;
validate_batch_image(image, batch)
}
}
pub(super) fn restore_image_batch_resources(
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: Arc<()>,
image: &Image2d,
source: &ImageBatch2d,
budget: ImageBatchBudget,
) -> Result<ImageBatch2d, ImageError> {
if !Arc::ptr_eq(&renderer_identity, &image.renderer_identity) {
return Err(ImageError::RendererMismatch);
}
if !Arc::ptr_eq(&image.recovery_identity, &source.image_recovery_identity) {
return Err(ImageError::RecoverySourceMismatch);
}
preflight_image_batch_capacity(device, source.sprites.len(), budget)?;
let mut sprites = Vec::new();
let requested_bytes = source
.sprites
.len()
.checked_mul(std::mem::size_of::<ImageSprite2d>())
.ok_or(ImageError::DimensionsTooLarge)?;
sprites
.try_reserve_exact(source.sprites.len())
.map_err(|_| ImageError::AllocationFailed { requested_bytes })?;
sprites.extend_from_slice(&source.sprites);
create_image_batch_resources(device, queue, renderer_identity, image, sprites, budget)
}
pub(super) fn validate_batch_image(
image: &Image2d,
batch: &ImageBatch2d,
) -> Result<(), ImageError> {
if !prepared_scene_belongs_to(&image.renderer_identity, &batch.renderer_identity)
|| !prepared_scene_belongs_to(&image.resource_identity, &batch.image_identity)
{
return Err(ImageError::RendererMismatch);
}
Ok(())
}
pub(super) fn validate_image_region_upload(
image: &Image2d,
region: ImageTexelRect,
pixel_count: usize,
) -> Result<usize, ImageError> {
if !region.fits(image.width, image.height) {
return Err(ImageError::UpdateRegionOutOfBounds);
}
let required =
image_byte_count(region.width, region.height).ok_or(ImageError::DimensionsTooLarge)?;
if pixel_count != required {
return Err(ImageError::InvalidPixelCount);
}
Ok(required)
}
#[allow(clippy::too_many_arguments)]
pub(super) fn create_image_batch_resources(
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: Arc<()>,
image: &Image2d,
sprites: Vec<ImageSprite2d>,
budget: ImageBatchBudget,
) -> Result<ImageBatch2d, ImageError> {
preflight_image_batch_capacity(device, sprites.len(), budget)?;
let gpu_bytes = sprites
.len()
.max(1)
.checked_mul(std::mem::size_of::<ImageInstance>())
.ok_or(ImageError::DimensionsTooLarge)?;
if sprites.iter().any(|sprite| {
!sprite.source.fits(image.width, image.height)
|| !sprite.tint.is_normalized()
|| !logical_image_region_is_portable(sprite.destination)
}) {
return Err(ImageError::InvalidSprite);
}
let staging_bytes = sprites
.len()
.saturating_mul(std::mem::size_of::<ImageInstance>());
let sprites = compact_vec_with_byte_limit(
sprites,
budget.max_retained_bytes.saturating_sub(staging_bytes),
|actual| ImageError::BatchBudgetExceeded {
limit: budget.max_retained_bytes,
actual,
},
)?;
let mut instances = Vec::new();
instances
.try_reserve_exact(sprites.len())
.map_err(|_| ImageError::AllocationFailed {
requested_bytes: sprites
.len()
.saturating_mul(std::mem::size_of::<ImageInstance>()),
})?;
for sprite in &sprites {
let origin = sprite.destination.origin().to_vec2();
let viewport = sprite.destination.viewport();
let image_width = image.width as f32;
let image_height = image.height as f32;
let source = sprite.source;
let instance = ImageInstance {
destination: [origin.x, origin.y, viewport.width(), viewport.height()],
uv_rect: [
(source.x as f32 + 0.5) / image_width,
(source.y as f32 + 0.5) / image_height,
(source.x as f32 + source.width as f32 - 0.5) / image_width,
(source.y as f32 + source.height as f32 - 0.5) / image_height,
],
tint: sprite.tint.to_array(),
};
if !instance
.destination
.iter()
.chain(instance.uv_rect.iter())
.chain(instance.tint.iter())
.all(|value| value.is_finite())
{
return Err(ImageError::InvalidSprite);
}
instances.push(instance);
}
let retained_bytes = sprites
.capacity()
.saturating_mul(std::mem::size_of::<ImageSprite2d>())
.saturating_add(
instances
.capacity()
.saturating_mul(std::mem::size_of::<ImageInstance>()),
);
if retained_bytes > budget.max_retained_bytes {
return Err(ImageError::BatchBudgetExceeded {
limit: budget.max_retained_bytes,
actual: retained_bytes,
});
}
let instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine retained image sprite instances"),
size: gpu_bytes as wgpu::BufferAddress,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
if !instances.is_empty() {
queue.write_buffer(&instance_buffer, 0, bytemuck::cast_slice(&instances));
submit_pending_uploads(queue);
}
Ok(ImageBatch2d {
renderer_identity,
image_identity: Arc::clone(&image.resource_identity),
image_recovery_identity: Arc::clone(&image.recovery_identity),
instance_buffer,
sprites,
instances,
budget,
geometry_proof: BatchProofCache::default(),
})
}
pub(super) fn logical_image_region_is_portable(region: LogicalViewportRegion) -> bool {
let origin = region.origin().to_vec2();
let size = region.viewport().size();
let components = [origin.x, origin.y, size.x, size.y];
if !components.into_iter().all(is_portable_shader_source) {
return false;
}
if components
.into_iter()
.all(|value| value.abs() <= super::MAX_PORTABLE_SHADER_VALUE * 0.25)
{
return true;
}
shader_interval_sum_range([
(f64::from(origin.x), f64::from(origin.x)),
(0.0, f64::from(size.x)),
])
.is_some()
&& shader_interval_sum_range([
(f64::from(origin.y), f64::from(origin.y)),
(0.0, f64::from(size.y)),
])
.is_some()
}
#[allow(clippy::too_many_arguments)]
pub(super) fn create_image_resources(
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: Arc<()>,
width: u32,
height: u32,
pixels: Vec<u8>,
budget: ImageBudget,
) -> Result<Image2d, ImageError> {
validate_image_shape(
width,
height,
pixels.len(),
budget,
device.limits().max_texture_dimension_2d,
)?;
let pixels = compact_vec_with_byte_limit(pixels, budget.max_bytes, |actual| {
ImageError::BudgetExceeded {
limit: budget.max_bytes,
actual,
}
})?;
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("sim-engine retained RGBA image"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: IMAGE_FORMAT,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
});
write_image_texture(queue, &texture, 0, 0, width, height, &pixels);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
Ok(Image2d {
renderer_identity,
resource_identity: Arc::new(()),
recovery_identity: Arc::new(()),
texture,
view,
width,
height,
pixels,
budget,
})
}
fn compact_vec_with_byte_limit<T: Copy>(
values: Vec<T>,
maximum_bytes: usize,
capacity_error: impl FnOnce(usize) -> ImageError,
) -> Result<Vec<T>, ImageError> {
let element_size = std::mem::size_of::<T>();
let allocation_bytes = values.capacity().saturating_mul(element_size);
if allocation_bytes <= maximum_bytes {
return Ok(values);
}
let requested_bytes = values
.len()
.checked_mul(element_size)
.ok_or(ImageError::DimensionsTooLarge)?;
let mut compact = Vec::new();
compact
.try_reserve_exact(values.len())
.map_err(|_| ImageError::AllocationFailed { requested_bytes })?;
compact.extend_from_slice(&values);
let actual = compact.capacity().saturating_mul(element_size);
if actual > maximum_bytes {
return Err(capacity_error(actual));
}
Ok(compact)
}
pub(super) fn validate_image_shape(
width: u32,
height: u32,
pixel_count: usize,
budget: ImageBudget,
max_texture_dimension: u32,
) -> Result<usize, ImageError> {
if width == 0 || height == 0 {
return Err(ImageError::ZeroDimension);
}
if width > budget.max_width
|| height > budget.max_height
|| width > max_texture_dimension
|| height > max_texture_dimension
|| width.checked_mul(4).is_none()
{
return Err(ImageError::DimensionsTooLarge);
}
let bytes = image_byte_count(width, height).ok_or(ImageError::DimensionsTooLarge)?;
if bytes > budget.max_bytes {
return Err(ImageError::BudgetExceeded {
limit: budget.max_bytes,
actual: bytes,
});
}
if pixel_count != bytes {
return Err(ImageError::InvalidPixelCount);
}
Ok(bytes)
}
pub(super) fn preflight_image_batch_capacity(
device: &wgpu::Device,
sprite_count: usize,
budget: ImageBatchBudget,
) -> Result<(), ImageError> {
if sprite_count > budget.max_sprites {
return Err(ImageError::BatchBudgetExceeded {
limit: budget.max_sprites,
actual: sprite_count,
});
}
if u32::try_from(sprite_count).is_err() {
return Err(ImageError::DimensionsTooLarge);
}
let retained_bytes = sprite_count
.checked_mul(batch_retained_bytes(1))
.ok_or(ImageError::DimensionsTooLarge)?;
if retained_bytes > budget.max_retained_bytes {
return Err(ImageError::BatchBudgetExceeded {
limit: budget.max_retained_bytes,
actual: retained_bytes,
});
}
let gpu_bytes = sprite_count
.max(1)
.checked_mul(std::mem::size_of::<ImageInstance>())
.ok_or(ImageError::DimensionsTooLarge)?;
if gpu_bytes as u64 > device.limits().max_buffer_size {
return Err(ImageError::DimensionsTooLarge);
}
Ok(())
}
fn image_byte_count(width: u32, height: u32) -> Option<usize> {
(width as usize)
.checked_mul(height as usize)?
.checked_mul(4)
}
#[allow(clippy::too_many_arguments)]
fn write_image_texture(
queue: &wgpu::Queue,
texture: &wgpu::Texture,
x: u32,
y: u32,
width: u32,
height: u32,
pixels: &[u8],
) {
queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture,
mip_level: 0,
origin: wgpu::Origin3d { x, y, z: 0 },
aspect: wgpu::TextureAspect::All,
},
pixels,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(width * 4),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
);
submit_pending_uploads(queue);
}
#[cfg(test)]
mod tests;