use super::*;
use crate::{
Camera3d, LogicalPixels, Mesh3d, MeshStyle3d, PhysicalPerLogical, Transform3d, Vec3,
WireframeStyle3d,
};
use std::sync::atomic::{AtomicU64, Ordering};
#[path = "mesh3d_validation.rs"]
mod validation;
use validation::validate_points_for_policy;
pub use validation::{Mesh3dSurfaceError, SurfaceRasterization3d};
#[path = "mesh3d_surface.rs"]
mod surface;
pub use surface::{Mesh3dPreflightReport, Mesh3dRenderBudget};
use surface::{SurfaceClipEdge, SurfaceClipVertex, SurfaceFrame, SurfaceObject};
#[path = "mesh3d_texture.rs"]
mod texture;
use texture::{MeshTextureRenderer, MeshUvGpu};
#[path = "mesh3d_restoration.rs"]
mod restoration;
use restoration::restore_retained_mesh;
#[path = "mesh3d_colors.rs"]
mod colors;
use crate::mesh3d::{SurfaceAlphaMode3d, SurfaceSidedness3d};
use colors::MeshColorGpu;
#[path = "mesh3d_normals.rs"]
mod normals;
use normals::MeshNormalGpu;
#[path = "mesh3d_lighting.rs"]
mod lighting;
use crate::mesh3d::{Fog3d, Lighting3d, SurfaceLighting3d};
use lighting::{SurfaceEnvironmentGpu, SurfaceLightingVertex, SurfaceTransport};
#[path = "mesh3d_surface_pipeline.rs"]
mod surface_pipeline;
use surface_pipeline::{SurfaceLayout, SurfacePipelines, create_surface_pipelines};
#[cfg(test)]
#[path = "mesh3d_lighting_tests.rs"]
mod lighting_tests;
#[path = "mesh3d_material.rs"]
mod material;
#[cfg(test)]
#[path = "mesh3d_material_tests.rs"]
mod material_tests;
#[cfg(test)]
#[path = "mesh3d_native_acceptance_tests.rs"]
mod native_acceptance_tests;
#[cfg(test)]
#[path = "mesh3d_material_resource_tests.rs"]
mod material_resource_tests;
pub use texture::{
Texture3d, Texture3dError, Texture3dOptions, Texture3dUpdateBudget,
Texture3dUpdateBudgetResource, Texture3dUpdateError, Texture3dUpdateReport, TextureMaterial3d,
TextureMipmaps3d,
};
#[cfg(test)]
use crate::{MeshEdge3d, Projection3d, Rotation3d, SurfaceStyle3d, WorldLength};
#[cfg(test)]
#[path = "mesh3d_lifetime_tests.rs"]
mod lifetime_tests;
#[cfg(test)]
#[path = "mesh3d_vertex_color_tests.rs"]
mod vertex_color_tests;
#[cfg(test)]
#[path = "mesh3d_color_budget_tests.rs"]
mod color_budget_tests;
#[cfg(test)]
#[path = "mesh3d_timing_tests.rs"]
mod timing_tests;
#[cfg(test)]
pub(super) use timing_tests::assert_gpu_scene_timing_and_upload_contract;
#[cfg(test)]
fn logical(value: f32) -> LogicalPixels {
LogicalPixels::new(value).unwrap()
}
#[cfg(test)]
fn physical_per_logical(value: f32) -> PhysicalPerLogical {
PhysicalPerLogical::new(value).unwrap()
}
#[cfg(test)]
fn world(value: f32) -> WorldLength {
WorldLength::new(value).unwrap()
}
const INITIAL_INSTANCE_CAPACITY: usize = 16;
const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
const HIDDEN_EDGE_DEPTH_BIAS: i32 = 1;
const VISIBLE_EDGE_DEPTH_BIAS: i32 = -1;
static NEXT_SCENE3D_ID: AtomicU64 = AtomicU64::new(1);
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct MeshVertexGpu {
position: [f32; 3],
}
impl MeshVertexGpu {
const ATTRIBUTES: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![0 => Float32x3];
const LAYOUT: wgpu::VertexBufferLayout<'static> = wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &Self::ATTRIBUTES,
};
}
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct MeshInstanceGpu {
model_row_0: [f32; 4],
model_row_1: [f32; 4],
model_row_2: [f32; 4],
color: [f32; 4],
surface: [f32; 4],
normal_row_0: [f32; 4],
normal_row_1: [f32; 4],
normal_row_2: [f32; 4],
uv_transform: [f32; 4],
}
impl MeshInstanceGpu {
const ATTRIBUTES: [wgpu::VertexAttribute; 9] = wgpu::vertex_attr_array![1 => Float32x4, 2 => Float32x4, 3 => Float32x4, 4 => Float32x4, 7 => Float32x4, 9 => Float32x4, 10 => Float32x4, 11 => Float32x4, 12 => 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)]
struct Camera3dUniform {
clip_row_0: [f32; 4],
clip_row_1: [f32; 4],
clip_row_2: [f32; 4],
clip_row_3: [f32; 4],
viewport: [f32; 4],
environment: SurfaceEnvironmentGpu,
}
impl Camera3dUniform {
fn new(
camera: Camera3d,
width: u32,
height: u32,
scale_factor: PhysicalPerLogical,
) -> Result<Self, Mesh3dRenderError> {
let rows = camera
.world_to_clip_rows()
.map_err(|_| Mesh3dRenderError::InvalidGeometryTransform)?;
let uniform = Self {
clip_row_0: rows[0],
clip_row_1: rows[1],
clip_row_2: rows[2],
clip_row_3: rows[3],
viewport: [width as f32, height as f32, scale_factor.get(), 0.0],
environment: SurfaceEnvironmentGpu::default(),
};
uniform
.rows()
.into_iter()
.flatten()
.chain(uniform.viewport)
.all(is_portable_shader_source)
.then_some(uniform)
.ok_or(Mesh3dRenderError::InvalidGeometryTransform)
}
fn rows(self) -> [[f32; 4]; 4] {
[
self.clip_row_0,
self.clip_row_1,
self.clip_row_2,
self.clip_row_3,
]
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct MeshEdgeGpu {
start: [f32; 3],
end: [f32; 3],
}
impl MeshEdgeGpu {
const ATTRIBUTES: [wgpu::VertexAttribute; 2] =
wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3];
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)]
struct EdgeObjectUniform {
model_row_0: [f32; 4],
model_row_1: [f32; 4],
model_row_2: [f32; 4],
visible_color: [f32; 4],
hidden_color: [f32; 4],
edge_style: [f32; 4],
}
#[cfg(test)]
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ClipProbeInputGpu {
start_clip: [f32; 4],
end_clip: [f32; 4],
}
#[cfg(test)]
#[repr(C)]
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ClipProbeOutputGpu {
start_clip: [f32; 4],
end_clip: [f32; 4],
range: [f32; 2],
visible: u32,
padding: u32,
}
pub(super) struct Mesh3dRenderer {
dynamic_scratch: dynamic::DynamicMesh3dScratch,
textures: MeshTextureRenderer,
pipeline: SurfacePipelines,
colored_pipeline: SurfacePipelines,
colored_clipped_pipeline: SurfacePipelines,
clipped_color_buffer: Option<wgpu::Buffer>,
clipped_color_capacity: usize,
clipped_lighting_buffer: Option<wgpu::Buffer>,
clipped_lighting_capacity: usize,
clipped_surface_pipeline: SurfacePipelines,
clipped_surface_buffer: Option<wgpu::Buffer>,
clipped_surface_capacity: usize,
clipped_surface_objects: Vec<SurfaceObject>,
clipped_visible_edge_pipeline: wgpu::RenderPipeline,
clipped_hidden_edge_pipeline: wgpu::RenderPipeline,
clipped_edge_buffer: Option<wgpu::Buffer>,
clipped_edge_capacity: usize,
visible_edge_pipeline: wgpu::RenderPipeline,
hidden_edge_pipeline: wgpu::RenderPipeline,
camera_uniform_buffer: wgpu::Buffer,
camera_bind_group: wgpu::BindGroup,
instance_buffer: wgpu::Buffer,
instance_capacity: usize,
instances: Vec<MeshInstanceGpu>,
edge_object_layout: wgpu::BindGroupLayout,
edge_object_bind_group: wgpu::BindGroup,
edge_object_buffer: wgpu::Buffer,
edge_object_stride: usize,
edge_object_capacity: usize,
edge_object_bytes: Vec<u8>,
}
impl Mesh3dRenderer {
pub(super) fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sim-engine retained 3D mesh shader"),
source: wgpu::ShaderSource::Wgsl(lighting::shader_source(include_str!("mesh3d.wgsl"))),
});
let camera_uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D camera uniform buffer"),
size: std::mem::size_of::<Camera3dUniform>() as wgpu::BufferAddress,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let camera_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sim-engine 3D camera bind group layout"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("sim-engine 3D camera bind group"),
layout: &camera_layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: camera_uniform_buffer.as_entire_binding(),
}],
});
let edge_object_stride = align_to(
std::mem::size_of::<EdgeObjectUniform>(),
device.limits().min_uniform_buffer_offset_alignment as usize,
);
let edge_object_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sim-engine 3D edge object bind group layout"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: wgpu::BufferSize::new(
std::mem::size_of::<EdgeObjectUniform>() as u64,
),
},
count: None,
}],
});
let edge_object_buffer =
create_edge_object_buffer(device, edge_object_stride, INITIAL_INSTANCE_CAPACITY);
let edge_object_bind_group =
create_edge_object_bind_group(device, &edge_object_layout, &edge_object_buffer);
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sim-engine retained 3D mesh pipeline layout"),
bind_group_layouts: &[Some(&camera_layout)],
immediate_size: 0,
});
let pipeline = create_surface_pipelines(
device,
format,
&pipeline_layout,
&shader,
SurfaceLayout {
clipped: false,
textured: false,
colored: false,
},
);
let clipped_surface_pipeline = create_surface_pipelines(
device,
format,
&pipeline_layout,
&shader,
SurfaceLayout {
clipped: true,
textured: false,
colored: false,
},
);
let edge_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sim-engine 3D edge pipeline layout"),
bind_group_layouts: &[Some(&camera_layout), Some(&edge_object_layout)],
immediate_size: 0,
});
let visible_edge_pipeline = create_edge_pipeline(
device,
&shader,
&edge_pipeline_layout,
format,
wgpu::CompareFunction::LessEqual,
"mesh3d_visible_edge_fs_main",
"sim-engine visible 3D edge pipeline",
false,
);
let hidden_edge_pipeline = create_edge_pipeline(
device,
&shader,
&edge_pipeline_layout,
format,
wgpu::CompareFunction::Greater,
"mesh3d_hidden_edge_fs_main",
"sim-engine hidden 3D edge pipeline",
false,
);
let clipped_visible_edge_pipeline = create_edge_pipeline(
device,
&shader,
&edge_pipeline_layout,
format,
wgpu::CompareFunction::LessEqual,
"mesh3d_visible_edge_fs_main",
"sim-engine canonical visible 3D edge pipeline",
true,
);
let clipped_hidden_edge_pipeline = create_edge_pipeline(
device,
&shader,
&edge_pipeline_layout,
format,
wgpu::CompareFunction::Greater,
"mesh3d_hidden_edge_fs_main",
"sim-engine canonical hidden 3D edge pipeline",
true,
);
Self {
dynamic_scratch: dynamic::DynamicMesh3dScratch::default(),
textures: MeshTextureRenderer::new(device, format, &camera_layout),
pipeline,
colored_pipeline: create_surface_pipelines(
device,
format,
&pipeline_layout,
&shader,
SurfaceLayout {
clipped: false,
textured: false,
colored: true,
},
),
colored_clipped_pipeline: create_surface_pipelines(
device,
format,
&pipeline_layout,
&shader,
SurfaceLayout {
clipped: true,
textured: false,
colored: true,
},
),
clipped_color_buffer: None,
clipped_color_capacity: 0,
clipped_lighting_buffer: None,
clipped_lighting_capacity: 0,
clipped_surface_pipeline,
clipped_surface_buffer: None,
clipped_surface_capacity: 0,
clipped_surface_objects: Vec::new(),
clipped_visible_edge_pipeline,
clipped_hidden_edge_pipeline,
clipped_edge_buffer: None,
clipped_edge_capacity: 0,
visible_edge_pipeline,
hidden_edge_pipeline,
camera_uniform_buffer,
camera_bind_group,
instance_buffer: create_instance_buffer(device, INITIAL_INSTANCE_CAPACITY),
instance_capacity: INITIAL_INSTANCE_CAPACITY,
instances: Vec::new(),
edge_object_layout,
edge_object_bind_group,
edge_object_buffer,
edge_object_stride,
edge_object_capacity: INITIAL_INSTANCE_CAPACITY,
edge_object_bytes: Vec::new(),
}
}
fn ensure_frame_capacity(
&mut self,
device: &wgpu::Device,
object_count: usize,
) -> Result<(), Mesh3dRenderError> {
let instance_capacity = if object_count > self.instance_capacity {
Some(
object_count
.checked_next_power_of_two()
.filter(|capacity| buffer_capacity_fits::<MeshInstanceGpu>(device, *capacity))
.ok_or(Mesh3dRenderError::InstanceCapacityTooLarge)?,
)
} else {
None
};
let edge_capacity = if object_count > self.edge_object_capacity {
Some(
object_count
.checked_next_power_of_two()
.filter(|capacity| {
capacity
.checked_mul(self.edge_object_stride)
.is_some_and(|bytes| {
bytes as u64 <= device.limits().max_buffer_size
&& bytes <= u32::MAX as usize
})
})
.ok_or(Mesh3dRenderError::InstanceCapacityTooLarge)?,
)
} else {
None
};
let required_edge_bytes = object_count
.checked_mul(self.edge_object_stride)
.ok_or(Mesh3dRenderError::InstanceCapacityTooLarge)?;
let replace_instance_staging = self.instances.capacity() < object_count;
let replace_edge_staging = self.edge_object_bytes.capacity() < required_edge_bytes;
if instance_capacity.is_none()
&& edge_capacity.is_none()
&& !replace_instance_staging
&& !replace_edge_staging
{
return Ok(());
}
let replacement_instances = if replace_instance_staging {
let mut instances = Vec::new();
instances
.try_reserve_exact(object_count)
.map_err(|_| Mesh3dRenderError::InstanceCapacityTooLarge)?;
Some(instances)
} else {
None
};
let replacement_edge_bytes = if replace_edge_staging {
let mut bytes = Vec::new();
bytes
.try_reserve_exact(required_edge_bytes)
.map_err(|_| Mesh3dRenderError::InstanceCapacityTooLarge)?;
Some(bytes)
} else {
None
};
let replacement_instance_buffer =
instance_capacity.map(|capacity| create_instance_buffer(device, capacity));
let replacement_edge_resources = edge_capacity.map(|capacity| {
let buffer = create_edge_object_buffer(device, self.edge_object_stride, capacity);
let bind_group =
create_edge_object_bind_group(device, &self.edge_object_layout, &buffer);
(buffer, bind_group)
});
if let Some(instances) = replacement_instances {
self.instances = instances;
}
if let (Some(capacity), Some(buffer)) = (instance_capacity, replacement_instance_buffer) {
self.instance_buffer = buffer;
self.instance_capacity = capacity;
}
if let Some(bytes) = replacement_edge_bytes {
self.edge_object_bytes = bytes;
}
if let (Some(capacity), Some((buffer, bind_group))) =
(edge_capacity, replacement_edge_resources)
{
self.edge_object_buffer = buffer;
self.edge_object_bind_group = bind_group;
self.edge_object_capacity = capacity;
}
Ok(())
}
}
#[derive(Clone)]
pub struct RetainedMesh3d {
renderer_identity: Arc<()>,
vertex_buffer: Arc<wgpu::Buffer>,
index_buffer: Option<Arc<wgpu::Buffer>>,
edge_buffer: Option<Arc<wgpu::Buffer>>,
texture_coordinate_buffer: Option<Arc<wgpu::Buffer>>,
color_buffer: Option<Arc<wgpu::Buffer>>,
normal_buffer: Option<Arc<wgpu::Buffer>>,
material: Option<TextureMaterial3d>,
source: Mesh3d,
index_count: u32,
edge_count: u32,
gpu_allocation_bytes: usize,
budget: Mesh3dUploadBudget,
allocation: Mesh3dUploadLayout,
}
impl RetainedMesh3d {
pub fn without_material(&self) -> Self {
let mut mesh = self.clone();
mesh.material = None;
mesh
}
pub const fn material(&self) -> Option<&TextureMaterial3d> {
self.material.as_ref()
}
pub const fn budget(&self) -> Mesh3dUploadBudget {
self.budget
}
pub fn source(&self) -> &Mesh3d {
&self.source
}
pub fn triangle_count(&self) -> usize {
self.source.triangle_count()
}
pub const fn gpu_allocation_bytes(&self) -> usize {
self.gpu_allocation_bytes
}
pub fn recovery_memory_bytes(&self) -> usize {
self.source.recovery_memory_bytes()
}
}
#[path = "mesh3d_dynamic.rs"]
mod dynamic;
#[path = "mesh3d_objects.rs"]
mod objects;
#[path = "mesh3d_upload.rs"]
mod upload;
pub use dynamic::{
DynamicMesh3dBudget, DynamicMesh3dBudgetResource, DynamicMesh3dError, DynamicMesh3dUpdateReport,
};
pub use objects::{
Mesh3dInstance, Object3dId, Scene3d, Scene3dBudget, Scene3dBudgetResource, Scene3dError,
Scene3dMeshUpdateReport, Scene3dStatistics,
};
pub use upload::{Mesh3dUploadBudget, Mesh3dUploadBudgetResource, Mesh3dUploadReport};
pub struct RenderTarget3d {
renderer_identity: Arc<()>,
color: RenderTarget2d,
_depth_texture: wgpu::Texture,
depth_view: wgpu::TextureView,
logical_viewport: LogicalViewport,
pixels_per_logical: PhysicalPerLogical,
}
impl RenderTarget3d {
pub fn width(&self) -> u32 {
self.color.width()
}
pub fn height(&self) -> u32 {
self.color.height()
}
pub const fn logical_viewport(&self) -> LogicalViewport {
self.logical_viewport
}
pub const fn pixels_per_logical(&self) -> PhysicalPerLogical {
self.pixels_per_logical
}
pub const fn color_target(&self) -> &RenderTarget2d {
&self.color
}
pub fn allocation_bytes(&self) -> usize {
self.color.allocation_bytes().saturating_add(
(self.width() as usize)
.saturating_mul(self.height() as usize)
.saturating_mul(4),
)
}
}
fn validate_mesh_style(mesh: &RetainedMesh3d, style: MeshStyle3d) -> Result<(), Scene3dError> {
validate_mesh_source_style(mesh.source(), style)
}
fn validate_mesh_source_style(source: &Mesh3d, style: MeshStyle3d) -> Result<(), Scene3dError> {
let has_surface = style.surface_style().is_some() && source.triangle_count() > 0;
if has_surface
&& style
.surface_style()
.is_some_and(|surface| surface.lighting() == SurfaceLighting3d::Lambert)
&& source.normals().is_empty()
{
return Err(Scene3dError::MissingNormals);
}
let has_wireframe = style.wireframe_style().is_some() && !source.display_edges().is_empty();
(has_surface || has_wireframe)
.then_some(())
.ok_or(Scene3dError::StyleHasNoMatchingGeometry)
}
fn validate_scene3d_transform(transform: Transform3d) -> Result<(), Scene3dError> {
transform
.model_rows()
.ok()
.is_some_and(|rows| rows.into_iter().flatten().all(is_portable_shader_source))
.then_some(())
.ok_or(Scene3dError::InvalidTransform)
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Mesh3dResourceError {
Texture(Texture3dError),
NonPortableTextureCoordinate,
InvalidBudget,
RendererMismatch,
BudgetExceeded {
resource: Mesh3dUploadBudgetResource,
limit: usize,
actual: usize,
},
CapacityTooLarge,
NonPortableVertex,
HostAllocationFailed {
requested_bytes: u64,
},
Target(RenderTargetError),
InvalidViewportAspect,
}
impl fmt::Display for Mesh3dResourceError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Texture(error) => write!(formatter, "{error}"),
Self::NonPortableTextureCoordinate => write!(
formatter,
"3D texture coordinate is outside the portable shader envelope"
),
Self::InvalidBudget => write!(formatter, "3D mesh upload limits must be nonzero"),
Self::RendererMismatch => {
write!(formatter, "3D mesh belongs to another renderer generation")
}
Self::BudgetExceeded {
resource,
limit,
actual,
} => write!(
formatter,
"3D mesh {resource:?} budget exceeded: {actual} > {limit}"
),
Self::CapacityTooLarge => write!(formatter, "3D mesh exceeds GPU buffer limits"),
Self::NonPortableVertex => write!(
formatter,
"3D mesh contains a vertex outside the portable shader envelope"
),
Self::HostAllocationFailed { requested_bytes } => write!(
formatter,
"3D mesh could not reserve a {requested_bytes}-byte host staging buffer"
),
Self::Target(error) => write!(formatter, "3D target creation failed: {error}"),
Self::InvalidViewportAspect => write!(
formatter,
"3D target texture and logical viewport must have one aspect ratio"
),
}
}
}
impl Error for Mesh3dResourceError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mesh3dRenderError {
SortingBudgetExceeded {
limit: usize,
actual: usize,
},
RendererMismatch,
InvalidGeometryTransform,
UnportableSurfaceTopology,
InstanceCapacityTooLarge,
CameraTargetAspectMismatch,
InvalidEdgeProjection,
ObjectFailure {
object_id: Object3dId,
reason: Mesh3dObjectError,
},
GeneratedGeometryCapacityTooLarge,
SurfaceTriangleBudgetExceeded {
limit: usize,
actual: usize,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mesh3dObjectError {
InvalidGeometryTransform,
UnportableSurfaceTopology,
InvalidEdgeProjection,
SurfaceTriangle {
triangle_index: usize,
reason: Mesh3dSurfaceError,
},
Vertex {
vertex_index: usize,
reason: Mesh3dSurfaceError,
},
}
impl Mesh3dRenderError {
fn for_object(self, object_id: Object3dId) -> Self {
let reason = match self {
Self::InvalidGeometryTransform => Mesh3dObjectError::InvalidGeometryTransform,
Self::UnportableSurfaceTopology => Mesh3dObjectError::UnportableSurfaceTopology,
Self::InvalidEdgeProjection => Mesh3dObjectError::InvalidEdgeProjection,
_ => return self,
};
Self::ObjectFailure { object_id, reason }
}
pub const fn object_id(self) -> Option<Object3dId> {
match self {
Self::ObjectFailure { object_id, .. } => Some(object_id),
_ => None,
}
}
pub const fn source_triangle_index(self) -> Option<usize> {
match self {
Self::ObjectFailure {
reason: Mesh3dObjectError::SurfaceTriangle { triangle_index, .. },
..
} => Some(triangle_index),
_ => None,
}
}
pub const fn source_vertex_index(self) -> Option<usize> {
match self {
Self::ObjectFailure {
reason: Mesh3dObjectError::Vertex { vertex_index, .. },
..
} => Some(vertex_index),
_ => None,
}
}
pub const fn surface_reason(self) -> Option<Mesh3dSurfaceError> {
match self {
Self::ObjectFailure {
reason:
Mesh3dObjectError::SurfaceTriangle { reason, .. }
| Mesh3dObjectError::Vertex { reason, .. },
..
} => Some(reason),
_ => None,
}
}
}
impl fmt::Display for Mesh3dRenderError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::SortingBudgetExceeded { limit, actual } => write!(
formatter,
"3D sorting storage {actual} exceeds {limit} bytes"
),
Self::RendererMismatch => {
write!(formatter, "3D scene resource belongs to another renderer")
}
Self::InvalidGeometryTransform => {
write!(
formatter,
"3D transform is outside the portable GPU geometry envelope"
)
}
Self::UnportableSurfaceTopology => write!(
formatter,
"3D surface clipping or projected triangle topology is outside the portable GPU envelope"
),
Self::InstanceCapacityTooLarge => write!(
formatter,
"visible 3D objects exceed per-frame GPU or host buffer capacity"
),
Self::CameraTargetAspectMismatch => write!(
formatter,
"3D camera aspect does not match the target logical viewport"
),
Self::InvalidEdgeProjection => write!(
formatter,
"3D edge clipping or screen-space arithmetic is outside the portable GPU envelope"
),
Self::ObjectFailure { object_id, reason } => write!(
formatter,
"3D object {} failed preflight: {reason:?}",
object_id.get()
),
Self::GeneratedGeometryCapacityTooLarge => write!(
formatter,
"generated 3D surface topology exceeds frame or device capacity"
),
Self::SurfaceTriangleBudgetExceeded { limit, actual } => write!(
formatter,
"3D surface submissions {actual} exceed frame triangle limit {limit}"
),
}
}
}
impl Error for Mesh3dRenderError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Mesh3dRenderReport {
object_count: usize,
triangle_count: usize,
edge_count: usize,
render_pass_count: usize,
draw_call_count: usize,
upload: Duration,
preflight_duration: Duration,
staging_upload_duration: Duration,
encode_submit: Duration,
preflight: Mesh3dPreflightReport,
gpu_timing_id: Option<GpuTimingId>,
uploaded_bytes: usize,
upload_calls: usize,
buffer_allocation_count: usize,
retained_frame_cpu_bytes: usize,
retained_frame_gpu_bytes: usize,
staging_capacity_bytes: usize,
peak_frame_cpu_bytes: usize,
peak_frame_gpu_bytes: usize,
}
impl Mesh3dRenderReport {
pub const fn preflight(self) -> Mesh3dPreflightReport {
self.preflight
}
pub const fn object_count(self) -> usize {
self.object_count
}
pub const fn triangle_count(self) -> usize {
self.triangle_count
}
pub const fn edge_count(self) -> usize {
self.edge_count
}
pub const fn render_pass_count(self) -> usize {
self.render_pass_count
}
pub const fn draw_call_count(self) -> usize {
self.draw_call_count
}
pub const fn upload(self) -> Duration {
self.upload
}
pub const fn preflight_duration(self) -> Duration {
self.preflight_duration
}
pub const fn staging_upload_duration(self) -> Duration {
self.staging_upload_duration
}
pub const fn gpu_timing_id(self) -> Option<GpuTimingId> {
self.gpu_timing_id
}
pub const fn uploaded_bytes(self) -> usize {
self.uploaded_bytes
}
pub const fn upload_calls(self) -> usize {
self.upload_calls
}
pub const fn buffer_allocation_count(self) -> usize {
self.buffer_allocation_count
}
pub const fn retained_frame_cpu_bytes(self) -> usize {
self.retained_frame_cpu_bytes
}
pub const fn retained_frame_gpu_bytes(self) -> usize {
self.retained_frame_gpu_bytes
}
pub const fn staging_capacity_bytes(self) -> usize {
self.staging_capacity_bytes
}
pub const fn peak_frame_cpu_bytes(self) -> usize {
self.peak_frame_cpu_bytes
}
pub const fn peak_frame_gpu_bytes(self) -> usize {
self.peak_frame_gpu_bytes
}
pub const fn encode_submit(self) -> Duration {
self.encode_submit
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Scene3dRestoreReport {
object_count: usize,
migrated_object_count: usize,
restored_mesh_count: usize,
restored_gpu_bytes: usize,
restored_texture_count: usize,
restored_texture_bytes: usize,
}
impl Scene3dRestoreReport {
pub const fn restored_texture_count(self) -> usize {
self.restored_texture_count
}
pub const fn restored_texture_bytes(self) -> usize {
self.restored_texture_bytes
}
pub const fn object_count(self) -> usize {
self.object_count
}
pub const fn migrated_object_count(self) -> usize {
self.migrated_object_count
}
pub const fn restored_mesh_count(self) -> usize {
self.restored_mesh_count
}
pub const fn restored_gpu_bytes(self) -> usize {
self.restored_gpu_bytes
}
}
impl WgpuRenderer {
pub fn create_mesh3d(&self, source: Mesh3d) -> Result<RetainedMesh3d, Mesh3dResourceError> {
create_retained_mesh(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
source,
)
}
pub fn restore_mesh3d(
&self,
source: &RetainedMesh3d,
) -> Result<RetainedMesh3d, Mesh3dResourceError> {
restore_retained_mesh(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
&self.mesh3d_renderer.textures.layout,
source,
)
}
pub fn restore_scene3d(
&self,
scene: &mut Scene3d,
) -> Result<Scene3dRestoreReport, Mesh3dResourceError> {
restore_scene3d_resources(
&self.device,
&self.queue,
&self.mesh3d_renderer.textures.layout,
Arc::clone(&self.renderer_identity),
scene,
)
}
pub fn create_render_target3d(
&self,
width: u32,
height: u32,
logical_viewport: LogicalViewport,
) -> Result<RenderTarget3d, Mesh3dResourceError> {
let pixels_per_logical = target_pixels_per_logical(width, height, logical_viewport)
.ok_or(Mesh3dResourceError::InvalidViewportAspect)?;
let color = self
.create_render_target(width, height)
.map_err(Mesh3dResourceError::Target)?;
let depth_texture = create_depth_texture(&self.device, width, height);
let depth_view = depth_texture.create_view(&wgpu::TextureViewDescriptor::default());
Ok(RenderTarget3d {
renderer_identity: Arc::clone(&self.renderer_identity),
color,
_depth_texture: depth_texture,
depth_view,
logical_viewport,
pixels_per_logical,
})
}
pub fn restore_render_target3d(
&self,
source: &RenderTarget3d,
) -> Result<RenderTarget3d, Mesh3dResourceError> {
self.create_render_target3d(source.width(), source.height(), source.logical_viewport())
}
pub fn render_scene3d_to_target(
&mut self,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
) -> Result<Mesh3dRenderReport, Mesh3dRenderError> {
self.render_scene3d_to_target_with_budget(
target,
scene,
camera,
Mesh3dRenderBudget::default(),
)
}
pub fn validate_scene3d_for_target(
&self,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
budget: Mesh3dRenderBudget,
) -> Result<Mesh3dPreflightReport, Mesh3dRenderError> {
self.mesh3d_renderer
.preflight_scene3d(
&self.device,
&self.renderer_identity,
target,
scene,
camera,
budget,
)
.map(|(_, frame)| frame.report)
}
pub fn render_scene3d_to_target_with_budget(
&mut self,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
budget: Mesh3dRenderBudget,
) -> Result<Mesh3dRenderReport, Mesh3dRenderError> {
self.mesh3d_renderer.render_scene3d_with_timing(
&self.device,
&self.queue,
&self.renderer_identity,
target,
scene,
camera,
budget,
Some(&mut self.gpu_timing),
)
}
}
impl Mesh3dRenderer {
fn retained_frame_cpu_bytes(&self) -> usize {
self.instances
.capacity()
.saturating_mul(std::mem::size_of::<MeshInstanceGpu>())
.saturating_add(self.edge_object_bytes.capacity())
.saturating_add(
self.clipped_surface_objects
.capacity()
.saturating_mul(std::mem::size_of::<SurfaceObject>()),
)
}
fn retained_frame_gpu_bytes(&self) -> usize {
[
Some(&self.camera_uniform_buffer),
Some(&self.instance_buffer),
Some(&self.edge_object_buffer),
self.clipped_surface_buffer.as_ref(),
self.clipped_color_buffer.as_ref(),
self.clipped_lighting_buffer.as_ref(),
self.clipped_edge_buffer.as_ref(),
]
.into_iter()
.flatten()
.fold(0usize, |total, buffer| {
total.saturating_add(buffer.size() as usize)
})
}
fn preflight_scene3d(
&self,
device: &wgpu::Device,
renderer_identity: &Arc<()>,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
budget: Mesh3dRenderBudget,
) -> Result<(Camera3dUniform, SurfaceFrame), Mesh3dRenderError> {
validate_target_identity(renderer_identity, target)?;
validate_camera_target_aspect(camera, target.logical_viewport())?;
let mut camera_uniform = Camera3dUniform::new(
camera,
target.width(),
target.height(),
target.pixels_per_logical(),
)?;
let capacity = scene
.visible_object_count()
.max(1)
.checked_next_power_of_two()
.ok_or(Mesh3dRenderError::InstanceCapacityTooLarge)?;
if !buffer_capacity_fits::<MeshInstanceGpu>(device, capacity)
|| capacity
.checked_mul(self.edge_object_stride)
.is_none_or(|bytes| {
bytes as u64 > device.limits().max_buffer_size || bytes > u32::MAX as usize
})
{
return Err(Mesh3dRenderError::InstanceCapacityTooLarge);
}
camera_uniform.environment = SurfaceEnvironmentGpu::new(scene, camera);
let order = material::prepare_order(scene, camera, budget)?;
let mut frame = surface::preflight(
renderer_identity,
scene,
camera_uniform,
budget,
device.limits().max_buffer_size,
)?;
frame.report.sorting_capacity_bytes =
order.capacity() * std::mem::size_of::<material::SurfaceDraw>();
frame.order = order;
Ok((camera_uniform, frame))
}
#[cfg(test)]
#[allow(clippy::too_many_arguments)]
fn render_scene3d(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: &Arc<()>,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
budget: Mesh3dRenderBudget,
) -> Result<Mesh3dRenderReport, Mesh3dRenderError> {
self.render_scene3d_with_timing(
device,
queue,
renderer_identity,
target,
scene,
camera,
budget,
None,
)
}
#[allow(clippy::too_many_arguments)]
fn render_scene3d_with_timing(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: &Arc<()>,
target: &RenderTarget3d,
scene: &Scene3d,
camera: Camera3d,
budget: Mesh3dRenderBudget,
mut gpu_timing: Option<&mut gpu_timing::GpuTimingCollector>,
) -> Result<Mesh3dRenderReport, Mesh3dRenderError> {
let upload_started_at = Instant::now();
let previous_frame_cpu_bytes = self.retained_frame_cpu_bytes();
let previous_frame_gpu_bytes = self.retained_frame_gpu_bytes();
let (camera_uniform, surface_frame) =
self.preflight_scene3d(device, renderer_identity, target, scene, camera, budget)?;
let preflight_duration = upload_started_at.elapsed();
let transient_frame_cpu_bytes = surface_frame
.vertices
.capacity()
.saturating_mul(std::mem::size_of::<SurfaceClipVertex>())
.saturating_add(
surface_frame
.colors
.capacity()
.saturating_mul(std::mem::size_of::<MeshColorGpu>()),
)
.saturating_add(
surface_frame
.lighting
.capacity()
.saturating_mul(std::mem::size_of::<SurfaceLightingVertex>()),
)
.saturating_add(
surface_frame
.edges
.capacity()
.saturating_mul(std::mem::size_of::<SurfaceClipEdge>()),
)
.saturating_add(
surface_frame
.order
.capacity()
.saturating_mul(std::mem::size_of::<material::SurfaceDraw>()),
);
let incoming_object_bytes = surface_frame
.objects
.capacity()
.saturating_mul(std::mem::size_of::<SurfaceObject>());
let visible_count = scene.visible_object_count();
let uploaded_bytes = std::mem::size_of::<Camera3dUniform>()
.saturating_add(visible_count.saturating_mul(std::mem::size_of::<MeshInstanceGpu>()))
.saturating_add(visible_count.saturating_mul(self.edge_object_stride))
.saturating_add(surface_frame.report.generated_upload_bytes());
let upload_calls = 1
+ usize::from(visible_count > 0) * 2
+ usize::from(!surface_frame.vertices.is_empty())
+ usize::from(!surface_frame.colors.is_empty())
+ usize::from(!surface_frame.lighting.is_empty())
+ usize::from(!surface_frame.edges.is_empty());
let replacement_surface_buffer =
if surface_frame.vertices.len() > self.clipped_surface_capacity {
Some(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine clipped 3D surface buffer"),
size: (surface_frame.vertices.len() * std::mem::size_of::<SurfaceClipVertex>())
as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
} else {
None
};
let replacement_lighting_buffer = if surface_frame.lighting.len()
> self.clipped_lighting_capacity
{
Some(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine canonical 3D lighting attributes"),
size: (surface_frame.lighting.len() * std::mem::size_of::<SurfaceLightingVertex>())
as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
} else {
None
};
let replacement_color_buffer = if surface_frame.colors.len() > self.clipped_color_capacity {
Some(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine clipped 3D vertex color buffer"),
size: (surface_frame.colors.len() * std::mem::size_of::<MeshColorGpu>()) as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
} else {
None
};
let replacement_edge_buffer = if surface_frame.edges.len() > self.clipped_edge_capacity {
Some(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine canonical clip-space 3D edge buffer"),
size: (surface_frame.edges.len() * std::mem::size_of::<SurfaceClipEdge>()) as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
} else {
None
};
let replace_instance_buffer = visible_count > self.instance_capacity;
let replace_edge_buffer = visible_count > self.edge_object_capacity;
let replace_instance_staging = visible_count > self.instances.capacity();
let replace_edge_staging =
visible_count * self.edge_object_stride > self.edge_object_bytes.capacity();
let generated_replacements = [
replacement_surface_buffer.as_ref(),
replacement_lighting_buffer.as_ref(),
replacement_color_buffer.as_ref(),
replacement_edge_buffer.as_ref(),
];
let buffer_allocation_count = generated_replacements.iter().flatten().count()
+ usize::from(replace_instance_buffer)
+ usize::from(replace_edge_buffer);
let replacement_generated_bytes = generated_replacements
.into_iter()
.flatten()
.fold(0usize, |total, buffer| {
total.saturating_add(buffer.size() as usize)
});
self.ensure_frame_capacity(device, visible_count)?;
let peak_frame_cpu_bytes = previous_frame_cpu_bytes
.saturating_add(transient_frame_cpu_bytes)
.saturating_add(incoming_object_bytes)
.saturating_add(if replace_instance_staging {
self.instances
.capacity()
.saturating_mul(std::mem::size_of::<MeshInstanceGpu>())
} else {
0
})
.saturating_add(if replace_edge_staging {
self.edge_object_bytes.capacity()
} else {
0
});
let peak_frame_gpu_bytes = previous_frame_gpu_bytes
.saturating_add(replacement_generated_bytes)
.saturating_add(if replace_instance_buffer {
self.instance_buffer.size() as usize
} else {
0
})
.saturating_add(if replace_edge_buffer {
self.edge_object_buffer.size() as usize
} else {
0
});
if let Some(buffer) = replacement_surface_buffer {
self.clipped_surface_buffer = Some(buffer);
self.clipped_surface_capacity = surface_frame.vertices.len();
}
if let Some(buffer) = replacement_edge_buffer {
self.clipped_edge_buffer = Some(buffer);
self.clipped_edge_capacity = surface_frame.edges.len();
}
if let Some(buffer) = replacement_lighting_buffer {
self.clipped_lighting_buffer = Some(buffer);
self.clipped_lighting_capacity = surface_frame.lighting.len();
}
if let Some(buffer) = &self.clipped_lighting_buffer
&& !surface_frame.lighting.is_empty()
{
queue.write_buffer(buffer, 0, bytemuck::cast_slice(&surface_frame.lighting));
}
if let Some(buffer) = replacement_color_buffer {
self.clipped_color_buffer = Some(buffer);
self.clipped_color_capacity = surface_frame.colors.len();
}
self.clipped_surface_objects = surface_frame.objects;
if let Some(buffer) = &self.clipped_color_buffer
&& !surface_frame.colors.is_empty()
{
queue.write_buffer(buffer, 0, bytemuck::cast_slice(&surface_frame.colors));
}
if let Some(buffer) = &self.clipped_surface_buffer
&& !surface_frame.vertices.is_empty()
{
queue.write_buffer(buffer, 0, bytemuck::cast_slice(&surface_frame.vertices));
}
if let Some(buffer) = &self.clipped_edge_buffer
&& !surface_frame.edges.is_empty()
{
queue.write_buffer(buffer, 0, bytemuck::cast_slice(&surface_frame.edges));
}
self.instances.clear();
self.edge_object_bytes.clear();
self.edge_object_bytes
.resize(visible_count.saturating_mul(self.edge_object_stride), 0);
let triangle_count = surface_frame.report.submitted_triangle_count();
let mut edge_count = 0usize;
let mut draw_call_count = 0usize;
for (object_index, instance) in scene
.instances()
.iter()
.filter(|instance| instance.visible)
.enumerate()
{
let model_rows = self.clipped_surface_objects[object_index].model_rows;
let normal_rows = self.clipped_surface_objects[object_index]
.transport
.normal_rows;
self.instances.push(MeshInstanceGpu {
normal_row_0: normal_rows[0],
normal_row_1: normal_rows[1],
normal_row_2: normal_rows[2],
model_row_0: model_rows[0],
model_row_1: model_rows[1],
model_row_2: model_rows[2],
surface: material::surface_parameters(instance.style.surface_style()),
uv_transform: texture::material_uv_parameters(instance.mesh.material()),
color: {
let color = instance
.style
.surface_style()
.map_or(Color::BLACK, |surface| surface.color())
.to_array();
let tint = instance
.mesh
.material()
.map_or(Color::WHITE, TextureMaterial3d::tint)
.to_array();
std::array::from_fn(|index| color[index] * tint[index])
},
});
if instance.style.surface_style().is_some() {
let generated = self.clipped_surface_objects[object_index]
.generated
.as_ref();
if generated.map_or(instance.mesh.index_count > 0, |range| !range.is_empty()) {
draw_call_count = draw_call_count.saturating_add(1);
}
}
if let Some(style) = instance.wireframe() {
let instance_edge_count = instance.mesh.source().display_edges().len();
edge_count = edge_count.saturating_add(instance_edge_count);
if instance_edge_count > 0 {
draw_call_count = draw_call_count.saturating_add(1);
if style.hidden_enabled() {
draw_call_count = draw_call_count.saturating_add(1);
}
}
let hidden_color = style.hidden_color().unwrap_or(style.visible_color());
let hidden_width = style.hidden_width().map_or(0.0, LogicalPixels::get);
let (dash_length, gap_length) = style
.hidden_pattern()
.map_or((1.0, 1.0), |(dash, gap)| (dash.get(), gap.get()));
let edge_uniform = EdgeObjectUniform {
model_row_0: model_rows[0],
model_row_1: model_rows[1],
model_row_2: model_rows[2],
visible_color: style.visible_color().to_array(),
hidden_color: hidden_color.to_array(),
edge_style: [
style.visible_width().get(),
hidden_width,
dash_length,
gap_length,
],
};
let start = object_index * self.edge_object_stride;
let end = start + std::mem::size_of::<EdgeObjectUniform>();
self.edge_object_bytes[start..end]
.copy_from_slice(bytemuck::bytes_of(&edge_uniform));
}
}
queue.write_buffer(
&self.camera_uniform_buffer,
0,
bytemuck::bytes_of(&camera_uniform),
);
if !self.instances.is_empty() {
queue.write_buffer(
&self.instance_buffer,
0,
bytemuck::cast_slice(&self.instances),
);
}
if !self.edge_object_bytes.is_empty() {
queue.write_buffer(&self.edge_object_buffer, 0, &self.edge_object_bytes);
}
let upload = upload_started_at.elapsed();
let staging_upload_duration = upload.saturating_sub(preflight_duration);
let encode_started_at = Instant::now();
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("sim-engine retained 3D scene encoder"),
});
let timing = gpu_timing
.as_deref_mut()
.and_then(|collector| collector.reserve(GpuTimingSource::Scene3d));
encode_ordered_scene_pass(
&mut encoder,
self,
&target.color.view,
&target.depth_view,
scene.background(),
scene.instances(),
&surface_frame.order,
timing.as_ref().map(|timing| timing.timestamp_writes()),
);
if let Some(timing) = &timing {
timing.resolve(&mut encoder);
}
queue.submit([encoder.finish()]);
let gpu_timing_id = match (gpu_timing, timing) {
(Some(collector), Some(timing)) => Some(collector.submitted(timing)),
_ => None,
};
let encode_submit = encode_started_at.elapsed();
Ok(Mesh3dRenderReport {
object_count: visible_count,
triangle_count,
edge_count,
render_pass_count: 1,
draw_call_count,
upload,
preflight_duration,
staging_upload_duration,
encode_submit,
preflight: surface_frame.report,
gpu_timing_id,
uploaded_bytes,
upload_calls,
buffer_allocation_count,
retained_frame_cpu_bytes: self.retained_frame_cpu_bytes(),
retained_frame_gpu_bytes: self.retained_frame_gpu_bytes(),
staging_capacity_bytes: self
.retained_frame_cpu_bytes()
.saturating_add(transient_frame_cpu_bytes),
peak_frame_cpu_bytes,
peak_frame_gpu_bytes,
})
}
}
fn create_retained_mesh(
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: Arc<()>,
source: Mesh3d,
) -> Result<RetainedMesh3d, Mesh3dResourceError> {
let prepared = upload::prepare_with_budget(device, source, Mesh3dUploadBudget::default())?;
Ok(upload_prepared_retained_mesh(
device,
queue,
renderer_identity,
prepared,
))
}
struct PreparedRetainedMeshUpload {
source: Mesh3d,
layout: Mesh3dUploadLayout,
allocation: Mesh3dUploadLayout,
vertices: Vec<MeshVertexGpu>,
edges: Vec<MeshEdgeGpu>,
texture_coordinates: Vec<MeshUvGpu>,
colors: Vec<MeshColorGpu>,
normals: Vec<MeshNormalGpu>,
budget: Mesh3dUploadBudget,
}
impl PreparedRetainedMeshUpload {
fn staging_capacity_bytes(&self) -> usize {
self.vertices
.capacity()
.saturating_mul(std::mem::size_of::<MeshVertexGpu>())
.saturating_add(
self.edges
.capacity()
.saturating_mul(std::mem::size_of::<MeshEdgeGpu>()),
)
.saturating_add(
self.texture_coordinates
.capacity()
.saturating_mul(std::mem::size_of::<MeshUvGpu>()),
)
.saturating_add(
self.colors
.capacity()
.saturating_mul(std::mem::size_of::<MeshColorGpu>()),
)
.saturating_add(
self.normals
.capacity()
.saturating_mul(std::mem::size_of::<MeshNormalGpu>()),
)
}
}
fn prepare_retained_mesh_upload(
device: &wgpu::Device,
source: Mesh3d,
) -> Result<PreparedRetainedMeshUpload, Mesh3dResourceError> {
let layout = preflight_mesh3d_source(&source, device.limits().max_buffer_size)?;
if !mesh3d_source_is_portable(&source) {
return Err(Mesh3dResourceError::NonPortableVertex);
}
if source.texture_coordinates().iter().any(|coordinate| {
!is_portable_shader_source(coordinate.u()) || !is_portable_shader_source(coordinate.v())
}) {
return Err(Mesh3dResourceError::NonPortableTextureCoordinate);
}
let mut normals = Vec::new();
normals
.try_reserve_exact(source.normals().len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: layout.normal_bytes,
})?;
normals.extend(source.normals().iter().map(MeshNormalGpu::from_source));
let mut colors = Vec::new();
colors
.try_reserve_exact(source.vertex_colors().len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: layout.color_bytes,
})?;
colors.extend(source.vertex_colors().iter().map(|color| MeshColorGpu {
color: color.to_array(),
}));
let mut texture_coordinates = Vec::new();
texture_coordinates
.try_reserve_exact(source.texture_coordinates().len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: layout.texture_coordinate_bytes,
})?;
texture_coordinates.extend(
source
.texture_coordinates()
.iter()
.map(|coordinate| MeshUvGpu {
coordinate: [coordinate.u(), coordinate.v()],
}),
);
let mut vertices = Vec::new();
vertices
.try_reserve_exact(source.vertices().len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: layout.vertex_bytes,
})?;
vertices.extend(source.vertices().iter().map(|vertex| MeshVertexGpu {
position: [vertex.x(), vertex.y(), vertex.z()],
}));
let mut edges = Vec::new();
edges
.try_reserve_exact(source.display_edges().len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: layout.edge_bytes,
})?;
edges.extend(source.display_edges().iter().map(|edge| {
let start = source.vertices()[edge.start() as usize];
let end = source.vertices()[edge.end() as usize];
MeshEdgeGpu {
start: [start.x(), start.y(), start.z()],
end: [end.x(), end.y(), end.z()],
}
}));
Ok(PreparedRetainedMeshUpload {
source,
layout,
allocation: layout,
vertices,
edges,
texture_coordinates,
colors,
normals,
budget: Mesh3dUploadBudget::default(),
})
}
fn mesh3d_source_is_portable(source: &Mesh3d) -> bool {
source.vertices().iter().all(|vertex| {
[vertex.x(), vertex.y(), vertex.z()]
.into_iter()
.all(is_portable_shader_source)
})
}
fn upload_prepared_retained_mesh(
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer_identity: Arc<()>,
prepared: PreparedRetainedMeshUpload,
) -> RetainedMesh3d {
let PreparedRetainedMeshUpload {
source,
layout,
allocation,
vertices,
edges,
texture_coordinates,
colors,
normals,
budget,
} = prepared;
let mesh = allocate_retained_mesh(
device,
renderer_identity,
source,
layout,
allocation,
budget,
);
write_retained_mesh_uploads(
queue,
&mesh,
&vertices,
&edges,
&texture_coordinates,
&colors,
&normals,
);
submit_pending_uploads(queue);
mesh
}
fn allocate_retained_mesh(
device: &wgpu::Device,
renderer_identity: Arc<()>,
source: Mesh3d,
live: Mesh3dUploadLayout,
allocation: Mesh3dUploadLayout,
budget: Mesh3dUploadBudget,
) -> RetainedMesh3d {
let vertex_buffer = Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine retained 3D vertex buffer"),
size: allocation.vertex_bytes,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}));
let index_buffer = if allocation.index_bytes == 0 {
None
} else {
Some(Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine retained 3D index buffer"),
size: allocation.index_bytes,
usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})))
};
let edge_buffer = if allocation.edge_bytes == 0 {
None
} else {
let buffer = Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine retained 3D edge buffer"),
size: allocation.edge_bytes,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}));
Some(buffer)
};
let texture_coordinate_buffer = if allocation.texture_coordinate_bytes == 0 {
None
} else {
let buffer = Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D UV buffer"),
size: allocation.texture_coordinate_bytes,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}));
Some(buffer)
};
let color_buffer = (allocation.color_bytes > 0).then(|| {
Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D vertex color buffer"),
size: allocation.color_bytes,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
});
let normal_buffer = (allocation.normal_bytes > 0).then(|| {
Arc::new(device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D normal buffer"),
size: allocation.normal_bytes,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}))
});
RetainedMesh3d {
renderer_identity,
vertex_buffer,
index_buffer,
edge_buffer,
texture_coordinate_buffer,
color_buffer,
normal_buffer,
material: None,
source,
index_count: live.index_count,
edge_count: live.edge_count,
gpu_allocation_bytes: allocation.total_bytes as usize,
budget,
allocation,
}
}
#[allow(clippy::too_many_arguments)]
fn write_retained_mesh_uploads(
queue: &wgpu::Queue,
mesh: &RetainedMesh3d,
vertices: &[MeshVertexGpu],
edges: &[MeshEdgeGpu],
coordinates: &[MeshUvGpu],
colors: &[MeshColorGpu],
normals: &[MeshNormalGpu],
) -> usize {
let mut calls = 0;
for (buffer, bytes) in [
(Some(&mesh.vertex_buffer), bytemuck::cast_slice(vertices)),
(
mesh.index_buffer.as_ref(),
bytemuck::cast_slice(mesh.source.triangle_indices()),
),
(mesh.edge_buffer.as_ref(), bytemuck::cast_slice(edges)),
(mesh.color_buffer.as_ref(), bytemuck::cast_slice(colors)),
(mesh.normal_buffer.as_ref(), bytemuck::cast_slice(normals)),
(
mesh.texture_coordinate_buffer.as_ref(),
bytemuck::cast_slice(coordinates),
),
] {
if let Some(buffer) = buffer
&& !bytes.is_empty()
{
queue.write_buffer(buffer, 0, bytes);
calls += 1;
}
}
calls
}
fn restore_scene3d_resources(
device: &wgpu::Device,
queue: &wgpu::Queue,
texture_layout: &wgpu::BindGroupLayout,
renderer_identity: Arc<()>,
scene: &mut Scene3d,
) -> Result<Scene3dRestoreReport, Mesh3dResourceError> {
let prepared_textures = texture::prepare_scene_restoration(device, &renderer_identity, scene)?;
let mut restored_textures = Vec::new();
restored_textures
.try_reserve_exact(prepared_textures.len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: prepared_textures
.len()
.saturating_mul(std::mem::size_of::<(usize, Texture3d)>())
as u64,
})?;
let pending_staging_bytes = scene
.instances
.len()
.checked_mul(std::mem::size_of::<(usize, RetainedMesh3d)>())
.and_then(|bytes| u64::try_from(bytes).ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
let prepared_staging_bytes = scene
.instances
.len()
.checked_mul(std::mem::size_of::<(
usize,
Arc<wgpu::Buffer>,
PreparedRetainedMeshUpload,
)>())
.and_then(|bytes| u64::try_from(bytes).ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
let restored_staging_bytes = scene
.instances
.len()
.checked_mul(std::mem::size_of::<(usize, RetainedMesh3d)>())
.and_then(|bytes| u64::try_from(bytes).ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
let replacement_staging_bytes = scene
.instances
.len()
.checked_mul(std::mem::size_of::<Mesh3dInstance>())
.and_then(|bytes| u64::try_from(bytes).ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
let mut pending = Vec::<(usize, RetainedMesh3d)>::new();
pending
.try_reserve_exact(scene.instances.len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: pending_staging_bytes,
})?;
let mut prepared = Vec::<(usize, Arc<wgpu::Buffer>, PreparedRetainedMeshUpload)>::new();
prepared
.try_reserve_exact(scene.instances.len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: prepared_staging_bytes,
})?;
let mut restored = Vec::<(usize, RetainedMesh3d)>::new();
restored
.try_reserve_exact(scene.instances.len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: restored_staging_bytes,
})?;
let mut replacement_instances = Vec::new();
replacement_instances
.try_reserve_exact(scene.instances.len())
.map_err(|_| Mesh3dResourceError::HostAllocationFailed {
requested_bytes: replacement_staging_bytes,
})?;
replacement_instances.extend(scene.instances.iter().cloned());
for instance in &scene.instances {
if Arc::ptr_eq(&renderer_identity, &instance.mesh.renderer_identity) {
continue;
}
let key = Arc::as_ptr(&instance.mesh.vertex_buffer) as usize;
pending.push((key, instance.mesh.clone()));
}
pending.sort_unstable_by_key(|entry| entry.0);
pending.dedup_by_key(|entry| entry.0);
for (key, mesh) in pending {
let upload = upload::prepare_restoration(device, &mesh)?;
prepared.push((key, Arc::clone(&mesh.vertex_buffer), upload));
}
for (key, _old_vertex_buffer, upload) in prepared {
let replacement =
upload_prepared_retained_mesh(device, queue, Arc::clone(&renderer_identity), upload);
restored.push((key, replacement));
}
for prepared in prepared_textures {
if let Some(chain) = prepared.chain {
let restored = texture::upload_chain(
device,
queue,
&renderer_identity,
texture_layout,
chain,
prepared.source.preserves_alpha(),
);
restored_textures.push((prepared.key, restored));
}
}
let mut migrated_object_count = 0;
for instance in &mut replacement_instances {
let key = Arc::as_ptr(&instance.mesh.vertex_buffer) as usize;
let previous_material = instance.mesh.material.clone();
let mut migrated = false;
if let Ok(index) = restored.binary_search_by_key(&key, |entry| entry.0) {
instance.mesh = restored[index].1.clone();
migrated = true;
}
if let Some(material) = previous_material {
if let Ok(index) = restored_textures
.binary_search_by_key(&material.texture().identity_key(), |entry| entry.0)
{
instance.mesh.material =
Some(material.with_restored_texture(&restored_textures[index].1));
migrated = true;
} else {
instance.mesh.material = Some(material);
}
}
migrated_object_count += usize::from(migrated);
}
let restored_gpu_bytes = restored.iter().fold(0_usize, |total, (_, mesh)| {
total.saturating_add(mesh.gpu_allocation_bytes())
});
scene.instances = replacement_instances;
scene.renderer_identity = Some(renderer_identity);
scene.rebuild_resource_keys();
Ok(Scene3dRestoreReport {
object_count: scene.object_count(),
migrated_object_count,
restored_mesh_count: restored.len(),
restored_gpu_bytes,
restored_texture_count: restored_textures.len(),
restored_texture_bytes: restored_textures
.iter()
.map(|(_, texture)| texture.gpu_allocation_bytes())
.sum(),
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Mesh3dUploadLayout {
vertex_bytes: u64,
index_bytes: u64,
edge_bytes: u64,
texture_coordinate_bytes: u64,
color_bytes: u64,
normal_bytes: u64,
total_bytes: u64,
index_count: u32,
edge_count: u32,
}
fn preflight_mesh3d_source(
source: &Mesh3d,
max_buffer_size: u64,
) -> Result<Mesh3dUploadLayout, Mesh3dResourceError> {
let mut layout = preflight_mesh3d_upload(
source.vertices().len(),
source.triangle_indices().len(),
source.display_edges().len(),
max_buffer_size,
)?;
layout.texture_coordinate_bytes = source
.texture_coordinates()
.len()
.checked_mul(std::mem::size_of::<MeshUvGpu>())
.and_then(|bytes| u64::try_from(bytes).ok())
.filter(|bytes| *bytes <= max_buffer_size)
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
layout.color_bytes = source
.vertex_colors()
.len()
.checked_mul(std::mem::size_of::<MeshColorGpu>())
.and_then(|bytes| u64::try_from(bytes).ok())
.filter(|bytes| *bytes <= max_buffer_size)
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
layout.normal_bytes = source
.normals()
.len()
.checked_mul(std::mem::size_of::<MeshNormalGpu>())
.and_then(|bytes| u64::try_from(bytes).ok())
.filter(|bytes| *bytes <= max_buffer_size)
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
layout.total_bytes = layout
.total_bytes
.checked_add(layout.texture_coordinate_bytes)
.and_then(|bytes| bytes.checked_add(layout.color_bytes))
.and_then(|bytes| bytes.checked_add(layout.normal_bytes))
.filter(|bytes| usize::try_from(*bytes).is_ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
Ok(layout)
}
fn preflight_mesh3d_upload(
vertex_count: usize,
index_count: usize,
edge_count: usize,
max_buffer_size: u64,
) -> Result<Mesh3dUploadLayout, Mesh3dResourceError> {
let draw_index_count =
u32::try_from(index_count).map_err(|_| Mesh3dResourceError::CapacityTooLarge)?;
let draw_edge_count =
u32::try_from(edge_count).map_err(|_| Mesh3dResourceError::CapacityTooLarge)?;
let checked_buffer_bytes = |element_size: usize, element_count: usize| {
u64::try_from(element_size)
.ok()
.and_then(|size| u64::try_from(element_count).ok()?.checked_mul(size))
.filter(|bytes| *bytes <= max_buffer_size && usize::try_from(*bytes).is_ok())
.ok_or(Mesh3dResourceError::CapacityTooLarge)
};
let vertex_bytes = checked_buffer_bytes(std::mem::size_of::<MeshVertexGpu>(), vertex_count)?;
let index_bytes = checked_buffer_bytes(std::mem::size_of::<u32>(), index_count)?;
let edge_bytes = checked_buffer_bytes(std::mem::size_of::<MeshEdgeGpu>(), edge_count)?;
let total_bytes = vertex_bytes
.checked_add(index_bytes)
.and_then(|bytes| bytes.checked_add(edge_bytes))
.ok_or(Mesh3dResourceError::CapacityTooLarge)?;
usize::try_from(total_bytes).map_err(|_| Mesh3dResourceError::CapacityTooLarge)?;
Ok(Mesh3dUploadLayout {
vertex_bytes,
index_bytes,
edge_bytes,
texture_coordinate_bytes: 0,
color_bytes: 0,
normal_bytes: 0,
total_bytes,
index_count: draw_index_count,
edge_count: draw_edge_count,
})
}
fn create_instance_buffer(device: &wgpu::Device, capacity: usize) -> wgpu::Buffer {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D instance buffer"),
size: (capacity.max(1) * std::mem::size_of::<MeshInstanceGpu>()) as wgpu::BufferAddress,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})
}
#[allow(clippy::too_many_arguments)]
fn create_edge_pipeline(
device: &wgpu::Device,
shader: &wgpu::ShaderModule,
layout: &wgpu::PipelineLayout,
format: wgpu::TextureFormat,
depth_compare: wgpu::CompareFunction,
fragment_entry: &'static str,
label: &'static str,
clip_space: bool,
) -> wgpu::RenderPipeline {
let (vertex_entry, depth_bias) = if depth_compare == wgpu::CompareFunction::Greater {
(
"mesh3d_hidden_edge_vs_main",
wgpu::DepthBiasState {
constant: HIDDEN_EDGE_DEPTH_BIAS,
slope_scale: 0.0,
clamp: 0.0,
},
)
} else {
(
"mesh3d_visible_edge_vs_main",
wgpu::DepthBiasState {
constant: VISIBLE_EDGE_DEPTH_BIAS,
slope_scale: 0.0,
clamp: 0.0,
},
)
};
let vertex_entry = if clip_space {
if depth_compare == wgpu::CompareFunction::Greater {
"mesh3d_clipped_hidden_edge_vs_main"
} else {
"mesh3d_clipped_visible_edge_vs_main"
}
} else {
vertex_entry
};
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(layout),
vertex: wgpu::VertexState {
module: shader,
entry_point: Some(vertex_entry),
compilation_options: wgpu::PipelineCompilationOptions::default(),
buffers: &[Some(if clip_space {
SurfaceClipEdge::LAYOUT
} else {
MeshEdgeGpu::LAYOUT
})],
},
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: DEPTH_FORMAT,
depth_write_enabled: Some(false),
depth_compare: Some(depth_compare),
stencil: wgpu::StencilState::default(),
bias: depth_bias,
}),
multisample: wgpu::MultisampleState::default(),
fragment: Some(wgpu::FragmentState {
module: shader,
entry_point: Some(fragment_entry),
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,
})
}
fn align_to(value: usize, alignment: usize) -> usize {
if alignment <= 1 {
value
} else {
value.div_ceil(alignment).saturating_mul(alignment)
}
}
fn create_edge_object_buffer(
device: &wgpu::Device,
stride: usize,
capacity: usize,
) -> wgpu::Buffer {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D edge object uniform buffer"),
size: capacity.max(1).saturating_mul(stride) as wgpu::BufferAddress,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})
}
fn create_edge_object_bind_group(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
buffer: &wgpu::Buffer,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("sim-engine 3D edge object bind group"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<EdgeObjectUniform>() as u64),
}),
}],
})
}
fn create_depth_texture(device: &wgpu::Device, width: u32, height: u32) -> wgpu::Texture {
device.create_texture(&wgpu::TextureDescriptor {
label: Some("sim-engine 3D depth target"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
}
fn target_pixels_per_logical(
width: u32,
height: u32,
viewport: LogicalViewport,
) -> Option<PhysicalPerLogical> {
let horizontal = width as f64 / viewport.width() as f64;
let vertical = height as f64 / viewport.height() as f64;
if !horizontal.is_finite()
|| !vertical.is_finite()
|| horizontal <= 0.0
|| vertical <= 0.0
|| !aspect_matches(horizontal, vertical)
|| horizontal > f32::MAX as f64
{
return None;
}
PhysicalPerLogical::new(horizontal as f32).ok()
}
fn aspect_matches(left: f64, right: f64) -> bool {
if !left.is_finite() || !right.is_finite() || left <= 0.0 || right <= 0.0 {
return false;
}
let scale = left.abs().max(right.abs());
(left - right).abs() <= scale * 1.0e-5
}
fn validate_camera_target_aspect(
camera: Camera3d,
viewport: LogicalViewport,
) -> Result<(), Mesh3dRenderError> {
aspect_matches(
f64::from(camera.projection().aspect_ratio()),
f64::from(viewport.width()) / f64::from(viewport.height()),
)
.then_some(())
.ok_or(Mesh3dRenderError::CameraTargetAspectMismatch)
}
fn validate_target_identity(
renderer_identity: &Arc<()>,
target: &RenderTarget3d,
) -> Result<(), Mesh3dRenderError> {
(Arc::ptr_eq(renderer_identity, &target.renderer_identity)
&& Arc::ptr_eq(renderer_identity, &target.color.renderer_identity))
.then_some(())
.ok_or(Mesh3dRenderError::RendererMismatch)
}
fn validate_mesh_identity(
renderer_identity: &Arc<()>,
mesh: &RetainedMesh3d,
) -> Result<(), Mesh3dRenderError> {
(Arc::ptr_eq(renderer_identity, &mesh.renderer_identity)
&& mesh
.material()
.is_none_or(|material| material.texture().belongs_to(renderer_identity)))
.then_some(())
.ok_or(Mesh3dRenderError::RendererMismatch)
}
#[cfg(test)]
fn validate_shader_transform(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> Result<(), Mesh3dRenderError> {
validate_shader_points(mesh, model_rows, camera_rows)?;
validate_surface_triangle_topology(mesh, model_rows, camera_rows)
}
#[cfg(test)]
fn validate_shader_points(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> Result<(), Mesh3dRenderError> {
for vertex in mesh.vertices() {
validate_shader_point(*vertex, model_rows, camera_rows)?;
}
Ok(())
}
#[cfg(test)]
fn validate_surface_triangle_topology(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> Result<(), Mesh3dRenderError> {
surface::classify_surface(mesh, model_rows, camera_rows, |_, _, _| Ok(()))
}
fn validate_projected_triangle_orientation(
clips: [[ShaderValueRange; 4]; 3],
) -> Result<(), Mesh3dRenderError> {
let minimum_normal = f64::from(f32::MIN_POSITIVE);
let ndc = clips.map(|clip| {
let denominator = (clip[3].minimum, clip[3].maximum);
[
wgsl_division_range((clip[0].minimum, clip[0].maximum), denominator),
wgsl_division_range((clip[1].minimum, clip[1].maximum), denominator),
]
});
let ndc = [
[
ndc[0][0].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
ndc[0][1].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
],
[
ndc[1][0].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
ndc[1][1].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
],
[
ndc[2][0].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
ndc[2][1].ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?,
],
];
let first_x = rounded_f32_add_range(ndc[1][0], ndc[0][0], true)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let first_y = rounded_f32_add_range(ndc[2][1], ndc[0][1], true)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let second_y = rounded_f32_add_range(ndc[1][1], ndc[0][1], true)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let second_x = rounded_f32_add_range(ndc[2][0], ndc[0][0], true)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let positive = rounded_f32_product_range(first_x, first_y)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let negative = rounded_f32_product_range(second_y, second_x)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let signed_area = rounded_f32_add_range(positive, negative, true)
.ok_or(Mesh3dRenderError::UnportableSurfaceTopology)?;
let stable_area = signed_area.0 >= minimum_normal || signed_area.1 <= -minimum_normal;
if !stable_area {
return Err(Mesh3dRenderError::UnportableSurfaceTopology);
}
Ok(())
}
#[cfg(test)]
fn validate_shader_point(
point: Vec3,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> Result<(), Mesh3dRenderError> {
validate_clip_classification(shader_clip_point_ranges(point, model_rows, camera_rows)?)
}
fn shader_clip_point_ranges(
point: Vec3,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
) -> Result<[ShaderValueRange; 4], Mesh3dRenderError> {
let model_point = [point.x(), point.y(), point.z(), 1.0].map(ShaderValueRange::exact);
let world = [
shader_dot_range(model_rows[0], model_point)?,
shader_dot_range(model_rows[1], model_point)?,
shader_dot_range(model_rows[2], model_point)?,
ShaderValueRange::exact(1.0),
];
Ok([
shader_dot_range(camera_rows[0], world)?,
shader_dot_range(camera_rows[1], world)?,
shader_dot_range(camera_rows[2], world)?,
shader_dot_range(camera_rows[3], world)?,
])
}
fn validate_clip_classification(clip: [ShaderValueRange; 4]) -> Result<(), Mesh3dRenderError> {
let plane_ranges = clip_plane_ranges(clip)?;
let minimum_normal = f64::from(f32::MIN_POSITIVE);
let stable_planes = plane_ranges
.iter()
.all(|range| range.0 >= 0.0 || range.1 <= -minimum_normal);
let always_inside =
plane_ranges.iter().all(|range| range.0 >= 0.0) && clip[3].minimum >= minimum_normal;
let always_outside = plane_ranges.iter().any(|range| range.1 <= -minimum_normal);
(stable_planes && (always_inside || always_outside))
.then_some(())
.ok_or(Mesh3dRenderError::InvalidGeometryTransform)
}
fn clip_plane_ranges(clip: [ShaderValueRange; 4]) -> Result<[(f64, f64); 6], Mesh3dRenderError> {
let x = clip[0];
let y = clip[1];
let z = clip[2];
let w = clip[3];
let plane_ranges = [
(w.minimum + x.minimum, w.maximum + x.maximum),
(w.minimum - x.maximum, w.maximum - x.minimum),
(w.minimum + y.minimum, w.maximum + y.maximum),
(w.minimum - y.maximum, w.maximum - y.minimum),
(z.minimum, z.maximum),
(w.minimum - z.maximum, w.maximum - z.minimum),
];
plane_ranges
.iter()
.all(|range| range.0.is_finite() && range.1.is_finite())
.then_some(plane_ranges)
.ok_or(Mesh3dRenderError::InvalidGeometryTransform)
}
type ClipPlaneRanges = [(f64, f64); 6];
type EdgeClipPlaneRanges = [ClipPlaneRanges; 2];
type ClipComponentRange = (f64, f64);
type ClipPointRanges = [ClipComponentRange; 4];
type EdgeClipRanges = [ClipPointRanges; 2];
#[derive(Clone, Copy)]
struct NormalizedEdgeRanges {
clip: EdgeClipRanges,
planes: EdgeClipPlaneRanges,
}
fn clip_ranges_share_outside_plane(start: ClipPlaneRanges, end: ClipPlaneRanges) -> bool {
let minimum_normal = f64::from(f32::MIN_POSITIVE);
start
.into_iter()
.zip(end)
.any(|(start, end)| start.1 <= -minimum_normal && end.1 <= -minimum_normal)
}
fn validate_edge_homogeneous_classification(
start: [ShaderValueRange; 4],
end: [ShaderValueRange; 4],
) -> Result<NormalizedEdgeRanges, Mesh3dRenderError> {
let minimum_magnitude = start
.into_iter()
.chain(end)
.map(shader_range_minimum_magnitude)
.fold(0.0_f64, f64::max)
.max(1.0);
let maximum_magnitude = start
.into_iter()
.chain(end)
.map(|value| value.minimum.abs().max(value.maximum.abs()))
.fold(1.0_f64, f64::max);
if !minimum_magnitude.is_finite() || !maximum_magnitude.is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let scale = wgsl_division_range(
(1.0, 1.0),
(minimum_magnitude.max(1.0), maximum_magnitude.max(1.0)),
)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let mut normalized_clip = [[(0.0, 0.0); 4]; 2];
let mut normalized_planes = [[(0.0, 0.0); 6]; 2];
for (endpoint_index, clip) in [start, end].into_iter().enumerate() {
let normalized = clip.map(|component| {
rounded_f32_product_range((component.minimum, component.maximum), scale)
});
if normalized.iter().any(Option::is_none) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let normalized = normalized.map(Option::unwrap);
normalized_clip[endpoint_index] = normalized;
let x = normalized[0];
let y = normalized[1];
let z = normalized[2];
let w = normalized[3];
let planes = [
rounded_f32_add_range(w, x, false),
rounded_f32_add_range(w, x, true),
rounded_f32_add_range(w, y, false),
rounded_f32_add_range(w, y, true),
Some(z),
rounded_f32_add_range(w, z, true),
];
if planes.iter().any(Option::is_none) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let planes = planes.map(Option::unwrap);
normalized_planes[endpoint_index] = planes;
}
validate_normalized_plane_sides([start, end], normalized_planes)?;
Ok(NormalizedEdgeRanges {
clip: normalized_clip,
planes: normalized_planes,
})
}
fn validate_normalized_plane_sides(
raw_clip: [[ShaderValueRange; 4]; 2],
normalized_planes: EdgeClipPlaneRanges,
) -> Result<(), Mesh3dRenderError> {
let minimum_normal = f64::from(f32::MIN_POSITIVE);
for (raw_clip, normalized_planes) in raw_clip.into_iter().zip(normalized_planes) {
for (raw, normalized) in clip_plane_ranges(raw_clip)?
.into_iter()
.zip(normalized_planes)
{
let raw_inside = raw.0 >= 0.0;
let raw_outside = raw.1 <= -minimum_normal;
let normalized_inside = normalized.0 >= 0.0;
let normalized_outside = normalized.1 <= -minimum_normal;
if (raw_inside && !normalized_inside) || (raw_outside && !normalized_outside) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
}
}
Ok(())
}
fn shader_range_minimum_magnitude(value: ShaderValueRange) -> f64 {
if value.minimum <= 0.0 && value.maximum >= 0.0 {
0.0
} else {
value.minimum.abs().min(value.maximum.abs())
}
}
fn rounded_f32_product_range(left: (f64, f64), right: (f64, f64)) -> Option<(f64, f64)> {
let products = [
left.0 * right.0,
left.0 * right.1,
left.1 * right.0,
left.1 * right.1,
];
rounded_f32_range(
products.into_iter().fold(f64::INFINITY, f64::min),
products.into_iter().fold(f64::NEG_INFINITY, f64::max),
)
}
fn rounded_f32_add_range(
left: (f64, f64),
right: (f64, f64),
subtract: bool,
) -> Option<(f64, f64)> {
let (minimum, maximum) = if subtract {
(left.0 - right.1, left.1 - right.0)
} else {
(left.0 + right.0, left.1 + right.1)
};
rounded_f32_range(minimum, maximum)
}
fn rounded_f32_range(minimum: f64, maximum: f64) -> Option<(f64, f64)> {
if !minimum.is_finite()
|| !maximum.is_finite()
|| minimum < -f64::from(MAX_PORTABLE_SHADER_VALUE)
|| maximum > f64::from(MAX_PORTABLE_SHADER_VALUE)
{
return None;
}
let mut minimum = f64::from(next_f32_down(minimum as f32)?);
let mut maximum = f64::from(next_f32_up(maximum as f32)?);
let minimum_normal = f64::from(f32::MIN_POSITIVE);
if maximum > 0.0 && minimum < minimum_normal {
minimum = minimum.min(0.0);
}
if minimum < 0.0 && maximum > -minimum_normal {
maximum = maximum.max(0.0);
}
Some((minimum, maximum))
}
fn next_f32_down(value: f32) -> Option<f32> {
if !value.is_finite() {
return None;
}
let next = if value == 0.0 {
-f32::from_bits(1)
} else if value > 0.0 {
f32::from_bits(value.to_bits().checked_sub(1)?)
} else {
f32::from_bits(value.to_bits().checked_add(1)?)
};
next.is_finite().then_some(next)
}
fn next_f32_up(value: f32) -> Option<f32> {
if !value.is_finite() {
return None;
}
let next = if value == 0.0 {
f32::from_bits(1)
} else if value > 0.0 {
f32::from_bits(value.to_bits().checked_add(1)?)
} else {
f32::from_bits(value.to_bits().checked_sub(1)?)
};
next.is_finite().then_some(next)
}
fn wgsl_division_range(numerator: (f64, f64), denominator: (f64, f64)) -> Option<(f64, f64)> {
let minimum_normal = f64::from(f32::MIN_POSITIVE);
let maximum_divisor = 2.0_f64.powi(126);
if denominator.0 < minimum_normal || denominator.1 > maximum_divisor {
return None;
}
let quotients = [
numerator.0 / denominator.0,
numerator.0 / denominator.1,
numerator.1 / denominator.0,
numerator.1 / denominator.1,
];
let mut range = rounded_f32_range(
quotients.into_iter().fold(f64::INFINITY, f64::min),
quotients.into_iter().fold(f64::NEG_INFINITY, f64::max),
)?;
for _ in 0..2 {
range.0 = f64::from(next_f32_down(range.0 as f32)?);
range.1 = f64::from(next_f32_up(range.1 as f32)?);
}
Some(range)
}
fn wgsl_signed_division_range(
numerator: (f64, f64),
denominator: (f64, f64),
) -> Option<(f64, f64)> {
if denominator.0 > 0.0 {
wgsl_division_range(numerator, denominator)
} else if denominator.1 < 0.0 {
wgsl_division_range(
(-numerator.1, -numerator.0),
(-denominator.1, -denominator.0),
)
} else {
None
}
}
fn interval_lerp_range(
start: (f64, f64),
end: (f64, f64),
amount: (f64, f64),
) -> Option<(f64, f64)> {
let delta = rounded_f32_add_range(end, start, true)?;
let scaled_delta = rounded_f32_product_range(delta, amount)?;
rounded_f32_add_range(start, scaled_delta, false)
}
fn interval_clip_edge_to_frustum(
normalized: NormalizedEdgeRanges,
) -> Result<Option<EdgeClipRanges>, Mesh3dRenderError> {
let minimum_normal = f64::from(f32::MIN_POSITIVE);
let mut enter = (0.0_f64, 0.0_f64);
let mut exit = (1.0_f64, 1.0_f64);
for (start_distance, end_distance) in normalized.planes[0].into_iter().zip(normalized.planes[1])
{
let start_outside = start_distance.1 <= -minimum_normal;
let end_outside = end_distance.1 <= -minimum_normal;
if start_outside && end_outside {
return Ok(None);
}
if start_outside || end_outside {
let denominator = rounded_f32_add_range(start_distance, end_distance, true)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let amount = wgsl_signed_division_range(start_distance, denominator)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
if amount.0 < 0.0 || amount.1 > 1.0 {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
if start_outside {
enter = (enter.0.max(amount.0), enter.1.max(amount.1));
} else {
exit = (exit.0.min(amount.0), exit.1.min(amount.1));
}
}
}
if enter.0 > exit.1 {
return Ok(None);
}
if enter.1 > exit.0 {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let clipped_start = std::array::from_fn(|axis| {
interval_lerp_range(normalized.clip[0][axis], normalized.clip[1][axis], enter)
});
let clipped_end = std::array::from_fn(|axis| {
interval_lerp_range(normalized.clip[0][axis], normalized.clip[1][axis], exit)
});
if clipped_start.iter().any(Option::is_none) || clipped_end.iter().any(Option::is_none) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let clipped = [
clipped_start.map(Option::unwrap),
clipped_end.map(Option::unwrap),
];
if clipped[0][3].0 < minimum_normal || clipped[1][3].0 < minimum_normal {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
Ok(Some(clipped))
}
fn projected_screen_axis_range(
numerator: (f64, f64),
denominator: (f64, f64),
dimension: f32,
inverted: bool,
) -> Option<(f64, f64)> {
let ndc = wgsl_division_range(numerator, denominator)?;
let half_ndc = rounded_f32_product_range(ndc, (0.5, 0.5))?;
let normalized = rounded_f32_add_range((0.5, 0.5), half_ndc, inverted)?;
rounded_f32_product_range(normalized, {
let dimension = f64::from(dimension.max(1.0));
(dimension, dimension)
})
}
fn validate_edge_projection_range(
start: [(f64, f64); 4],
end: [(f64, f64); 4],
viewport: [f32; 4],
fixed_delta: [f32; 2],
) -> Result<(), Mesh3dRenderError> {
let start_x = projected_screen_axis_range(start[0], start[3], viewport[0], false)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let start_y = projected_screen_axis_range(start[1], start[3], viewport[1], true)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let end_x = projected_screen_axis_range(end[0], end[3], viewport[0], false)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let end_y = projected_screen_axis_range(end[1], end[3], viewport[1], true)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let delta_x = rounded_f32_add_range(end_x, start_x, true)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let delta_y = rounded_f32_add_range(end_y, start_y, true)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let component_minimum = |range: (f64, f64)| {
if range.0 > 0.0 {
range.0
} else if range.1 < 0.0 {
-range.1
} else {
0.0
}
};
let minimum_length = component_minimum(delta_x).hypot(component_minimum(delta_y));
let maximum_length = delta_x
.0
.abs()
.max(delta_x.1.abs())
.hypot(delta_y.0.abs().max(delta_y.1.abs()));
let extrusion_threshold = 0.0001_f64;
if !minimum_length.is_finite()
|| !maximum_length.is_finite()
|| (minimum_length <= extrusion_threshold && maximum_length > extrusion_threshold)
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
if maximum_length <= extrusion_threshold {
return Ok(());
}
let fixed_x = f64::from(fixed_delta[0]);
let fixed_y = f64::from(fixed_delta[1]);
let fixed_length = fixed_x.hypot(fixed_y);
let minimum_dot = fixed_x * if fixed_x >= 0.0 { delta_x.0 } else { delta_x.1 }
+ fixed_y * if fixed_y >= 0.0 { delta_y.0 } else { delta_y.1 };
if !fixed_length.is_finite()
|| fixed_length <= extrusion_threshold
|| !minimum_dot.is_finite()
|| minimum_dot <= 0.0
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
Ok(())
}
fn validate_edge_projection(
mesh: &Mesh3d,
model_rows: [[f32; 4]; 3],
camera_rows: [[f32; 4]; 4],
style: WireframeStyle3d,
viewport: [f32; 4],
) -> Result<(), Mesh3dRenderError> {
let style_sources = [
style.visible_width().get(),
style.hidden_width().map_or(0.0, LogicalPixels::get),
style
.hidden_pattern()
.map_or(0.0, |pattern| pattern.0.get()),
style
.hidden_pattern()
.map_or(0.0, |pattern| pattern.1.get()),
];
if !viewport
.into_iter()
.chain(style_sources)
.all(is_portable_shader_source)
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let pixels_per_logical = PhysicalPerLogical::new(viewport[2])
.map_err(|_| Mesh3dRenderError::InvalidEdgeProjection)?;
let visible_raster = edge_raster_envelope(style.visible_width(), pixels_per_logical)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let hidden_raster = match style.hidden_width() {
Some(width) => Some(
edge_raster_envelope(width, pixels_per_logical)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?,
),
None => None,
};
let hidden_period = style.hidden_pattern().map(|(dash, gap)| {
let dash = dash.get();
let gap = gap.get();
if is_nonzero_subnormal(dash) || is_nonzero_subnormal(gap) {
return f32::NAN;
}
let period = f64::from(dash) + f64::from(gap);
if period > f64::from(MAX_PORTABLE_SHADER_VALUE) {
f32::NAN
} else {
dash + gap
}
});
if hidden_period.is_some_and(|period| !period.is_finite()) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
validate_hidden_dash_envelope(viewport, hidden_period)?;
for edge in mesh.display_edges() {
let mut clip_ranges = [[ShaderValueRange::exact(0.0); 4]; 2];
let mut clip = [[0.0_f32; 4]; 2];
for (endpoint_index, vertex_index) in [edge.start(), edge.end()].into_iter().enumerate() {
let vertex = mesh.vertices()[vertex_index as usize];
clip_ranges[endpoint_index] =
shader_clip_point_ranges(vertex, model_rows, camera_rows)?;
validate_clip_classification(clip_ranges[endpoint_index])?;
clip[endpoint_index] = clip_ranges[endpoint_index].map(|value| value.fixed);
}
let normalized_ranges =
validate_edge_homogeneous_classification(clip_ranges[0], clip_ranges[1])?;
if clip_ranges_share_outside_plane(normalized_ranges.planes[0], normalized_ranges.planes[1])
{
continue;
}
let Some(clipped_ranges) = interval_clip_edge_to_frustum(normalized_ranges)? else {
continue;
};
let Some(clipped) = clip_edge_to_frustum(clip[0], clip[1])? else {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
};
let mut screen = [[0.0_f32; 2]; 2];
for (endpoint_index, clip) in clipped.into_iter().enumerate() {
let ndc_x = clip[0] / clip[3];
let ndc_y = clip[1] / clip[3];
screen[endpoint_index] = [
(ndc_x * 0.5 + 0.5) * viewport[0],
(0.5 - ndc_y * 0.5) * viewport[1],
];
if !screen[endpoint_index][0].is_finite() || !screen[endpoint_index][1].is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
}
let delta_x = screen[1][0] - screen[0][0];
let delta_y = screen[1][1] - screen[0][1];
let length_squared = delta_x * delta_x + delta_y * delta_y;
if !delta_x.is_finite() || !delta_y.is_finite() || !length_squared.is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let threshold_squared = 0.0001_f32 * 0.0001_f32;
if length_squared > threshold_squared * 0.99 && length_squared < threshold_squared * 1.01 {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let screen_length = length_squared.sqrt();
validate_edge_projection_range(
clipped_ranges[0],
clipped_ranges[1],
viewport,
[delta_x, delta_y],
)?;
let screen_normal = if screen_length > 0.0001 {
[-delta_y / screen_length, delta_x / screen_length]
} else {
[0.0, 0.0]
};
if !screen_normal.into_iter().all(f32::is_finite) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
validate_edge_shader_arithmetic(clipped_ranges, viewport, visible_raster, None)?;
if let Some(hidden_raster) = hidden_raster {
validate_edge_shader_arithmetic(
clipped_ranges,
viewport,
hidden_raster,
hidden_period,
)?;
}
}
Ok(())
}
fn validate_hidden_dash_envelope(
viewport: [f32; 4],
dash_period: Option<f32>,
) -> Result<(), Mesh3dRenderError> {
let Some(period) = dash_period else {
return Ok(());
};
if period <= 0.0 || is_nonzero_subnormal(period) {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let width = f64::from(viewport[0]);
let height = f64::from(viewport[1]);
let pixels_per_logical = f64::from(viewport[2]);
let screen_diagonal = width.hypot(height) * (1.0 + 8.0 * f64::from(f32::EPSILON));
let maximum_logical_distance = screen_diagonal / pixels_per_logical;
let maximum_repetition = maximum_logical_distance / f64::from(period);
if !screen_diagonal.is_finite()
|| !maximum_logical_distance.is_finite()
|| !maximum_repetition.is_finite()
|| maximum_logical_distance > f64::from(MAX_PORTABLE_SHADER_VALUE)
|| maximum_repetition > f64::from(MAX_PORTABLE_SHADER_VALUE)
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
Ok(())
}
fn clip_edge_to_frustum(
start: [f32; 4],
end: [f32; 4],
) -> Result<Option<[[f32; 4]; 2]>, Mesh3dRenderError> {
Ok(clip_edge_to_frustum_details(start, end)?.map(|clipped| clipped.clip))
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct ClippedEdgeCpu {
clip: [[f32; 4]; 2],
enter: f32,
exit: f32,
}
fn clip_edge_to_frustum_details(
start: [f32; 4],
end: [f32; 4],
) -> Result<Option<ClippedEdgeCpu>, Mesh3dRenderError> {
let pair_max = start
.into_iter()
.chain(end)
.map(f32::abs)
.fold(0.0_f32, f32::max);
if !pair_max.is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
if pair_max > MAX_PORTABLE_SHADER_VALUE {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
let homogeneous_scale = 1.0 / pair_max.max(1.0);
let start = start.map(|component| component * homogeneous_scale);
let end = end.map(|component| component * homogeneous_scale);
let start_distances = clip_plane_distances(start)?;
let end_distances = clip_plane_distances(end)?;
let mut enter = 0.0_f32;
let mut exit = 1.0_f32;
for (start_distance, end_distance) in start_distances.into_iter().zip(end_distances) {
if start_distance < 0.0 && end_distance < 0.0 {
return Ok(None);
}
if start_distance < 0.0 || end_distance < 0.0 {
let denominator = start_distance - end_distance;
let amount = start_distance / denominator;
if !denominator.is_finite() || !amount.is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
if start_distance < 0.0 {
enter = enter.max(amount);
} else {
exit = exit.min(amount);
}
}
}
if enter > exit {
return Ok(None);
}
let clipped_start = shader_lerp_clip(start, end, enter)?;
let clipped_end = shader_lerp_clip(start, end, exit)?;
if clipped_start[3] <= 0.0 || clipped_end[3] <= 0.0 {
return Ok(None);
}
Ok(Some(ClippedEdgeCpu {
clip: [clipped_start, clipped_end],
enter,
exit,
}))
}
fn clip_plane_distances(clip: [f32; 4]) -> Result<[f32; 6], Mesh3dRenderError> {
let add = |left: f32, right: f32| {
let result = left + right;
result
.is_finite()
.then_some(result)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)
};
let subtract = |left: f32, right: f32| {
let result = left - right;
result
.is_finite()
.then_some(result)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)
};
Ok([
add(clip[3], clip[0])?,
subtract(clip[3], clip[0])?,
add(clip[3], clip[1])?,
subtract(clip[3], clip[1])?,
clip[2],
subtract(clip[3], clip[2])?,
])
}
fn shader_lerp_clip(
start: [f32; 4],
end: [f32; 4],
amount: f32,
) -> Result<[f32; 4], Mesh3dRenderError> {
let mut output = [0.0_f32; 4];
for axis in 0..4 {
let delta = end[axis] - start[axis];
let value = start[axis] + delta * amount;
if !delta.is_finite() || !value.is_finite() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
output[axis] = value;
}
Ok(output)
}
#[derive(Debug, Clone, Copy)]
struct EdgeRasterEnvelope {
physical_half_width: f32,
raster_half_width: f32,
}
fn edge_raster_envelope(
logical_width: LogicalPixels,
pixels_per_logical: PhysicalPerLogical,
) -> Option<EdgeRasterEnvelope> {
let logical_width = logical_width.get();
let pixels_per_logical = pixels_per_logical.get();
if !is_portable_shader_source(logical_width) || !is_portable_shader_source(pixels_per_logical) {
return None;
}
let physical_half_width_f64 = f64::from(logical_width) * f64::from(pixels_per_logical) * 0.5;
let raster_half_width_f64 = (physical_half_width_f64 + 0.5).max(1.0);
let maximum = f64::from(MAX_PORTABLE_SHADER_VALUE);
if !physical_half_width_f64.is_finite()
|| physical_half_width_f64 <= 0.0
|| raster_half_width_f64 * 2.0 > maximum
{
return None;
}
let physical_half_width = logical_width * pixels_per_logical * 0.5;
let raster_half_width = (physical_half_width + 0.5).max(1.0);
let doubled_raster_width = raster_half_width * 2.0;
(physical_half_width.is_finite()
&& physical_half_width > 0.0
&& raster_half_width.is_finite()
&& doubled_raster_width.is_finite())
.then_some(EdgeRasterEnvelope {
physical_half_width,
raster_half_width,
})
}
fn validate_edge_shader_arithmetic(
clipped: EdgeClipRanges,
viewport: [f32; 4],
raster: EdgeRasterEnvelope,
dash_period: Option<f32>,
) -> Result<(), Mesh3dRenderError> {
let maximum_screen_length = f64::from(viewport[0]).hypot(f64::from(viewport[1]))
* (1.0 + 8.0 * f64::from(f32::EPSILON));
let logical_distance = maximum_screen_length / f64::from(viewport[2]);
if !maximum_screen_length.is_finite()
|| !logical_distance.is_finite()
|| logical_distance > f64::from(MAX_PORTABLE_SHADER_VALUE)
|| !(raster.physical_half_width + 0.5).is_finite()
|| !(raster.raster_half_width * 2.0).is_finite()
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
if let Some(period) = dash_period {
let repetition = logical_distance / f64::from(period);
let repeated_distance = repetition.floor() * f64::from(period);
let within_period = logical_distance - repeated_distance;
if !period.is_finite()
|| period <= 0.0
|| !repetition.is_finite()
|| !repeated_distance.is_finite()
|| !within_period.is_finite()
|| repetition.abs() > f64::from(MAX_PORTABLE_SHADER_VALUE)
|| repeated_distance.abs() > f64::from(MAX_PORTABLE_SHADER_VALUE)
|| within_period.abs() > f64::from(MAX_PORTABLE_SHADER_VALUE)
{
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
}
let dimensions = [viewport[0].max(1.0), viewport[1].max(1.0)];
for axis in 0..2 {
let normalized_component_bound = 1.0 + 4.0 * f64::from(f32::EPSILON);
let screen_offset = rounded_f32_product_range(
(-normalized_component_bound, normalized_component_bound),
(
f64::from(raster.raster_half_width),
f64::from(raster.raster_half_width),
),
)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let doubled_screen_offset = rounded_f32_product_range(screen_offset, (2.0, 2.0))
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
let ndc_offset = wgsl_division_range(
doubled_screen_offset,
(f64::from(dimensions[axis]), f64::from(dimensions[axis])),
)
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
for endpoint in clipped {
let offset = rounded_f32_product_range(ndc_offset, endpoint[3])
.ok_or(Mesh3dRenderError::InvalidEdgeProjection)?;
if rounded_f32_add_range(endpoint[axis], offset, false).is_none() {
return Err(Mesh3dRenderError::InvalidEdgeProjection);
}
}
}
Ok(())
}
#[derive(Debug, Clone, Copy)]
struct ShaderValueRange {
fixed: f32,
minimum: f64,
maximum: f64,
}
impl ShaderValueRange {
fn exact(value: f32) -> Self {
Self {
fixed: value,
minimum: f64::from(value),
maximum: f64::from(value),
}
}
}
fn shader_dot_range(
row: [f32; 4],
point: [ShaderValueRange; 4],
) -> Result<ShaderValueRange, Mesh3dRenderError> {
for axis in 0..4 {
if !is_portable_shader_source(row[axis])
|| !is_portable_shader_source(point[axis].fixed)
|| point[axis].minimum < -f64::from(MAX_PORTABLE_SHADER_VALUE)
|| point[axis].maximum > f64::from(MAX_PORTABLE_SHADER_VALUE)
|| (point[axis].minimum != 0.0
&& point[axis].minimum.abs() < f64::from(f32::MIN_POSITIVE))
|| (point[axis].maximum != 0.0
&& point[axis].maximum.abs() < f64::from(f32::MIN_POSITIVE))
{
return Err(Mesh3dRenderError::InvalidGeometryTransform);
}
}
let terms: [(f64, f64); 4] = std::array::from_fn(|axis| {
interval_products_f64(row[axis], point[axis].minimum, point[axis].maximum)
});
let (minimum, maximum) =
shader_interval_sum_range(terms).ok_or(Mesh3dRenderError::InvalidGeometryTransform)?;
let mut result = 0.0_f32;
for axis in 0..4 {
let product = row[axis] * point[axis].fixed;
result += product;
if !product.is_finite() || !result.is_finite() {
return Err(Mesh3dRenderError::InvalidGeometryTransform);
}
}
Ok(ShaderValueRange {
fixed: result,
minimum,
maximum,
})
}
#[cfg(test)]
fn shader_dot(row: [f32; 4], point: [f32; 4]) -> Result<f32, Mesh3dRenderError> {
shader_dot_range(row, point.map(ShaderValueRange::exact)).map(|value| value.fixed)
}
#[cfg(test)]
fn encode_scene_pass(
encoder: &mut wgpu::CommandEncoder,
renderer: &Mesh3dRenderer,
color_view: &wgpu::TextureView,
depth_view: &wgpu::TextureView,
background: Color,
instances: &[Mesh3dInstance],
) {
encode_ordered_scene_pass(
encoder,
renderer,
color_view,
depth_view,
background,
instances,
&[],
None,
);
}
#[allow(clippy::too_many_arguments)]
fn encode_ordered_scene_pass(
encoder: &mut wgpu::CommandEncoder,
renderer: &Mesh3dRenderer,
color_view: &wgpu::TextureView,
depth_view: &wgpu::TextureView,
background: Color,
instances: &[Mesh3dInstance],
order: &[material::SurfaceDraw],
timestamp_writes: Option<wgpu::RenderPassTimestampWrites<'_>>,
) {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("sim-engine retained 3D mesh pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: color_view,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(premultiplied_wgpu_color(background)),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: depth_view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
timestamp_writes,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&renderer.pipeline);
pass.set_bind_group(0, &renderer.camera_bind_group, &[]);
let mut insertion = instances
.iter()
.filter(|instance| instance.visible)
.enumerate();
let mut sorted = order.iter();
loop {
let next = if order.is_empty() {
insertion.next()
} else {
sorted
.next()
.map(|entry| (entry.visible_index, &instances[entry.scene_index]))
};
let Some((instance_index, instance)) = next else {
break;
};
if instance.style.surface_style().is_none() || instance.mesh.index_count == 0 {
continue;
}
let instance_start =
(instance_index * std::mem::size_of::<MeshInstanceGpu>()) as wgpu::BufferAddress;
let instance_end =
instance_start + std::mem::size_of::<MeshInstanceGpu>() as wgpu::BufferAddress;
let Some(surface_style) = instance.style.surface_style() else {
continue;
};
let material = instance.mesh.material();
let colored = instance.mesh.color_buffer.is_some();
if let Some(material) = material {
pass.set_bind_group(1, material.bind_group(), &[]);
}
let object = renderer.clipped_surface_objects.get(instance_index);
if let Some(range) = object.and_then(|object| object.generated.as_ref()) {
if range.is_empty() {
continue;
}
let Some(buffer) = &renderer.clipped_surface_buffer else {
continue;
};
let pipelines = match (material.is_some(), colored) {
(false, false) => &renderer.clipped_surface_pipeline,
(false, true) => &renderer.colored_clipped_pipeline,
(true, false) => &renderer.textures.clipped_pipeline,
(true, true) => &renderer.textures.colored_clipped_pipeline,
};
pass.set_pipeline(pipelines.for_style(surface_style));
let stride = std::mem::size_of::<SurfaceClipVertex>() as u64;
pass.set_vertex_buffer(
0,
buffer.slice(u64::from(range.start) * stride..u64::from(range.end) * stride),
);
pass.set_vertex_buffer(
1,
renderer.instance_buffer.slice(instance_start..instance_end),
);
if let (Some(buffer), Some(colors)) = (
&renderer.clipped_color_buffer,
object.and_then(|object| object.generated_colors.as_ref()),
) {
let stride = std::mem::size_of::<MeshColorGpu>() as u64;
pass.set_vertex_buffer(
2,
buffer.slice(u64::from(colors.start) * stride..u64::from(colors.end) * stride),
);
}
if let (Some(buffer), Some(lighting)) = (
&renderer.clipped_lighting_buffer,
object.and_then(|object| object.generated_lighting.as_ref()),
) {
let stride = std::mem::size_of::<SurfaceLightingVertex>() as u64;
pass.set_vertex_buffer(
2 + u32::from(colored),
buffer.slice(
u64::from(lighting.start) * stride..u64::from(lighting.end) * stride,
),
);
}
pass.draw(0..range.end - range.start, 0..1);
continue;
}
let Some(index_buffer) = &instance.mesh.index_buffer else {
continue;
};
let pipelines = match (material.is_some(), colored) {
(false, false) => &renderer.pipeline,
(false, true) => &renderer.colored_pipeline,
(true, false) => &renderer.textures.retained_pipeline,
(true, true) => &renderer.textures.colored_retained_pipeline,
};
pass.set_pipeline(pipelines.for_style(surface_style));
pass.set_vertex_buffer(0, instance.mesh.vertex_buffer.slice(..));
let instance_slot = if material.is_some() {
if let Some(coordinates) = &instance.mesh.texture_coordinate_buffer {
pass.set_vertex_buffer(1, coordinates.slice(..));
}
2
} else {
1
};
pass.set_vertex_buffer(
instance_slot,
renderer.instance_buffer.slice(instance_start..instance_end),
);
if let Some(buffer) = &instance.mesh.color_buffer {
pass.set_vertex_buffer(instance_slot + 1, buffer.slice(..));
}
if surface_style.lighting() == SurfaceLighting3d::Lambert
&& let Some(buffer) = &instance.mesh.normal_buffer
{
pass.set_vertex_buffer(instance_slot + 1 + u32::from(colored), buffer.slice(..));
}
pass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint32);
pass.draw_indexed(0..instance.mesh.index_count, 0, 0..1);
}
pass.set_pipeline(&renderer.hidden_edge_pipeline);
for (object_index, instance) in instances
.iter()
.filter(|instance| instance.visible)
.enumerate()
{
let Some(style) = instance.wireframe() else {
continue;
};
let Some(edge_buffer) = instance.mesh.edge_buffer.as_ref() else {
continue;
};
if !style.hidden_enabled() || instance.mesh.edge_count == 0 {
continue;
}
let dynamic_offset = (object_index * renderer.edge_object_stride) as u32;
pass.set_bind_group(1, &renderer.edge_object_bind_group, &[dynamic_offset]);
if let Some(range) = renderer
.clipped_surface_objects
.get(object_index)
.and_then(|object| object.generated_edges.as_ref())
{
if let Some(buffer) = &renderer.clipped_edge_buffer
&& !range.is_empty()
{
pass.set_pipeline(&renderer.clipped_hidden_edge_pipeline);
pass.set_vertex_buffer(0, buffer.slice(..));
pass.draw(0..6, range.clone());
}
continue;
}
pass.set_pipeline(&renderer.hidden_edge_pipeline);
pass.set_vertex_buffer(0, edge_buffer.slice(..));
pass.draw(0..6, 0..instance.mesh.edge_count);
}
pass.set_pipeline(&renderer.visible_edge_pipeline);
for (object_index, instance) in instances
.iter()
.filter(|instance| instance.visible)
.enumerate()
{
if instance.wireframe().is_none() || instance.mesh.edge_count == 0 {
continue;
}
let Some(edge_buffer) = instance.mesh.edge_buffer.as_ref() else {
continue;
};
let dynamic_offset = (object_index * renderer.edge_object_stride) as u32;
pass.set_bind_group(1, &renderer.edge_object_bind_group, &[dynamic_offset]);
if let Some(range) = renderer
.clipped_surface_objects
.get(object_index)
.and_then(|object| object.generated_edges.as_ref())
{
if let Some(buffer) = &renderer.clipped_edge_buffer
&& !range.is_empty()
{
pass.set_pipeline(&renderer.clipped_visible_edge_pipeline);
pass.set_vertex_buffer(0, buffer.slice(..));
pass.draw(0..6, range.clone());
}
continue;
}
pass.set_pipeline(&renderer.visible_edge_pipeline);
pass.set_vertex_buffer(0, edge_buffer.slice(..));
pass.draw(0..6, 0..instance.mesh.edge_count);
}
}
#[cfg(test)]
pub(super) fn assert_gpu_depth_contract(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
) {
dynamic::assert_gpu_dynamic_contract(device, queue, format);
vertex_color_tests::assert_gpu_vertex_color_contract(device, queue, format);
material_tests::assert_gpu_material_contract(device, queue, format);
lighting_tests::assert_gpu_lighting_contract(device, queue, format);
material_resource_tests::assert_gpu_sort_budget(device, queue, format);
color_budget_tests::assert_gpu_color_budget(device, queue, format);
surface::assert_gpu_surface_contract(device, queue, format);
surface::assert_gpu_native_surface_policy(device, queue, format);
surface::assert_gpu_native_edge_validation(device, queue, format);
texture::assert_gpu_texture_contract(device, queue, format);
texture::assert_gpu_texture_lifecycle(device, queue, format);
native_acceptance_tests::assert_gpu_native_acceptance(device, queue, format);
assert_gpu_clip_equivalence(device, queue);
let identity = Arc::new(());
let mut renderer = Mesh3dRenderer::new(device, format);
let vertices = vec![
Vec3::new(-1.0, -1.0, 0.0).unwrap(),
Vec3::new(1.0, -1.0, 0.0).unwrap(),
Vec3::new(0.0, 1.0, 0.0).unwrap(),
];
let near_triangle = Mesh3d::with_display_edges(
vertices.clone(),
vec![0, 1, 2],
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let far_triangle = Mesh3d::with_display_edges(
vertices,
vec![0, 1, 2],
vec![MeshEdge3d::new(0, 2).unwrap()],
)
.unwrap();
let near_mesh = create_retained_mesh(device, queue, Arc::clone(&identity), near_triangle)
.expect("3D test mesh should upload");
let far_mesh = create_retained_mesh(device, queue, Arc::clone(&identity), far_triangle)
.expect("3D test mesh should upload");
let near_crossing_edge = Mesh3d::with_display_edges(
vec![
Vec3::new(0.0, 0.0, 4.95).unwrap(),
Vec3::new(0.5, 0.5, 4.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let near_crossing_mesh =
create_retained_mesh(device, queue, Arc::clone(&identity), near_crossing_edge)
.expect("near-crossing 3D test edge should upload");
let classification_edge = Mesh3d::with_display_edges(
vec![
Vec3::new(-0.5, -0.5, 0.0).unwrap(),
Vec3::new(0.5, -0.5, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let classification_mesh =
create_retained_mesh(device, queue, Arc::clone(&identity), classification_edge)
.expect("classification test edge should upload");
let projection = Projection3d::perspective(0.927_295_2, 1.0, world(0.1), world(20.0)).unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 5.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
projection,
)
.unwrap();
let camera_uniform = Camera3dUniform::new(camera, 64, 64, physical_per_logical(1.0)).unwrap();
let near_transform = Transform3d::new(
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let far_transform = Transform3d::new(
Vec3::new(0.0, 0.0, -1.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let mut scene = Scene3d::new(Color::BLACK).unwrap();
let near_id = scene
.try_push(
&near_mesh,
near_transform,
MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::rgb(0.0, 1.0, 0.0)).unwrap())
.with_wireframe(
WireframeStyle3d::visible(Color::rgb(0.0, 0.0, 1.0), logical(2.0))
.unwrap()
.with_hidden(
Color::rgb(1.0, 0.0, 1.0),
logical(2.0),
logical(4.0),
logical(4.0),
)
.unwrap(),
),
)
.unwrap();
let mut other_scene = Scene3d::new(Color::BLACK).unwrap();
let other_scene_id = other_scene
.try_push(
&near_mesh,
Transform3d::IDENTITY,
MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::WHITE).unwrap()),
)
.unwrap();
assert_eq!(near_id.get(), other_scene_id.get());
assert_ne!(near_id, other_scene_id);
assert_eq!(
other_scene.set_visible(near_id, false),
Err(Scene3dError::ObjectNotFound { object_id: near_id })
);
assert_eq!(other_scene.visible_object_count(), 1);
assert_eq!(
scene.set_visible(other_scene_id, false),
Err(Scene3dError::ObjectNotFound {
object_id: other_scene_id,
})
);
assert_eq!(scene.visible_object_count(), 1);
let far_id = scene
.try_push(
&far_mesh,
far_transform,
MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::rgb(1.0, 0.0, 0.0)).unwrap())
.with_wireframe(
WireframeStyle3d::visible(Color::rgb(1.0, 0.0, 0.0), logical(2.0))
.unwrap()
.with_hidden(Color::WHITE, logical(2.0), logical(4.0), logical(4.0))
.unwrap(),
),
)
.unwrap();
scene
.try_push(
&near_crossing_mesh,
Transform3d::IDENTITY,
MeshStyle3d::wireframe(
WireframeStyle3d::visible(Color::rgb(1.0, 1.0, 0.0), logical(2.0)).unwrap(),
),
)
.unwrap();
let coplanar_transform = Transform3d::new(
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
scene
.try_push(
&classification_mesh,
coplanar_transform,
MeshStyle3d::wireframe(
WireframeStyle3d::visible(Color::rgb(0.0, 1.0, 1.0), logical(2.0))
.unwrap()
.with_hidden(
Color::rgb(1.0, 0.0, 1.0),
logical(2.0),
logical(4.0),
logical(4.0),
)
.unwrap(),
),
)
.unwrap();
let sub_depth_resolution_transform = Transform3d::new(
Vec3::new(0.0, 0.2, 0.999_999).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
scene
.try_push(
&classification_mesh,
sub_depth_resolution_transform,
MeshStyle3d::wireframe(
WireframeStyle3d::visible(Color::rgb(1.0, 0.5, 0.0), logical(2.0))
.unwrap()
.with_hidden(
Color::rgb(1.0, 0.0, 1.0),
logical(2.0),
logical(4.0),
logical(4.0),
)
.unwrap(),
),
)
.unwrap();
let moved_near_transform = Transform3d::new(
Vec3::new(0.25, 0.0, 1.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
scene.set_transform(near_id, moved_near_transform).unwrap();
assert_eq!(scene.instances()[0].transform(), moved_near_transform);
assert_eq!(scene.instances()[1].transform(), far_transform);
assert_eq!(scene.instances()[1].id(), far_id);
scene.set_visible(far_id, false).unwrap();
assert_eq!(scene.visible_object_count(), 4);
scene.set_visible(far_id, true).unwrap();
assert_eq!(scene.visible_object_count(), 5);
scene.set_transform(near_id, near_transform).unwrap();
renderer
.ensure_frame_capacity(device, scene.object_count())
.unwrap();
renderer.instances = scene
.instances()
.iter()
.map(|instance| {
let rows = instance.transform.model_rows().unwrap();
MeshInstanceGpu {
normal_row_0: [0.0; 4],
normal_row_1: [0.0; 4],
normal_row_2: [0.0; 4],
model_row_0: rows[0],
model_row_1: rows[1],
model_row_2: rows[2],
surface: material::surface_parameters(instance.style.surface_style()),
uv_transform: texture::material_uv_parameters(instance.mesh.material()),
color: instance
.style
.surface_style()
.map_or(Color::BLACK, SurfaceStyle3d::color)
.to_array(),
}
})
.collect();
renderer
.edge_object_bytes
.resize(scene.object_count() * renderer.edge_object_stride, 0);
let near_rows = near_transform.model_rows().unwrap();
let near_edge_uniform = EdgeObjectUniform {
model_row_0: near_rows[0],
model_row_1: near_rows[1],
model_row_2: near_rows[2],
visible_color: Color::rgb(0.0, 0.0, 1.0).to_array(),
hidden_color: Color::rgb(1.0, 0.0, 1.0).to_array(),
edge_style: [2.0, 2.0, 4.0, 4.0],
};
renderer.edge_object_bytes[..std::mem::size_of::<EdgeObjectUniform>()]
.copy_from_slice(bytemuck::bytes_of(&near_edge_uniform));
let far_rows = far_transform.model_rows().unwrap();
let far_edge_uniform = EdgeObjectUniform {
model_row_0: far_rows[0],
model_row_1: far_rows[1],
model_row_2: far_rows[2],
visible_color: Color::rgb(1.0, 0.0, 0.0).to_array(),
hidden_color: Color::WHITE.to_array(),
edge_style: [2.0, 2.0, 4.0, 4.0],
};
let edge_start = renderer.edge_object_stride;
let edge_end = edge_start + std::mem::size_of::<EdgeObjectUniform>();
renderer.edge_object_bytes[edge_start..edge_end]
.copy_from_slice(bytemuck::bytes_of(&far_edge_uniform));
let crossing_rows = Transform3d::IDENTITY.model_rows().unwrap();
let crossing_edge_uniform = EdgeObjectUniform {
model_row_0: crossing_rows[0],
model_row_1: crossing_rows[1],
model_row_2: crossing_rows[2],
visible_color: Color::rgb(1.0, 1.0, 0.0).to_array(),
hidden_color: Color::rgb(1.0, 1.0, 0.0).to_array(),
edge_style: [2.0, 0.0, 1.0, 1.0],
};
let crossing_edge_start = 2 * renderer.edge_object_stride;
let crossing_edge_end = crossing_edge_start + std::mem::size_of::<EdgeObjectUniform>();
renderer.edge_object_bytes[crossing_edge_start..crossing_edge_end]
.copy_from_slice(bytemuck::bytes_of(&crossing_edge_uniform));
let coplanar_rows = coplanar_transform.model_rows().unwrap();
let coplanar_edge_uniform = EdgeObjectUniform {
model_row_0: coplanar_rows[0],
model_row_1: coplanar_rows[1],
model_row_2: coplanar_rows[2],
visible_color: Color::rgb(0.0, 1.0, 1.0).to_array(),
hidden_color: Color::rgb(1.0, 0.0, 1.0).to_array(),
edge_style: [2.0, 2.0, 4.0, 4.0],
};
let coplanar_edge_start = 3 * renderer.edge_object_stride;
let coplanar_edge_end = coplanar_edge_start + std::mem::size_of::<EdgeObjectUniform>();
renderer.edge_object_bytes[coplanar_edge_start..coplanar_edge_end]
.copy_from_slice(bytemuck::bytes_of(&coplanar_edge_uniform));
let sub_depth_rows = sub_depth_resolution_transform.model_rows().unwrap();
let sub_depth_edge_uniform = EdgeObjectUniform {
model_row_0: sub_depth_rows[0],
model_row_1: sub_depth_rows[1],
model_row_2: sub_depth_rows[2],
visible_color: Color::rgb(1.0, 0.5, 0.0).to_array(),
hidden_color: Color::rgb(1.0, 0.0, 1.0).to_array(),
edge_style: [2.0, 2.0, 4.0, 4.0],
};
let sub_depth_edge_start = 4 * renderer.edge_object_stride;
let sub_depth_edge_end = sub_depth_edge_start + std::mem::size_of::<EdgeObjectUniform>();
renderer.edge_object_bytes[sub_depth_edge_start..sub_depth_edge_end]
.copy_from_slice(bytemuck::bytes_of(&sub_depth_edge_uniform));
queue.write_buffer(
&renderer.camera_uniform_buffer,
0,
bytemuck::bytes_of(&camera_uniform),
);
queue.write_buffer(
&renderer.instance_buffer,
0,
bytemuck::cast_slice(&renderer.instances),
);
queue.write_buffer(&renderer.edge_object_buffer, 0, &renderer.edge_object_bytes);
let color_texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("sim-engine 3D depth test color"),
size: wgpu::Extent3d {
width: 64,
height: 64,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let color_view = color_texture.create_view(&wgpu::TextureViewDescriptor::default());
let depth_texture = create_depth_texture(device, 64, 64);
let depth_view = depth_texture.create_view(&wgpu::TextureViewDescriptor::default());
let readback = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D depth test readback"),
size: 256 * 64,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("sim-engine 3D depth test encoder"),
});
encode_scene_pass(
&mut encoder,
&renderer,
&color_view,
&depth_view,
Color::BLACK,
scene.instances(),
);
encoder.copy_texture_to_buffer(
wgpu::TexelCopyTextureInfo {
texture: &color_texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyBufferInfo {
buffer: &readback,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(256),
rows_per_image: Some(64),
},
},
wgpu::Extent3d {
width: 64,
height: 64,
depth_or_array_layers: 1,
},
);
queue.submit([encoder.finish()]);
device
.poll(wgpu::PollType::wait_indefinitely())
.expect("3D depth test submission should complete");
let slice = readback.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
sender.send(result).unwrap();
});
device
.poll(wgpu::PollType::wait_indefinitely())
.expect("3D depth test mapping should complete");
receiver
.recv_timeout(Duration::from_secs(5))
.expect("3D depth test callback should run")
.expect("3D depth readback should map");
let bytes = slice.get_mapped_range().expect("3D depth bytes");
let [red, green, blue] = match format {
wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Rgba8UnormSrgb => [0, 1, 2],
wgpu::TextureFormat::Bgra8Unorm | wgpu::TextureFormat::Bgra8UnormSrgb => [2, 1, 0],
_ => panic!("unsupported 3D byte-channel oracle format: {format:?}"),
};
let center_offset = 32 * 256 + 32 * 4;
assert!(
bytes[center_offset + green] > 200,
"near green surface must win depth testing"
);
assert!(
bytes[center_offset + red] < 20,
"far red surface must remain occluded"
);
for x in 20..44 {
let offset = 48 * 256 + x * 4;
assert!(
bytes[offset + blue] > 180 && bytes[offset + red] < 80,
"coplanar near edge must remain solid visible blue at x={x}"
);
}
let mut hidden_pattern = Vec::new();
for step in 1..20 {
let amount = step as f32 / 20.0;
let x = (21.33 + (32.0 - 21.33) * amount).round() as usize;
let y = (42.67 + (21.33 - 42.67) * amount).round() as usize;
let offset = y * 256 + x * 4;
hidden_pattern
.push(bytes[offset] > 220 && bytes[offset + 1] > 220 && bytes[offset + 2] > 220);
}
assert!(
hidden_pattern.windows(2).any(|pair| pair == [true, false])
&& hidden_pattern.windows(2).any(|pair| pair == [false, true]),
"hidden edge must alternate ordered white dashes and gaps: {hidden_pattern:?}"
);
let near_clipped_yellow_pixels = bytes
.chunks_exact(4)
.filter(|pixel| pixel[red] > 180 && pixel[green] > 180 && pixel[blue] < 80)
.count();
assert!(
near_clipped_yellow_pixels >= 4,
"edge crossing the near plane must remain visible after homogeneous clipping: {near_clipped_yellow_pixels} yellow pixels"
);
let different_object_coplanar_pixels = bytes
.chunks_exact(4)
.filter(|pixel| pixel[red] < 80 && pixel[green] > 180 && pixel[blue] > 180)
.count();
assert!(
different_object_coplanar_pixels >= 4,
"a coplanar edge from another object must resolve visible: {different_object_coplanar_pixels} cyan pixels"
);
let sub_depth_resolution_pixels = bytes
.chunks_exact(4)
.filter(|pixel| pixel[red] > 180 && pixel[green] > 100 && pixel[blue] < 80)
.count();
assert!(
sub_depth_resolution_pixels >= 4,
"sub-depth-resolution separation must conservatively resolve visible: {sub_depth_resolution_pixels} orange pixels"
);
drop(bytes);
readback.unmap();
}
#[cfg(test)]
pub(super) fn assert_gpu_scene_recovery_contract(
source_device: &wgpu::Device,
source_queue: &wgpu::Queue,
recovery_device: &wgpu::Device,
recovery_queue: &wgpu::Queue,
format: wgpu::TextureFormat,
) {
texture::assert_dev5_contract(
source_device,
source_queue,
recovery_device,
recovery_queue,
format,
);
texture::assert_gpu_texture_lifecycle_recovery(
source_device,
source_queue,
recovery_device,
recovery_queue,
format,
);
dynamic::assert_gpu_dynamic_recovery(
source_device,
source_queue,
recovery_device,
recovery_queue,
);
material_resource_tests::assert_gpu_alpha_recovery(
source_device,
source_queue,
recovery_device,
recovery_queue,
);
lifetime_tests::assert_lifetime_contract(
source_device,
source_queue,
recovery_device,
recovery_queue,
);
surface::assert_gpu_clipped_recovery(
source_device,
source_queue,
recovery_device,
recovery_queue,
);
texture::assert_gpu_textured_recovery(
source_device,
source_queue,
recovery_device,
recovery_queue,
);
let source_identity = Arc::new(());
let recovery_identity = Arc::new(());
let topology = Mesh3d::with_display_edges(
vec![
Vec3::new(-0.5, -0.5, 0.0).unwrap(),
Vec3::new(0.5, -0.5, 0.0).unwrap(),
Vec3::new(0.0, 0.5, 0.0).unwrap(),
],
vec![0, 1, 2],
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let source_mesh = create_retained_mesh(
source_device,
source_queue,
Arc::clone(&source_identity),
topology,
)
.unwrap();
let transform_a = Transform3d::IDENTITY;
let transform_b = Transform3d::new(
Vec3::new(1.0, 2.0, 3.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(2.0, 2.0, 2.0).unwrap(),
)
.unwrap();
let style = MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::WHITE).unwrap())
.with_wireframe(WireframeStyle3d::visible(Color::BLACK, logical(1.0)).unwrap());
let mut scene = Scene3d::new(Color::BLACK).unwrap();
let first_id = scene.try_push(&source_mesh, transform_a, style).unwrap();
let second_id = scene.try_push(&source_mesh, transform_b, style).unwrap();
scene.set_visible(second_id, false).unwrap();
assert_eq!(
validate_mesh_identity(&recovery_identity, scene.instances()[0].mesh()),
Err(Mesh3dRenderError::RendererMismatch)
);
let report = restore_scene3d_resources(
recovery_device,
recovery_queue,
&Mesh3dRenderer::new(recovery_device, wgpu::TextureFormat::Rgba8UnormSrgb)
.textures
.layout,
Arc::clone(&recovery_identity),
&mut scene,
)
.unwrap();
assert_eq!(report.object_count(), 2);
assert_eq!(report.migrated_object_count(), 2);
assert_eq!(report.restored_mesh_count(), 1);
assert_eq!(
report.restored_gpu_bytes(),
source_mesh.gpu_allocation_bytes()
);
assert_eq!(scene.instances()[0].id(), first_id);
assert_eq!(scene.instances()[1].id(), second_id);
assert_eq!(scene.instances()[0].transform(), transform_a);
assert_eq!(scene.instances()[1].transform(), transform_b);
assert_eq!(scene.instances()[0].style(), style);
assert_eq!(scene.instances()[1].style(), style);
assert!(scene.instances()[0].is_visible());
assert!(!scene.instances()[1].is_visible());
assert!(Arc::ptr_eq(
&scene.instances()[0].mesh.vertex_buffer,
&scene.instances()[1].mesh.vertex_buffer,
));
for instance in scene.instances() {
assert_eq!(
validate_mesh_identity(&recovery_identity, instance.mesh()),
Ok(())
);
assert_eq!(
validate_mesh_identity(&source_identity, instance.mesh()),
Err(Mesh3dRenderError::RendererMismatch)
);
}
let no_op_report = restore_scene3d_resources(
recovery_device,
recovery_queue,
&Mesh3dRenderer::new(recovery_device, wgpu::TextureFormat::Rgba8UnormSrgb)
.textures
.layout,
recovery_identity,
&mut scene,
)
.unwrap();
assert_eq!(no_op_report.object_count(), 2);
assert_eq!(no_op_report.migrated_object_count(), 0);
assert_eq!(no_op_report.restored_mesh_count(), 0);
assert_eq!(no_op_report.restored_gpu_bytes(), 0);
}
#[cfg(test)]
fn assert_gpu_clip_equivalence(device: &wgpu::Device, queue: &wgpu::Queue) {
let inputs = seeded_clip_probe_inputs();
let input_bytes = bytemuck::cast_slice(&inputs);
let output_size = (inputs.len() * std::mem::size_of::<ClipProbeOutputGpu>()) as u64;
let input_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D clip probe input"),
size: input_bytes.len() as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D clip probe output"),
size: output_size,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let readback = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sim-engine 3D clip probe readback"),
size: output_size,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
queue.write_buffer(&input_buffer, 0, input_bytes);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sim-engine 3D clip equivalence shader"),
source: wgpu::ShaderSource::Wgsl(lighting::shader_source(include_str!("mesh3d.wgsl"))),
});
let empty_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sim-engine empty clip probe layout"),
entries: &[],
});
let probe_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sim-engine 3D clip probe layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: false },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sim-engine 3D clip probe pipeline layout"),
bind_group_layouts: &[
Some(&empty_layout),
Some(&empty_layout),
Some(&probe_layout),
],
immediate_size: 0,
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("sim-engine 3D clip probe pipeline"),
layout: Some(&pipeline_layout),
module: &shader,
entry_point: Some("mesh3d_clip_probe_main"),
compilation_options: wgpu::PipelineCompilationOptions::default(),
cache: None,
});
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("sim-engine 3D clip probe bind group"),
layout: &probe_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: input_buffer.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: output_buffer.as_entire_binding(),
},
],
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("sim-engine 3D clip probe encoder"),
});
{
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("sim-engine 3D clip probe pass"),
timestamp_writes: None,
});
pass.set_pipeline(&pipeline);
pass.set_bind_group(2, &bind_group, &[]);
pass.dispatch_workgroups((inputs.len() as u32).div_ceil(64), 1, 1);
}
encoder.copy_buffer_to_buffer(&output_buffer, 0, &readback, 0, output_size);
queue.submit([encoder.finish()]);
device
.poll(wgpu::PollType::wait_indefinitely())
.expect("3D clip probe submission should complete");
let slice = readback.slice(..);
let (sender, receiver) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |result| {
sender.send(result).unwrap();
});
device
.poll(wgpu::PollType::wait_indefinitely())
.expect("3D clip probe mapping should complete");
receiver
.recv_timeout(Duration::from_secs(5))
.expect("3D clip probe callback should run")
.expect("3D clip probe readback should map");
let bytes = slice.get_mapped_range().expect("3D clip probe bytes");
let outputs: &[ClipProbeOutputGpu] = bytemuck::cast_slice(&bytes);
for (case_index, (input, actual)) in inputs.iter().zip(outputs).enumerate() {
let expected = clip_edge_to_frustum_details(input.start_clip, input.end_clip)
.expect("finite seeded clip input should not overflow after normalization");
assert_eq!(
actual.visible,
u32::from(expected.is_some()),
"CPU/WGSL clip visibility differs for seeded case {case_index}: {input:?}"
);
let Some(expected) = expected else {
continue;
};
for (actual, expected) in actual
.start_clip
.into_iter()
.chain(actual.end_clip)
.chain(actual.range)
.zip(
expected.clip[0]
.into_iter()
.chain(expected.clip[1])
.chain([expected.enter, expected.exit]),
)
{
let tolerance = 32.0 * f32::EPSILON * expected.abs().max(1.0);
assert!(
(actual - expected).abs() <= tolerance,
"CPU/WGSL clip value differs for seeded case {case_index}: actual={actual}, expected={expected}, tolerance={tolerance}, input={input:?}"
);
}
}
drop(bytes);
readback.unmap();
}
#[cfg(test)]
fn seeded_clip_probe_inputs() -> Vec<ClipProbeInputGpu> {
let maximum = MAX_PORTABLE_SHADER_VALUE;
let mut inputs = vec![
ClipProbeInputGpu {
start_clip: [0.0, 0.0, 0.5, 1.0],
end_clip: [0.5, 0.5, 0.75, 1.0],
},
ClipProbeInputGpu {
start_clip: [-2.0, 0.0, 0.5, 1.0],
end_clip: [0.5, 0.0, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, 0.5, 1.0],
end_clip: [2.0, 0.0, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, -2.0, 0.5, 1.0],
end_clip: [0.0, 0.5, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, 0.5, 1.0],
end_clip: [0.0, 2.0, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, -1.0, 1.0],
end_clip: [0.0, 0.0, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, 0.5, 1.0],
end_clip: [0.0, 0.0, 2.0, 1.0],
},
ClipProbeInputGpu {
start_clip: [-2.0, -2.0, 0.5, 1.0],
end_clip: [0.5, 0.5, 0.5, 1.0],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, 0.5, 1.0],
end_clip: [2.0, 2.0, 2.0, 1.0],
},
ClipProbeInputGpu {
start_clip: [-1.0, 1.0, 0.0, 1.0],
end_clip: [1.0, -1.0, 1.0, 1.0],
},
ClipProbeInputGpu {
start_clip: [maximum, 0.0, maximum * 0.5, maximum],
end_clip: [-maximum, maximum, maximum, maximum],
},
ClipProbeInputGpu {
start_clip: [0.0, 0.0, -maximum, -maximum],
end_clip: [0.0, 0.0, -maximum * 0.5, -maximum * 0.5],
},
];
let mut state = 0x5eed_c1a5_u32;
for _ in 0..244 {
let mut next_component = || {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
((state >> 8) as f32 / 16_777_215.0) * 4.0 - 2.0
};
inputs.push(ClipProbeInputGpu {
start_clip: [
next_component(),
next_component(),
next_component(),
next_component(),
],
end_clip: [
next_component(),
next_component(),
next_component(),
next_component(),
],
});
}
debug_assert_eq!(inputs.len(), 256);
inputs
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shader_transform_validation_rejects_finite_overflow() {
let maximum = f32::MAX;
let mesh = Mesh3d::new(
vec![
Vec3::new(maximum, 0.0, 0.0).unwrap(),
Vec3::new(maximum, 1.0, 0.0).unwrap(),
Vec3::new(maximum, 0.0, 1.0).unwrap(),
],
vec![0, 1, 2],
)
.unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::IDENTITY,
Vec3::new(maximum, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 5.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(4.0), 1.0, world(0.1), world(20.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_shader_transform(
&mesh,
transform.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_ftz_sensitive_vertex_operands() {
let largest_subnormal = f32::from_bits(0x007f_ffff);
let mesh = Mesh3d::with_display_edges(
vec![Vec3::ZERO, Vec3::new(largest_subnormal, 0.0, 0.0).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 2.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_shader_transform(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_subnormal_row_operands_uniformly() {
let largest_subnormal = f32::from_bits(0x007f_ffff);
let mesh = Mesh3d::with_display_edges(
vec![Vec3::ZERO, Vec3::new(0.0, 1.0, 0.0).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::IDENTITY,
Vec3::new(largest_subnormal, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 2.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_shader_transform(
&mesh,
transform.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_subnormal_source_absorbed_by_translation() {
let point = Vec3::new(f32::from_bits(1), 0.0, 0.0).unwrap();
let mesh = Mesh3d::with_display_edges(
vec![point, Vec3::new(0.5, 0.0, 0.0).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let transform = Transform3d::new(
Vec3::new(1.0, 0.0, 0.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, -4.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(4.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
let model_rows = transform.model_rows().unwrap();
let model_x = shader_dot_range(
model_rows[0],
[point.x(), point.y(), point.z(), 1.0].map(ShaderValueRange::exact),
);
assert!(matches!(
model_x,
Err(Mesh3dRenderError::InvalidGeometryTransform)
));
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera.world_to_clip_rows().unwrap()),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn surface_triangle_ftz_high_scale_is_rejected() {
let largest_subnormal = f32::from_bits(0x007f_ffff);
let mesh = Mesh3d::new(
vec![
Vec3::ZERO,
Vec3::new(largest_subnormal, 0.0, 0.0).unwrap(),
Vec3::new(0.0, largest_subnormal, 0.0).unwrap(),
],
vec![0, 1, 2],
)
.unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::IDENTITY,
Vec3::new(f32::MAX, f32::MAX, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 4.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(8.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_shader_transform(
&mesh,
transform.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_extreme_component_selection_after_interval_dot() {
let rotation = Rotation3d::from_euler_xyz(
0.0,
std::f32::consts::FRAC_PI_4,
-(1.0_f32 / 3.0_f32.sqrt()).asin(),
)
.unwrap();
let unit_rows = Transform3d::new(Vec3::ZERO, rotation, Vec3::new(1.0, 1.0, 1.0).unwrap())
.unwrap()
.model_rows()
.unwrap();
let first_scale = 1.0 / unit_rows[0][0];
let scale = Vec3::new(
f32::from_bits(first_scale.to_bits() + 1),
1.0 / unit_rows[0][1],
1.0 / unit_rows[0][2],
)
.unwrap();
let transform = Transform3d::new(Vec3::ZERO, rotation, scale).unwrap();
let model_rows = transform.model_rows().unwrap();
assert_eq!(model_rows[0], [1.0, 1.0, 1.0, 0.0]);
let point = Vec3::new(
f32::from_bits(0x7ea1_07f9),
f32::from_bits(0x7ecc_fe95),
f32::from_bits(0x7e91_f970),
)
.unwrap();
let mesh = Mesh3d::with_display_edges(
vec![point, point.checked_scale(0.5).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(1.0), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera.world_to_clip_rows().unwrap()),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_pairwise_dot_overflow_after_finite_cpu_transform() {
let maximum = f32::MAX;
let angle = 0.5_f32.acos();
let model_x = -0.2 * maximum;
let model_z = (0.51 * maximum) / angle.sin();
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(model_x, -1.0e30, model_z).unwrap(),
Vec3::new(model_x, 1.0e30, model_z).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let transform = Transform3d::new(
Vec3::new(0.51 * maximum, 0.0, 0.0).unwrap(),
Rotation3d::from_axis_angle(Vec3::Y, angle).unwrap(),
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let model_center = Vec3::new(model_x, 0.0, model_z).unwrap();
let world_center = transform.transform_point(model_center).unwrap();
assert!(
world_center.x().is_finite()
&& world_center.y().is_finite()
&& world_center.z().is_finite()
);
let camera = Camera3d::look_at(
Vec3::new(
world_center.x(),
world_center.y(),
world_center.z() - 1.0e32,
)
.unwrap(),
world_center,
Vec3::Y,
Projection3d::perspective(2.8, 1.0, world(1.0e30), world(1.0e34)).unwrap(),
)
.unwrap();
assert!(
camera
.project_world(world_center, LogicalViewport::new(64.0, 64.0).unwrap())
.unwrap()
.inside_view()
);
assert_eq!(
validate_shader_transform(
&mesh,
transform.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_propagates_model_association_range_into_camera_dot() {
let point = Vec3::new(-6.593_279_5e37, 2.460_645_7e38, 9.006_588e37).unwrap();
let mesh = Mesh3d::with_display_edges(
vec![point, point.checked_scale(0.5).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let axis = Vec3::new(1.0, 1.0, 1.0).unwrap().normalized().unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::from_axis_angle(axis, std::f32::consts::FRAC_PI_2).unwrap(),
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, -1.0e37).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0 / 7.0e7), 1.0, world(1.0), world(3.0e38)).unwrap(),
)
.unwrap();
let model_rows = transform.model_rows().unwrap();
let model_point = [point.x(), point.y(), point.z(), 1.0];
assert_eq!(
shader_dot(model_rows[0], model_point),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera.world_to_clip_rows().unwrap()),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn shader_transform_rejects_association_dependent_clip_classification() {
let point = Vec3::new(1.732_050_8e20, -1.732_050_8e20, 3.808_820_2e12).unwrap();
let mesh = Mesh3d::new(
vec![
point,
Vec3::new(1.269_606_6e12, 1.269_606_6e12, 1.269_606_6e12).unwrap(),
Vec3::new(6.590_675_4e19, -6.590_675_4e19, 3.202_013e12).unwrap(),
],
vec![0, 1, 2],
)
.unwrap();
let field_of_view = f32::from_bits(std::f32::consts::PI.to_bits() - 1);
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
Vec3::new(-1.0e20, -9.999_999e19, 2.0e20).unwrap(),
Projection3d::perspective(field_of_view, 16.0, world(f32::MIN_POSITIVE), world(1.0e30))
.unwrap(),
)
.unwrap();
let model_rows = Transform3d::IDENTITY.model_rows().unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
let model_point = [point.x(), point.y(), point.z(), 1.0].map(ShaderValueRange::exact);
let world = [
shader_dot_range(model_rows[0], model_point).unwrap(),
shader_dot_range(model_rows[1], model_point).unwrap(),
shader_dot_range(model_rows[2], model_point).unwrap(),
ShaderValueRange::exact(1.0),
];
let clip_w = shader_dot_range(camera_rows[3], world).unwrap();
assert!(clip_w.minimum <= 0.0 && clip_w.maximum > 1.0e12);
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn surface_triangle_rejects_association_dependent_projected_collapse() {
let scale = f32::from_bits(0x5d52_e40a);
let coordinate = f32::from_bits(0x5d72_6836);
let adjacent = f32::from_bits(0x5d72_6837);
let product = f32::from_bits(0x7b47_b16b);
let mesh = Mesh3d::new(
vec![
Vec3::new(coordinate, coordinate, 0.0).unwrap(),
Vec3::new(adjacent, coordinate, 0.0).unwrap(),
Vec3::new(coordinate, adjacent, 0.0).unwrap(),
],
vec![0, 1, 2],
)
.unwrap();
let transform = Transform3d::new(
Vec3::new(-product, -product, 0.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(scale, scale, 1.0).unwrap(),
)
.unwrap();
let model_rows = transform.model_rows().unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 5.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0_f32.powi(103)), 1.0, world(0.1), world(10.0))
.unwrap(),
)
.unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
for vertex in mesh.vertices() {
assert_eq!(
shader_dot(model_rows[0], [vertex.x(), vertex.y(), vertex.z(), 1.0]),
Ok(0.0)
);
assert_eq!(
shader_dot(model_rows[1], [vertex.x(), vertex.y(), vertex.z(), 1.0]),
Ok(0.0)
);
}
assert_eq!(
validate_shader_points(&mesh, model_rows, camera_rows),
Ok(())
);
assert_eq!(
validate_surface_triangle_topology(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::UnportableSurfaceTopology)
);
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::UnportableSurfaceTopology)
);
}
#[test]
fn surface_triangle_frustum_branches_are_explicit() {
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 5.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
let model_rows = Transform3d::IDENTITY.model_rows().unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
let mesh = |vertices| Mesh3d::new(vertices, vec![0, 1, 2]).unwrap();
let inside = mesh(vec![
Vec3::new(-0.25, -0.25, 0.0).unwrap(),
Vec3::new(0.25, -0.25, 0.0).unwrap(),
Vec3::new(0.0, 0.25, 0.0).unwrap(),
]);
assert_eq!(
validate_surface_triangle_topology(&inside, model_rows, camera_rows),
Ok(())
);
let crossing = mesh(vec![
Vec3::new(-0.25, -0.25, 0.0).unwrap(),
Vec3::new(1.5, -0.25, 0.0).unwrap(),
Vec3::new(0.0, 0.25, 0.0).unwrap(),
]);
assert_eq!(
validate_shader_points(&crossing, model_rows, camera_rows),
Ok(())
);
assert_eq!(
validate_surface_triangle_topology(&crossing, model_rows, camera_rows),
Ok(())
);
let outside = mesh(vec![
Vec3::new(1.5, -0.25, 0.0).unwrap(),
Vec3::new(2.0, -0.25, 0.0).unwrap(),
Vec3::new(1.75, 0.25, 0.0).unwrap(),
]);
assert_eq!(outside.triangle_count(), 1);
assert_eq!(
validate_surface_triangle_topology(&outside, model_rows, camera_rows),
Ok(())
);
}
#[test]
fn shader_transform_rejects_extreme_correlated_sparse_vertices() {
let extent = 0.9 * f32::MAX;
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(extent, 0.0, 0.0).unwrap(),
Vec3::new(0.0, extent, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::from_axis_angle(Vec3::Z, -std::f32::consts::FRAC_PI_4).unwrap(),
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let first = transform.transform_point(mesh.vertices()[0]).unwrap();
let second = transform.transform_point(mesh.vertices()[1]).unwrap();
for vertex in [first, second] {
assert!(vertex.x().is_finite() && vertex.y().is_finite() && vertex.z().is_finite());
}
let target = Vec3::new(first.x(), 0.0, 0.0).unwrap();
let camera = Camera3d::look_at(
Vec3::new(target.x(), 0.0, 2.0e38).unwrap(),
target,
Vec3::Y,
Projection3d::perspective(2.8, 1.0, world(1.0), world(3.0e38)).unwrap(),
)
.unwrap();
let viewport = LogicalViewport::new(64.0, 64.0).unwrap();
assert!(camera.project_world(first, viewport).unwrap().inside_view());
assert!(
camera
.project_world(second, viewport)
.unwrap()
.inside_view()
);
assert_eq!(
validate_shader_transform(
&mesh,
transform.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn edge_projection_rejects_post_width_shader_overflow() {
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(-0.5, 0.0, 0.0).unwrap(),
Vec3::new(0.5, 0.0, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, logical(1_048_576.0)).unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 2.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
style,
[1.0, 1.0, 5.0e32, 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn edge_projection_rejects_logical_distance_overflow() {
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(-0.5, 0.0, 0.0).unwrap(),
Vec3::new(0.5, 0.0, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, logical(1_048_576.0)).unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 2.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
style,
[1_024.0, 1_024.0, f32::MIN_POSITIVE, 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn edge_projection_rejects_hidden_dash_phase_overflow() {
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(-0.5, 0.0, 0.0).unwrap(),
Vec3::new(0.5, 0.0, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let smallest = logical(f32::MIN_POSITIVE);
let style = WireframeStyle3d::visible(Color::WHITE, logical(1.0))
.unwrap()
.with_hidden(Color::WHITE, logical(1.0), smallest, smallest)
.unwrap();
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 2.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
style,
[1_024.0, 1_024.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn edge_projection_bounds_dash_across_legal_shader_associations() {
let point = Vec3::new(-6.593_279e17, 2.460_645_7e18, 9.006_587e17).unwrap();
let mesh = Mesh3d::with_display_edges(
vec![point, point.checked_scale(0.5).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let axis = Vec3::new(1.0, 1.0, 1.0).unwrap().normalized().unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::from_axis_angle(axis, std::f32::consts::FRAC_PI_2).unwrap(),
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::orthographic(world(5.0e10), 1.0, world(1.0), world(3.0e18)).unwrap(),
)
.unwrap();
let tiny = logical(1.5e-38);
let style = WireframeStyle3d::visible(Color::WHITE, logical(1.0))
.unwrap()
.with_hidden(Color::WHITE, logical(1.0), tiny, tiny)
.unwrap();
let model_rows = transform.model_rows().unwrap();
let model_point = [point.x(), point.y(), point.z(), 1.0];
assert_eq!(shader_dot(model_rows[0], model_point), Ok(0.0));
assert_eq!(
validate_edge_projection(
&mesh,
model_rows,
camera.world_to_clip_rows().unwrap(),
style,
[100.0, 100.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn edge_projection_rejects_association_dependent_collapse() {
let point = Vec3::new(-6.593_279e17, 2.460_645_7e18, 9.006_587e17).unwrap();
let mesh = Mesh3d::with_display_edges(
vec![point, point.checked_scale(0.5).unwrap()],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let axis = Vec3::new(1.0, 1.0, 1.0).unwrap().normalized().unwrap();
let transform = Transform3d::new(
Vec3::ZERO,
Rotation3d::from_axis_angle(axis, std::f32::consts::FRAC_PI_2).unwrap(),
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::orthographic(world(1.0e13), 1.0, world(1.0), world(3.0e18)).unwrap(),
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, logical(5.0)).unwrap();
let model_rows = transform.model_rows().unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Ok(())
);
assert_eq!(
validate_edge_projection(
&mesh,
model_rows,
camera_rows,
style,
[1_000.0, 1_000.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn edge_projection_rejects_extreme_homogeneous_sources_before_clipping() {
let outside_x = f32::from_bits(1.0_f32.to_bits() + 1);
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(-outside_x, f32::MAX, 1.0).unwrap(),
Vec3::new(-outside_x, -f32::MAX, 1.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(1.0), world(10.0)).unwrap(),
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, logical(1.0)).unwrap();
let model_rows = Transform3d::IDENTITY.model_rows().unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
assert_eq!(
validate_edge_projection(
&mesh,
model_rows,
camera_rows,
style,
[128.0, 128.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn edge_projection_rejects_subnormal_component_scaled_clip_boundary() {
let near = f32::from_bits(0x327e_4a5c) * 0.5;
let clip_w = f32::from_bits(0x327e_4a5c);
let clip_x = f32::from_bits(clip_w.to_bits() + 1);
let clip_y = f32::from_bits(0x41db_c900);
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::perspective(std::f32::consts::FRAC_PI_2, 1.0, world(near), world(1.0))
.unwrap(),
)
.unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
let start = Vec3::new(
clip_x / camera_rows[0][0],
clip_y / camera_rows[1][1],
clip_w,
)
.unwrap();
let end = Vec3::new(
clip_x / camera_rows[0][0],
-clip_y / camera_rows[1][1],
clip_w,
)
.unwrap();
let mesh = Mesh3d::with_display_edges(
vec![start, end],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let model_rows = Transform3d::IDENTITY.model_rows().unwrap();
let start_clip = shader_clip_point_ranges(start, model_rows, camera_rows).unwrap();
assert_eq!(start_clip[0].fixed, clip_x);
assert_eq!(start_clip[1].fixed, clip_y);
assert_eq!(start_clip[3].fixed, clip_w);
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
assert_eq!(
validate_edge_projection(
&mesh,
model_rows,
camera_rows,
WireframeStyle3d::visible(Color::WHITE, logical(1.0)).unwrap(),
[128.0, 128.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn edge_projection_rejects_ftz_sensitive_pair_scale_inputs() {
let largest_subnormal = f32::from_bits(0x007f_ffff);
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(0.0, largest_subnormal, 1.0).unwrap(),
Vec3::new(0.5, largest_subnormal, 1.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let transform = Transform3d::new(
Vec3::new(0.0, f32::from_bits(1.0_f32.to_bits() + 1), 0.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, f32::MAX, 1.0).unwrap(),
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, 1.0).unwrap(),
Vec3::Y,
Projection3d::orthographic(world(2.0), 1.0, world(1.0), world(10.0)).unwrap(),
)
.unwrap();
let model_rows = transform.model_rows().unwrap();
let camera_rows = camera.world_to_clip_rows().unwrap();
assert_eq!(
validate_shader_transform(&mesh, model_rows, camera_rows),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
assert_eq!(
validate_edge_projection(
&mesh,
model_rows,
camera_rows,
WireframeStyle3d::visible(Color::WHITE, logical(1.0)).unwrap(),
[128.0, 128.0, 1.0, 0.0],
),
Err(Mesh3dRenderError::InvalidGeometryTransform)
);
}
#[test]
fn edge_projection_rejects_values_outside_portable_width_envelope() {
let maximum_width = logical(1_048_576.0);
let requested_scale = f32::MAX / maximum_width.get();
let logical_viewport =
LogicalViewport::new(1.0 / requested_scale, 8_192.0 / requested_scale).unwrap();
let pixels_per_logical = target_pixels_per_logical(1, 8_192, logical_viewport).unwrap();
let scaled_width = maximum_width.get() * pixels_per_logical.get();
assert!(scaled_width.is_finite());
let view_depth = f32::from_bits(0x7f4d_1ce4);
let aspect = 1.0 / 8_192.0;
let vertical_fov = 1.0_f32;
let horizontal_scale = (vertical_fov * 0.5).tan() * aspect;
let half_x = view_depth * 0.5 * horizontal_scale;
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(-half_x, 0.0, -view_depth).unwrap(),
Vec3::new(half_x, 0.0, -view_depth).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, -1.0).unwrap(),
Vec3::Y,
Projection3d::perspective(vertical_fov, aspect, world(1.0), world(f32::MAX)).unwrap(),
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, maximum_width).unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
style,
[1.0, 8_192.0, pixels_per_logical.get(), 0.0],
),
Err(Mesh3dRenderError::InvalidEdgeProjection)
);
}
#[test]
fn scene3d_rejects_out_of_range_clear_colors() {
assert!(matches!(
Scene3d::new(Color::rgb(1.01, 0.0, 0.0)),
Err(Scene3dError::InvalidBackground)
));
}
#[test]
fn retained_mesh_and_scene_transform_reject_nonportable_shader_sources() {
let subnormal = f32::from_bits(1);
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(subnormal, 0.0, 0.0).unwrap(),
Vec3::new(1.0, 0.0, 0.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
assert!(!mesh3d_source_is_portable(&mesh));
let transform = Transform3d::new(
Vec3::new(subnormal, 0.0, 0.0).unwrap(),
Rotation3d::IDENTITY,
Vec3::new(1.0, 1.0, 1.0).unwrap(),
)
.unwrap();
assert_eq!(
validate_scene3d_transform(transform),
Err(Scene3dError::InvalidTransform)
);
assert_eq!(validate_scene3d_transform(Transform3d::IDENTITY), Ok(()));
}
#[test]
fn edge_crossing_near_plane_is_clipped_before_wgsl_division() {
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(0.0, 0.0, -0.05).unwrap(),
Vec3::new(0.5, 0.0, -1.0).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, -1.0).unwrap(),
Vec3::Y,
Projection3d::perspective(1.0, 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
let style = WireframeStyle3d::visible(Color::WHITE, logical(1.0)).unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
style,
[100.0, 100.0, 1.0, 0.0],
),
Ok(())
);
}
#[test]
fn fully_clipped_edges_do_not_reject_the_frame() {
let mesh = Mesh3d::with_display_edges(
vec![
Vec3::new(0.0, 0.0, -0.01).unwrap(),
Vec3::new(0.01, 0.0, -0.05).unwrap(),
],
Vec::new(),
vec![MeshEdge3d::new(0, 1).unwrap()],
)
.unwrap();
let camera = Camera3d::look_at(
Vec3::ZERO,
Vec3::new(0.0, 0.0, -1.0).unwrap(),
Vec3::Y,
Projection3d::perspective(1.0, 1.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
assert_eq!(
validate_edge_projection(
&mesh,
Transform3d::IDENTITY.model_rows().unwrap(),
camera.world_to_clip_rows().unwrap(),
WireframeStyle3d::visible(Color::WHITE, logical(1.0)).unwrap(),
[100.0, 100.0, 1.0, 0.0],
),
Ok(())
);
}
#[test]
fn homogeneous_edge_clipping_covers_near_far_and_camera_half_spaces() {
let near = clip_edge_to_frustum([0.0, 0.0, -0.5, 1.0], [0.0, 0.0, 0.5, 1.0])
.unwrap()
.unwrap();
assert!(near[0][2].abs() <= f32::EPSILON);
assert_eq!(near[1], [0.0, 0.0, 0.5, 1.0]);
let far = clip_edge_to_frustum([0.0, 0.0, 0.5, 1.0], [0.0, 0.0, 2.0, 1.0])
.unwrap()
.unwrap();
assert!((far[1][2] - far[1][3]).abs() <= f32::EPSILON);
assert_eq!(
clip_edge_to_frustum([0.0, 0.0, -2.0, -1.0], [0.0, 0.0, -1.0, -0.5]),
Ok(None)
);
assert_eq!(
clip_edge_to_frustum([-3.0, 0.0, 0.5, 1.0], [-2.0, 0.0, 0.5, 1.0]),
Ok(None)
);
}
#[test]
fn target_pixel_scale_is_independent_of_window_dpi() {
let viewport = LogicalViewport::new(1000.0, 500.0).unwrap();
assert_eq!(
target_pixels_per_logical(2000, 1000, viewport),
Some(physical_per_logical(2.0))
);
assert_eq!(
target_pixels_per_logical(500, 250, viewport),
Some(physical_per_logical(0.5))
);
assert_eq!(target_pixels_per_logical(500, 300, viewport), None);
assert!(aspect_matches(16.0 / 9.0, 1920.0 / 1080.0));
assert!(!aspect_matches(16.0 / 9.0, 4.0 / 3.0));
assert!(!aspect_matches(1.0 / 8_192.0, (1.0 / 8_192.0) * 1.08));
assert_eq!(
target_pixels_per_logical(
1,
8_192,
LogicalViewport::new(100_000.0, 431_157_900.0).unwrap(),
),
None
);
}
#[test]
fn camera_target_aspect_mismatch_is_rejected_by_render_contract() {
let camera = Camera3d::look_at(
Vec3::new(0.0, 0.0, 5.0).unwrap(),
Vec3::ZERO,
Vec3::Y,
Projection3d::perspective(1.0, 16.0 / 9.0, world(0.1), world(10.0)).unwrap(),
)
.unwrap();
let target = LogicalViewport::new(800.0, 600.0).unwrap();
assert_eq!(
validate_camera_target_aspect(camera, target),
Err(Mesh3dRenderError::CameraTargetAspectMismatch)
);
}
#[test]
fn logical_edge_width_is_equal_for_native_and_half_resolution_target() {
let logical_width = logical(1.0);
for pixels_per_logical in [physical_per_logical(2.0), physical_per_logical(0.5)] {
let physical_width = edge_raster_envelope(logical_width, pixels_per_logical)
.unwrap()
.physical_half_width
* 2.0;
assert_eq!(
physical_width / pixels_per_logical.get(),
logical_width.get()
);
}
}
#[test]
fn mesh_upload_preflight_rejects_each_buffer_before_staging_allocation() {
let max_buffer_size = 48;
let layout = preflight_mesh3d_upload(4, 12, 2, max_buffer_size).unwrap();
assert_eq!(layout.vertex_bytes, 48);
assert_eq!(layout.index_bytes, 48);
assert_eq!(layout.edge_bytes, 48);
assert_eq!(layout.total_bytes, 144);
assert_eq!(
preflight_mesh3d_upload(5, 0, 0, max_buffer_size),
Err(Mesh3dResourceError::CapacityTooLarge)
);
assert_eq!(
preflight_mesh3d_upload(1, 13, 0, max_buffer_size),
Err(Mesh3dResourceError::CapacityTooLarge)
);
assert_eq!(
preflight_mesh3d_upload(1, 0, 3, max_buffer_size),
Err(Mesh3dResourceError::CapacityTooLarge)
);
if usize::BITS > u32::BITS {
let first_draw_count_overflow = u32::MAX as usize + 1;
assert_eq!(
preflight_mesh3d_upload(1, first_draw_count_overflow, 0, u64::MAX),
Err(Mesh3dResourceError::CapacityTooLarge)
);
assert_eq!(
preflight_mesh3d_upload(1, 0, first_draw_count_overflow, u64::MAX),
Err(Mesh3dResourceError::CapacityTooLarge)
);
}
}
}