Files
solidcraft/crates/gpu/src/view/oit.rs
T
semmelrindeandClaude Opus 5.5 e0e2c566e7 Viewport: clear new resolve targets so AMD Direct3D 12 shows the scene (#6828) (#7399)
* claim: #6828

* Viewport: clear new resolve targets so AMD Direct3D 12 shows the scene (#6828)

With anti-aliasing above 1x the scene is drawn multisampled and resolved
into textures that nothing but the resolve writes. wgpu counts the resolve
as their first write and never clears them. Direct3D 12 requires a render
target placed in reused memory to be cleared, discarded or copied over
first, and some AMD Radeon drivers then show the uncleared texture as
transparent, a flat colour or speckles: no grid, origin planes or bodies
(#6828, #7157, #6613, #7052). Each new resolve texture (the frame's colour
and the see-through sums) is now cleared once when it is made.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 20:01:40 +00:00

300 lines
14 KiB
Rust

//! Weighted blended order-independent transparency (McGuire and Bavoil, "Weighted Blended
//! Order-Independent Transparency", JCGT 2013) for the model's see-through surfaces: glass (an
//! appearance's opacity) and faded context, instanced or not.
//!
//! Each see-through fragment adds its colour, weighted by its alpha and its depth, into an
//! accumulation target, and multiplies its transparency into a revealage target; a full-screen
//! pass then lays the weighted average over what is behind it, by how much is covered. Nothing is
//! sorted, on the CPU or the GPU, however many see-through triangles there are. The targets share
//! the frame's depth (tested, not written), so the opaque model hides what lies behind it.
use super::{TriSource, color_layout, depth_compare, instance_layout, planned_layout, shared_layout, tri_layout};
/// The accumulated colour (premultiplied, weighted) and alpha.
const ACCUM: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
/// How much of what is behind still shows (1: all of it).
const REVEAL: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;
const COMPOSITE: &str = r#"
@group(0) @binding(0) var accum_t: texture_2d<f32>;
@group(0) @binding(1) var reveal_t: texture_2d<f32>;
@vertex
fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
let x = f32((i << 1u) & 2u);
let y = f32(i & 2u);
return vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);
}
@fragment
fn fs(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
let p = vec2<i32>(pos.xy);
let reveal = textureLoad(reveal_t, p, 0).r;
let accum = textureLoad(accum_t, p, 0);
if (reveal >= 1.0) { discard; }
return vec4<f32>(accum.rgb / max(accum.a, 1e-5), 1.0 - reveal);
}
"#;
/// The pipelines, made once per target kind.
pub(super) struct Pipelines {
/// Built triangles ([`tri_layout`]), and instanced meshes smooth and flat.
pub built: wgpu::RenderPipeline,
/// Faded and see-through bodies drawn from their plans' evaluated vertices.
pub planned: wgpu::RenderPipeline,
pub instanced: wgpu::RenderPipeline,
pub instanced_flat: wgpu::RenderPipeline,
composite: wgpu::RenderPipeline,
bgl: wgpu::BindGroupLayout,
}
/// The targets, kept while the frame's size stays.
pub(super) struct Targets {
pub size: [u32; 2],
accum: wgpu::TextureView,
accum_resolve: Option<wgpu::TextureView>,
reveal: wgpu::TextureView,
reveal_resolve: Option<wgpu::TextureView>,
bind: wgpu::BindGroup,
}
impl Targets {
/// The textures only the resolve writes (none at one sample), which a new frame clears first.
pub fn resolves(&self) -> impl Iterator<Item = &wgpu::TextureView> {
self.accum_resolve.iter().chain(&self.reveal_resolve)
}
}
impl Pipelines {
/// The pipelines for frames of `format` with `depth` and `samples`, using the viewport's
/// shader `module` and uniform `layout`; `None` where the device cannot blend into a float
/// target (the model's see-through surfaces are then sorted as before).
pub fn new(
device: &wgpu::Device,
module: &wgpu::ShaderModule,
layout: &wgpu::PipelineLayout,
format: wgpu::TextureFormat,
depth: Option<wgpu::TextureFormat>,
samples: u32,
) -> Option<Pipelines> {
let scopes = [wgpu::ErrorFilter::OutOfMemory, wgpu::ErrorFilter::Internal, wgpu::ErrorFilter::Validation].map(|f| device.push_error_scope(f));
let reversed = super::reversed_depth(depth);
let samples = samples.max(1);
let multisample = wgpu::MultisampleState { count: samples, mask: !0, alpha_to_coverage_enabled: false };
let add =
wgpu::BlendComponent { src_factor: wgpu::BlendFactor::One, dst_factor: wgpu::BlendFactor::One, operation: wgpu::BlendOperation::Add };
let keep = wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::Zero,
dst_factor: wgpu::BlendFactor::OneMinusSrc,
operation: wgpu::BlendOperation::Add,
};
let targets = [
Some(wgpu::ColorTargetState {
format: ACCUM,
blend: Some(wgpu::BlendState { color: add, alpha: add }),
write_mask: wgpu::ColorWrites::ALL,
}),
Some(wgpu::ColorTargetState {
format: REVEAL,
blend: Some(wgpu::BlendState { color: keep, alpha: keep }),
write_mask: wgpu::ColorWrites::RED,
}),
];
let built_buffers = [Some(tri_layout())];
let evaluated = [Some(planned_layout()), Some(color_layout())];
let placed = [Some(shared_layout()), Some(instance_layout())];
let pipeline = |label: &str, source: TriSource| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(layout),
vertex: wgpu::VertexState {
module,
entry_point: Some(source.entry()),
buffers: match source {
TriSource::Built => &built_buffers[..],
TriSource::Planned => &evaluated[..],
TriSource::Instanced | TriSource::InstancedFlat => &placed[..],
},
compilation_options: Default::default(),
},
primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },
depth_stencil: depth.map(|format| wgpu::DepthStencilState {
format,
depth_write_enabled: Some(false),
depth_compare: Some(depth_compare(reversed, wgpu::CompareFunction::LessEqual)),
stencil: Default::default(),
bias: Default::default(),
}),
multisample,
fragment: Some(wgpu::FragmentState {
module,
entry_point: Some(&source.fragment("fs_oit")),
targets: &targets,
compilation_options: Default::default(),
}),
multiview_mask: None,
cache: None,
})
};
let built = pipeline("sc_oit", TriSource::Built);
let planned = pipeline("sc_oit_planned", TriSource::Planned);
let instanced = pipeline("sc_oit_instanced", TriSource::Instanced);
let instanced_flat = pipeline("sc_oit_instanced_flat", TriSource::InstancedFlat);
let texture = |binding| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
};
let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("sc_oit"), entries: &[texture(0), texture(1)] });
let composite_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("sc_oit_composite"),
bind_group_layouts: &[Some(&bgl)],
immediate_size: 0,
});
let composite_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sc_oit_composite"),
source: wgpu::ShaderSource::Wgsl(COMPOSITE.into()),
});
// Over the frame (premultiplied over transparent black): the average colour by how much
// is covered.
let over = wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
};
let composite = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("sc_oit_composite"),
layout: Some(&composite_layout),
vertex: wgpu::VertexState { module: &composite_module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },
primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },
depth_stencil: None,
multisample,
fragment: Some(wgpu::FragmentState {
module: &composite_module,
entry_point: Some("fs"),
targets: &[Some(wgpu::ColorTargetState { format, blend: Some(over), write_mask: wgpu::ColorWrites::ALL })],
compilation_options: Default::default(),
}),
multiview_mask: None,
cache: None,
});
let mut failed = None;
for scope in scopes.into_iter().rev() {
if let Some(e) = crate::popped(scope.pop()) {
failed.get_or_insert(e.to_string());
}
}
if let Some(e) = failed {
log::info!("see-through surfaces are sorted (no order-independent transparency here: {e})");
return None;
}
Some(Pipelines { built, planned, instanced, instanced_flat, composite, bgl })
}
/// The targets for a frame of `size` pixels at `samples` per pixel.
pub fn targets(&self, device: &wgpu::Device, size: [u32; 2], samples: u32) -> Targets {
let samples = samples.max(1);
let texture = |label: &str, format, samples, usage| {
device
.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d { width: size[0].max(1), height: size[1].max(1), depth_or_array_layers: 1 },
mip_level_count: 1,
sample_count: samples,
dimension: wgpu::TextureDimension::D2,
format,
usage,
view_formats: &[],
})
.create_view(&Default::default())
};
let read = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
let pair = |label: &str, format| {
if samples > 1 {
(texture(label, format, samples, wgpu::TextureUsages::RENDER_ATTACHMENT), Some(texture(label, format, 1, read)))
} else {
(texture(label, format, 1, read), None)
}
};
let (accum, accum_resolve) = pair("sc_oit_accum", ACCUM);
let (reveal, reveal_resolve) = pair("sc_oit_reveal", REVEAL);
let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("sc_oit"),
layout: &self.bgl,
entries: &[
wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(accum_resolve.as_ref().unwrap_or(&accum)) },
wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(reveal_resolve.as_ref().unwrap_or(&reveal)) },
],
});
Targets { size, accum, accum_resolve, reveal, reveal_resolve, bind }
}
/// The pass that gathers the see-through surfaces (`draw` records them), against `depth`.
pub fn accumulate(
&self,
encoder: &mut wgpu::CommandEncoder,
t: &Targets,
depth: Option<&wgpu::TextureView>,
stencil: bool,
draw: impl FnOnce(&mut wgpu::RenderPass<'static>),
) {
let attach = |view, resolve_target, clear| {
Some(wgpu::RenderPassColorAttachment {
view,
depth_slice: None,
resolve_target,
ops: wgpu::Operations { load: wgpu::LoadOp::Clear(clear), store: wgpu::StoreOp::Store },
})
};
let mut pass = encoder
.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("sc_oit"),
color_attachments: &[
attach(&t.accum, t.accum_resolve.as_ref(), wgpu::Color::TRANSPARENT),
attach(&t.reveal, t.reveal_resolve.as_ref(), wgpu::Color::WHITE),
],
depth_stencil_attachment: depth.map(|view| wgpu::RenderPassDepthStencilAttachment {
view,
depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store }),
stencil_ops: stencil.then_some(wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store }),
}),
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
})
.forget_lifetime();
pass.set_viewport(0.0, 0.0, t.size[0] as f32, t.size[1] as f32, 0.0, 1.0);
draw(&mut pass);
}
/// Lay what was gathered over the frame's `color` (resolved into `resolve`).
pub fn composite(&self, encoder: &mut wgpu::CommandEncoder, t: &Targets, color: &wgpu::TextureView, resolve: Option<&wgpu::TextureView>) {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("sc_oit_composite"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: color,
depth_slice: None,
resolve_target: resolve,
ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&self.composite);
pass.set_bind_group(0, &t.bind, &[]);
pass.draw(0..3, 0..1);
}
}