SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use super::*;
use crate::gpu::{Renderer as ViewRenderer, ViewportCallback};
use egui_wgpu::{CallbackResources, CallbackTrait, FrameCompositor, ScreenDescriptor, wgpu};
use std::cell::RefCell;
use std::hash::{Hash, Hasher};
use std::sync::{Arc, Mutex};
thread_local! { static CURRENT: RefCell<Option<Arc<Shared>>> = const { RefCell::new(None) }; }
thread_local! { static SURFACE_ALPHA: std::cell::Cell<Option<u8>> = const { std::cell::Cell::new(None) }; }
const BUDGET: u64 = 256 * 1024 * 1024;
const MAX_MARKERS: usize = 256;
type Params = [f32; 24];
fn capability(adapter: &wgpu::Adapter, device_type: wgpu::DeviceType, format: wgpu::TextureFormat, split: bool, msaa: u32) -> Capability {
if device_type == wgpu::DeviceType::Cpu {
return Capability::Unavailable("software adapter (gpu-software)");
}
rendering_capability(adapter, format, split, msaa)
}
fn rendering_capability(adapter: &wgpu::Adapter, format: wgpu::TextureFormat, split: bool, msaa: u32) -> Capability {
let allowed = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC;
if !split || msaa != 1 {
Capability::Unavailable("requires a native split scene and 1x UI without depth")
} else if !matches!(
format,
wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Bgra8Unorm | wgpu::TextureFormat::Rgba8UnormSrgb | wgpu::TextureFormat::Bgra8UnormSrgb
) || [format, wgpu::TextureFormat::Rgba16Float].iter().any(|f| {
let features = adapter.get_texture_format_features(*f);
!features.allowed_usages.contains(allowed) || !features.flags.contains(wgpu::TextureFormatFeatureFlags::FILTERABLE)
}) {
Capability::Unavailable("required renderable filterable formats unavailable")
} else {
Capability::Available
}
}
#[derive(Clone)]
struct Host {
adapter: wgpu::Adapter,
device_type: wgpu::DeviceType,
device: wgpu::Device,
queue: wgpu::Queue,
renderer: std::sync::Weak<egui::epaint::mutex::RwLock<egui_wgpu::Renderer>>,
lost: egui_wgpu::DeviceLost,
format: wgpu::TextureFormat,
capability: std::sync::OnceLock<Capability>,
split: bool,
msaa: u32,
}
impl Host {
fn capability(&self) -> Capability {
*self.capability.get_or_init(|| capability(&self.adapter, self.device_type, self.format, self.split, self.msaa))
}
}
pub struct State {
radius: f32,
available: bool,
tier_cap: usize,
host: Option<Host>,
active: Option<Arc<Shared>>,
retired: Counters,
source_supported: bool,
failure: Option<&'static str>,
surface_alpha: Option<u8>,
last_size: Option<[u32; 2]>,
last_background: Option<[Color32; 3]>,
}
impl Default for State {
fn default() -> Self {
Self {
radius: 0.0,
available: true,
tier_cap: 5,
host: None,
active: None,
retired: Counters::default(),
source_supported: true,
failure: None,
surface_alpha: None,
last_size: None,
last_background: None,
}
}
}
impl State {
pub fn install(&mut self, rs: &egui_wgpu::RenderState, split: bool) {
self.retire();
self.failure = None;
self.host = Some(Host {
adapter: rs.adapter.clone(),
device_type: rs.adapter.get_info().device_type,
device: rs.device.clone(),
queue: rs.queue.clone(),
renderer: Arc::downgrade(&rs.renderer),
lost: rs.device_lost.clone(),
format: rs.target_format,
capability: std::sync::OnceLock::new(),
split,
msaa: rs.msaa_samples,
});
}
fn retire(&mut self) {
if let Some(shared) = self.active.take() {
if let Ok(mut inner) = shared.inner.lock() {
self.retired = inner.counts;
self.retired.clear_live();
self.failure = inner.failure.or(self.failure);
inner.gpu = None;
}
if let Some(renderer) = self.host.as_ref().and_then(|h| h.renderer.upgrade()) {
renderer.write().frame_compositor = None;
}
}
}
pub fn set_radius(&mut self, radius: f32) -> Result<(), &'static str> {
let radius = validate_radius(radius)?;
if radius != self.radius {
self.retire();
self.radius = radius;
self.failure = None;
}
Ok(())
}
pub fn radius(&self) -> f32 {
self.radius
}
pub fn software_adapter(&self) -> bool {
self.host.as_ref().is_some_and(|h| h.device_type == wgpu::DeviceType::Cpu)
}
pub fn set_available(&mut self, available: bool) {
self.available = available;
if !available {
self.retire();
}
}
pub fn set_tier_cap(&mut self, cap: usize) {
let cap = cap.clamp(2, 5);
if self.tier_cap != cap {
self.retire();
self.tier_cap = cap;
}
}
pub fn painted_frame(&self) -> Option<PaintedFrame> {
self.active.as_ref()?.inner.lock().ok()?.painted
}
pub fn capability(&self) -> Capability {
let base = self.base_capability();
if base == Capability::Available && self.active.as_ref().is_some_and(|s| s.inner.lock().is_ok_and(|i| i.missing_source)) {
return Capability::Unavailable("no viewport source in the last painted frame");
}
base
}
pub fn capability_for(&self, viewport: egui::ViewportId) -> Capability {
if viewport != egui::ViewportId::ROOT {
return Capability::Unavailable("native pop-out source integration unavailable");
}
self.capability()
}
fn base_capability(&self) -> Capability {
let Some(host) = &self.host else { return Capability::Unavailable("no GPU host") };
if host.lost.is_lost() {
return Capability::Unavailable("device lost");
}
let available = host.capability();
if available != Capability::Available {
return available;
}
if !self.source_supported {
return Capability::Unavailable("workspace has no viewport source recipe");
}
if let Some(reason) = self.failure {
return Capability::Unavailable(reason);
}
if let Some(shared) = &self.active {
return match shared.inner.lock() {
Ok(inner) => inner.failure.map_or(Capability::Available, Capability::Unavailable),
Err(_) => Capability::Unavailable("blur state unavailable"),
};
}
Capability::Available
}
pub fn counters(&self) -> Counters {
self.active.as_ref().and_then(|s| s.inner.lock().ok().map(|i| i.counts)).unwrap_or(self.retired)
}
#[cfg(test)]
pub(crate) fn source_texture(&self) -> Option<wgpu::Texture> {
let inner = self.active.as_ref()?.inner.lock().ok()?;
Some(inner.gpu.as_ref()?.source._texture.clone())
}
#[cfg(test)]
pub(crate) fn source_geometry(&self) -> Option<[Rect; 3]> {
self.active.as_ref()?.inner.lock().ok()?.geometry
}
/// Internal capture tint only; deliberately not a user preference.
pub fn set_surface_alpha(&mut self, alpha: Option<u8>) {
self.surface_alpha = alpha;
}
pub fn begin(&mut self, ctx: &egui::Context, source_supported: bool) -> Scope {
let previous = CURRENT.with(|c| c.replace(None));
let alpha = SURFACE_ALPHA.with(|a| a.replace(self.surface_alpha));
if ctx.viewport_id() != egui::ViewportId::ROOT {
return Scope { previous, alpha };
}
self.source_supported = source_supported;
if self.radius == 0.0 {
self.retire();
return Scope { previous, alpha };
}
let colors = crate::theme::Tokens::get();
let background = [colors.viewport_top, colors.viewport_bottom, colors.app_bar];
if self.last_background != Some(background) {
let failed = self.failure.is_some() || self.active.as_ref().is_some_and(|s| s.inner.lock().is_ok_and(|i| i.failure.is_some()));
if failed {
self.retire();
self.failure = None;
}
self.last_background = Some(background);
}
let size = ctx.content_rect().size() * ctx.pixels_per_point();
if size.is_finite() && size.x > 0.0 && size.y > 0.0 {
let size_key = [size.x.round() as u32, size.y.round() as u32];
if self.last_size != Some(size_key) {
self.retire();
self.failure = None;
self.last_size = Some(size_key);
}
}
if !self.available || self.base_capability() != Capability::Available || !size.is_finite() || size.x <= 0.0 || size.y <= 0.0 {
self.retire();
return Scope { previous, alpha };
}
let Some(host) = &self.host else { return Scope { previous, alpha } };
let shared = self.active.get_or_insert_with(|| {
Arc::new(Shared {
host: host.clone(),
radius: self.radius,
tier_cap: self.tier_cap,
painting_owner: std::sync::atomic::AtomicBool::new(true),
inner: Mutex::new(Inner { counts: self.retired, ..Inner::default() }),
})
});
if let Ok(mut inner) = shared.inner.lock() {
inner.markers.clear();
inner.serial = inner.serial.wrapping_add(1);
inner.source_seen = false;
inner.source_count = 0;
if inner.frame != ctx.cumulative_frame_nr() {
inner.frame = ctx.cumulative_frame_nr();
inner.continuous = ctx.requested_repaint_last_pass();
}
inner.rendered = false;
inner.drawn_before = inner.counts.markers_drawn;
}
if let Some(renderer) = host.renderer.upgrade() {
renderer.write().frame_compositor = Some(shared.clone());
}
CURRENT.with(|c| *c.borrow_mut() = Some(shared.clone()));
Scope { previous, alpha }
}
}
/// Select production policy or bypass only its software rejection for rendering fixtures.
#[cfg(test)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum FixturePolicy {
Production,
Rendering,
}
#[cfg(test)]
pub(crate) fn fixture_state(
adapter: &wgpu::Adapter,
device: &wgpu::Device,
queue: &wgpu::Queue,
renderer: &Arc<egui::epaint::mutex::RwLock<egui_wgpu::Renderer>>,
format: wgpu::TextureFormat,
policy: FixturePolicy,
) -> State {
State {
radius: 0.0,
available: true,
tier_cap: 5,
host: Some(Host {
adapter: adapter.clone(),
device_type: adapter.get_info().device_type,
device: device.clone(),
queue: queue.clone(),
renderer: Arc::downgrade(renderer),
lost: egui_wgpu::DeviceLost::watch(device),
format,
capability: match policy {
FixturePolicy::Production => std::sync::OnceLock::new(),
FixturePolicy::Rendering => std::sync::OnceLock::from(rendering_capability(adapter, format, true, 1)),
},
split: true,
msaa: 1,
}),
active: None,
retired: Counters::default(),
source_supported: true,
failure: None,
surface_alpha: None,
last_size: None,
last_background: None,
}
}
#[cfg(test)]
pub(crate) fn fixture_budget(size: [u32; 2], steps: usize) -> Option<u64> {
target_bytes(size, steps, 16384)
}
impl Drop for State {
fn drop(&mut self) {
self.retire();
}
}
/// Restores the previous context even on early UI returns. No heap allocation.
pub struct Scope {
previous: Option<Arc<Shared>>,
alpha: Option<u8>,
}
impl Drop for Scope {
fn drop(&mut self) {
CURRENT.with(|c| *c.borrow_mut() = self.previous.take());
SURFACE_ALPHA.with(|a| a.set(self.alpha));
}
}
pub fn enabled() -> bool {
CURRENT.with(|c| c.borrow().is_some())
}
pub fn panel_fill(fill: Color32) -> Color32 {
if fill.a() == 0 {
return fill;
}
SURFACE_ALPHA.with(|a| {
a.get().map_or(fill, |alpha| {
let [r, g, b, _] = fill.to_srgba_unmultiplied();
Color32::from_rgba_unmultiplied(r, g, b, alpha)
})
})
}
struct Shared {
host: Host,
radius: f32,
tier_cap: usize,
inner: Mutex<Inner>,
painting_owner: std::sync::atomic::AtomicBool,
}
#[derive(Default)]
struct Inner {
frame: u64,
continuous: bool,
rendered: bool,
drawn_before: u64,
painted: Option<PaintedFrame>,
submitted_at: Option<std::time::Instant>,
gpu: Option<Gpu>,
markers: Vec<Marker>,
counts: Counters,
failure: Option<&'static str>,
serial: u64,
source_seen: bool,
screen: Option<([u32; 2], f32)>,
missing_source: bool,
source_count: u16,
#[cfg(test)]
geometry: Option<[Rect; 3]>,
}
#[derive(Clone, Copy)]
struct Marker {
rect: Rect,
corners: egui::CornerRadius,
opacity: f32,
snap: bool,
// Identity only: the paint job owns this callback for the entire frame. Keeping
// its Arc here would create a Shared -> callback -> Shared ownership cycle.
callback_id: usize,
}
pub fn decorate(painter: &Painter, frame: Frame, content: Rect, ordinary: Shape) -> Shape {
let opacity = painter.opacity();
if frame.fill.a() == 0 || (frame.fill.a() == 255 && opacity >= 1.0) || !opacity.is_finite() || opacity <= 0.0 || !painter.is_visible() {
return ordinary;
}
CURRENT.with(|c| {
let kept = c.borrow();
let Some(shared) = kept.as_ref() else { return ordinary };
if painter.ctx().viewport_id() != egui::ViewportId::ROOT {
return ordinary;
}
let rect = frame.widget_rect(content);
if !rect.is_finite() || !rect.is_positive() {
return ordinary;
}
let callback = if let Ok(mut inner) = shared.inner.lock() {
if inner.markers.len() >= MAX_MARKERS {
inner.failure = Some("blur panel limit exceeded");
inner.gpu = None;
inner.counts.clear_live();
return ordinary;
}
let index = inner.markers.len();
let callback = egui_wgpu::Callback::new_paint_callback(rect, PanelMarker { shared: shared.clone(), index });
inner.markers.push(Marker {
rect,
corners: frame.corner_radius,
opacity,
snap: painter.ctx().tessellation_options(|o| o.round_rects_to_pixels),
callback_id: Arc::as_ptr(&callback.callback) as *const () as usize,
});
inner.counts.markers_emitted += 1;
callback
} else {
return ordinary;
};
Shape::Vec(vec![Shape::Callback(callback), ordinary])
})
}
pub fn viewport(painter: &Painter, rect: Rect, cb: ViewportCallback, background: Rect, colors: [Color32; 2]) {
CURRENT.with(|c| {
if let Some(shared) = c.borrow().as_ref() {
if let Ok(mut inner) = shared.inner.lock() {
inner.source_count = inner.source_count.saturating_add(1);
}
let outside = crate::theme::Tokens::get().app_bar;
painter.add(egui_wgpu::Callback::new_paint_callback(
rect,
Source {
cb,
rect,
clip: painter.clip_rect(),
background,
colors,
outside,
context: painter.ctx().clone(),
layer: painter.layer_id(),
shared: shared.clone(),
},
));
} else {
painter.add(egui_wgpu::Callback::new_paint_callback(rect, cb));
}
});
}
struct Source {
cb: ViewportCallback,
rect: Rect,
clip: Rect,
background: Rect,
colors: [Color32; 2],
outside: Color32,
context: egui::Context,
layer: egui::LayerId,
shared: Arc<Shared>,
}
impl CallbackTrait for Source {
fn prepare(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
screen: &ScreenDescriptor,
encoder: &mut wgpu::CommandEncoder,
resources: &mut CallbackResources,
) -> Vec<wgpu::CommandBuffer> {
self.cb.prepare(device, queue, screen, encoder, resources)
}
fn finish_prepare(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
resources: &mut CallbackResources,
) -> Vec<wgpu::CommandBuffer> {
let Some(view) = resources.get::<ViewRenderer>() else { return Vec::new() };
if !self.shared.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return Vec::new();
}
// Physical surface clamping is supplied by the pass owner, not inferred from DPI.
let Ok(mut inner) = self.shared.inner.lock() else { return Vec::new() };
let Some((size, scale)) = inner.screen else { return Vec::new() };
let screen = ScreenDescriptor { size_in_pixels: size, pixels_per_point: scale };
if self.shared.host.lost.is_lost() || inner.failure.is_some() {
return Vec::new();
}
// Read once after UI emission/output processing; transforms can be set after
// this callback was emitted. The callback shape itself stays in local space.
let Some([rect, clip, background]) = self.effective_geometry() else {
inner.failure = Some("invalid viewport source geometry");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
};
#[cfg(test)]
{
inner.geometry = Some([rect, clip, background]);
}
if self.colors.iter().any(|color| color.a() != 255) || self.outside.a() != 255 {
inner.failure = Some("translucent viewport/background source unsupported");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
}
if screen.size_in_pixels.contains(&0) || !screen.pixels_per_point.is_finite() || screen.pixels_per_point <= 0.0 {
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
}
if inner.source_seen || inner.source_count != 1 {
inner.failure = Some("multiple viewport sources in one frame");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
}
inner.source_seen = true;
let Some((steps, offset)) = schedule_capped(self.shared.radius, self.shared.tier_cap) else { return Vec::new() };
let Some(bytes) = target_bytes(screen.size_in_pixels, steps, self.shared.host.device.limits().max_texture_dimension_2d) else {
inner.failure = Some("blur target is empty, exceeds device limits or memory budget");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
};
let replace = inner.gpu.as_ref().is_none_or(|g| g.size != screen.size_in_pixels || g.steps != steps);
if replace {
inner.gpu = None;
inner.counts.clear_live();
let (gpu, failure) = egui_wgpu::capture_errors(device, || {
Gpu::new(device, self.shared.host.format, screen.size_in_pixels, steps, offset, &mut inner.counts)
});
if let Some(error) = failure {
log::warn!("blur resources refused: {error}");
inner.failure = Some("GPU refused blur resources");
inner.counts.clear_live();
return Vec::new();
}
inner.gpu = Some(gpu);
inner.counts.live_bytes += bytes;
}
let key = self.key(&screen, [rect, clip, background]);
let serial = inner.serial;
let marker_count = inner.markers.len();
let Inner { gpu, counts, .. } = &mut *inner;
let Some(gpu) = gpu else { return Vec::new() };
gpu.ready_serial = serial;
let (_, failed) = egui_wgpu::capture_errors(device, || gpu.grow_markers(device, marker_count, counts));
if let Some(error) = failed {
log::warn!("blur marker resources refused: {error}");
inner.failure = Some("GPU refused blur marker resources");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
}
if gpu.valid == Some(key) {
counts.cache_hits += 1;
return Vec::new();
}
let params = background_params(background, clip, self.colors, self.outside, screen.pixels_per_point, self.shared.host.format.is_srgb());
if params.iter().any(|value| !value.is_finite()) {
inner.failure = Some("invalid physical viewport source geometry");
inner.gpu = None;
inner.counts.clear_live();
return Vec::new();
}
queue.write_buffer(&gpu.background.uniform, 0, &bytes_of(¶ms));
{
let mut pass = pass(encoder, "blur_source", &gpu.source.view, wgpu::Color::BLACK);
pass.set_pipeline(&gpu.background_pipeline);
pass.set_bind_group(0, &gpu.background.group, &[]);
pass.draw(0..3, 0..1);
let viewport = pixel_rect(rect, screen.pixels_per_point, screen.size_in_pixels);
let clipped = pixel_rect(rect.intersect(clip), screen.pixels_per_point, screen.size_in_pixels);
if let (Some([x, y, w, h]), Some([cx, cy, cw, ch])) = (viewport, clipped) {
pass.set_scissor_rect(cx, cy, cw, ch);
view.paint(&self.cb.0, &mut pass, [x as f32, y as f32, w as f32, h as f32]);
}
}
counts.source_passes += 1;
// The backdrop pyramid is built at paint-order boundaries in render(),
// after the underlying UI has actually been drawn, rather than from this
// scene-only texture during preparation.
gpu.pending = Some(key);
Vec::new()
}
fn paint(&self, info: egui::PaintCallbackInfo, pass: &mut wgpu::RenderPass<'static>, resources: &CallbackResources) {
self.cb.paint(info, pass, resources);
}
}
impl Source {
fn effective_geometry(&self) -> Option<[Rect; 3]> {
let transform = self.context.layer_transform_to_global(self.layer).unwrap_or(egui::emath::TSTransform::IDENTITY);
if !transform.translation.is_finite() || !transform.scaling.is_finite() || transform.scaling <= 0.0 {
return None;
}
let geometry = [self.rect, self.clip, self.background].map(|r| transform.mul_rect(r));
(geometry.iter().all(|r| r.is_finite()) && geometry[0].is_positive()).then_some(geometry)
}
fn key(&self, screen: &ScreenDescriptor, geometry: [Rect; 3]) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
solidcraft_gpu::view::frame_key(&self.cb.0).hash(&mut h);
for r in geometry {
[r.min.x, r.min.y, r.max.x, r.max.y].map(f32::to_bits).hash(&mut h);
}
self.colors.hash(&mut h);
self.outside.hash(&mut h);
screen.size_in_pixels.hash(&mut h);
screen.pixels_per_point.to_bits().hash(&mut h);
self.shared.radius.to_bits().hash(&mut h);
self.shared.tier_cap.hash(&mut h);
self.shared.host.format.hash(&mut h);
h.finish()
}
}
struct PanelMarker {
shared: Arc<Shared>,
index: usize,
}
impl CallbackTrait for PanelMarker {
fn paint(&self, info: egui::PaintCallbackInfo, pass: &mut wgpu::RenderPass<'static>, _: &CallbackResources) {
let Ok(mut inner) = self.shared.inner.lock() else { return };
if !self.shared.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return;
}
if inner.failure.is_some() || self.shared.host.lost.is_lost() {
return;
}
let Some(marker) = inner.markers.get(self.index).copied() else { return };
let Some(gpu) = inner.gpu.as_ref() else { return };
if gpu.ready_serial != inner.serial || !inner.source_seen {
return;
}
let Some(binding) = gpu.markers.get(self.index) else { return };
let mut p = [0.0; 24];
p[2] = u8::from(self.shared.host.format.is_srgb()) as f32;
p[3] = marker.opacity;
let r = info.viewport;
if !r.is_finite() || !r.is_positive() {
return;
}
p[4..8].copy_from_slice(&[
r.min.x * info.pixels_per_point,
r.min.y * info.pixels_per_point,
r.max.x * info.pixels_per_point,
r.max.y * info.pixels_per_point,
]);
if marker.snap {
for value in &mut p[4..8] {
*value = value.round();
}
}
let scale = info.pixels_per_point * r.width() / marker.rect.width();
if !scale.is_finite() || p[4..8].iter().any(|v| !v.is_finite()) {
return;
}
p[8..12].copy_from_slice(&[marker.corners.nw, marker.corners.ne, marker.corners.sw, marker.corners.se].map(|v| f32::from(v) * scale));
if p.iter().any(|value| !value.is_finite()) {
return;
}
// A distinct retained uniform per marker: queue writes never alias another marker's draw.
self.shared.host.queue.write_buffer(&binding.uniform, 0, &bytes_of(&p));
pass.set_viewport(0.0, 0.0, gpu.size[0] as f32, gpu.size[1] as f32, 0.0, 1.0);
pass.set_pipeline(&gpu.panel);
pass.set_bind_group(0, &binding.group, &[]);
pass.draw(0..3, 0..1);
inner.counts.markers_drawn += 1;
}
}
impl FrameCompositor for Shared {
fn begin_viewport(&self, viewport: u64) {
self.painting_owner.store(viewport == egui::ViewportId::ROOT.0.value(), std::sync::atomic::Ordering::Relaxed);
}
fn screen(&self, screen: &ScreenDescriptor, _: &mut CallbackResources) {
if !self.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return;
}
if let Ok(mut inner) = self.inner.lock() {
inner.screen = Some((screen.size_in_pixels, screen.pixels_per_point));
}
}
fn suspend(&self) {
if !self.host.lost.is_lost() && !self.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return;
}
if let Ok(mut inner) = self.inner.lock() {
inner.gpu = None;
inner.counts.clear_live();
inner.source_seen = false;
}
}
fn render(
&self,
renderer: &egui_wgpu::Renderer,
encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView,
jobs: &[egui::ClippedPrimitive],
screen: &ScreenDescriptor,
clear: [f32; 4],
) -> bool {
if self.host.lost.is_lost() {
return false;
}
if !self.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return false;
}
let (composition, pipeline, binding, marker_ids) = {
let Ok(mut inner) = self.inner.lock() else { return false };
if !inner.source_seen {
inner.missing_source = true;
inner.gpu = None;
inner.counts.clear_live();
return false;
}
inner.missing_source = false;
if inner.failure.is_some() {
return false;
}
let Some(gpu) = inner.gpu.as_ref() else { return false };
if gpu.ready_serial != inner.serial || gpu.size != screen.size_in_pixels {
return false;
}
let mut marker_ids: Vec<_> = inner.markers.iter().map(|marker| marker.callback_id).collect();
marker_ids.sort_unstable();
let data = (gpu.composition.view.clone(), gpu.present.clone(), gpu.presentation.group.clone(), marker_ids);
inner.counts.composition_passes += 1;
data
};
{
let color = wgpu::Color { r: clear[0] as f64, g: clear[1] as f64, b: clear[2] as f64, a: clear[3] as f64 };
let _clear = pass(encoder, "blur_ui_composition", &composition, color);
}
let mut start = 0;
let mut mesh_offset = 0;
let mut segment_passes = 0;
for end in 0..=jobs.len() {
let callback_id = jobs.get(end).and_then(|job| {
let egui::epaint::Primitive::Callback(callback) = &job.primitive else { return None };
Some(Arc::as_ptr(&callback.callback) as *const () as usize)
});
let marker = callback_id.is_some_and(|identity| marker_ids.binary_search(&identity).is_ok());
if !marker && end != jobs.len() {
continue;
}
if start < end {
let mut ui = load_pass(encoder, "blur_ui_segment", &composition);
renderer.render_with_mesh_offset(&mut ui, &jobs[start..end], screen, mesh_offset);
mesh_offset += jobs[start..end].iter().filter(|job| matches!(&job.primitive, egui::epaint::Primitive::Mesh(_))).count();
segment_passes += 1;
}
if marker {
// The preceding segment is complete before sampling its color target.
// Reuse the pyramid, but include previously painted UI in the backdrop.
if let Ok(mut inner) = self.inner.lock() {
let Inner { gpu, counts, .. } = &mut *inner;
if let Some(gpu) = gpu {
for step in &gpu.chain {
let mut blur = pass(encoder, "blur_backdrop", &step.target.view, wgpu::Color::TRANSPARENT);
blur.set_pipeline(if step.down { &gpu.down } else { &gpu.up });
blur.set_bind_group(0, &step.binding.group, &[]);
blur.draw(0..3, 0..1);
counts.blur_passes += 1;
}
}
}
}
start = end;
}
{
let mut present = pass(encoder, "blur_present", target, wgpu::Color::TRANSPARENT);
present.set_pipeline(&pipeline);
present.set_bind_group(0, &binding, &[]);
present.draw(0..3, 0..1);
}
if let Ok(mut inner) = self.inner.lock() {
inner.counts.composition_passes += segment_passes;
inner.counts.present_passes += 1;
inner.rendered = true;
}
true
}
fn submitted(&self) {
if !self.painting_owner.load(std::sync::atomic::Ordering::Relaxed) {
return;
}
if let Ok(mut inner) = self.inner.lock() {
if inner.rendered && inner.counts.markers_drawn > inner.drawn_before && !self.host.lost.is_lost() {
let now = std::time::Instant::now();
inner.painted = Some(PaintedFrame {
frame: inner.frame,
interval_ms: inner.submitted_at.map(|at| now.duration_since(at).as_secs_f64() * 1000.0),
continuous: inner.continuous,
});
inner.submitted_at = Some(now);
inner.rendered = false;
} else {
inner.painted = None;
inner.submitted_at = None;
}
if self.host.lost.is_lost() {
inner.gpu = None;
inner.counts.clear_live();
inner.failure = Some("device lost");
} else if let Some(gpu) = inner.gpu.as_mut()
&& let Some(key) = gpu.pending.take()
{
gpu.valid = Some(key);
}
}
}
}
struct Target {
_texture: wgpu::Texture,
view: wgpu::TextureView,
}
struct Binding {
uniform: wgpu::Buffer,
group: wgpu::BindGroup,
}
struct Step {
target: Target,
binding: Binding,
down: bool,
}
struct Gpu {
size: [u32; 2],
steps: usize,
source: Target,
composition: Target,
chain: Vec<Step>,
background: Binding,
presentation: Binding,
markers: Vec<Binding>,
background_pipeline: wgpu::RenderPipeline,
down: wgpu::RenderPipeline,
up: wgpu::RenderPipeline,
panel: wgpu::RenderPipeline,
present: wgpu::RenderPipeline,
layout: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
valid: Option<u64>,
pending: Option<u64>,
ready_serial: u64,
}
fn bytes_of(params: &Params) -> [u8; 96] {
let mut bytes = [0; 96];
for (out, value) in bytes.as_chunks_mut::<4>().0.iter_mut().zip(params) {
out.copy_from_slice(&value.to_le_bytes());
}
bytes
}
fn target_bytes(size: [u32; 2], steps: usize, max: u32) -> Option<u64> {
let [w, h] = size;
if w == 0 || h == 0 || w > max || h > max || !(2..=5).contains(&steps) {
return None;
}
// S/C are four-byte UI textures; every down/up target is linear RGBA16F.
let mut total = u64::from(w).checked_mul(u64::from(h))?.checked_mul(8)?;
let mut dims = size;
for _ in 0..steps {
dims = dims.map(|d| d.div_ceil(2));
total = total.checked_add(u64::from(dims[0]).checked_mul(u64::from(dims[1]))?.checked_mul(8)?)?;
}
dims = size;
for _ in 0..steps {
total = total.checked_add(u64::from(dims[0]).checked_mul(u64::from(dims[1]))?.checked_mul(8)?)?;
dims = dims.map(|d| d.div_ceil(2));
}
(total <= BUDGET).then_some(total)
}
fn pixel_rect(rect: Rect, scale: f32, size: [u32; 2]) -> Option<[u32; 4]> {
if !rect.is_finite() || !rect.is_positive() || !scale.is_finite() || scale <= 0.0 {
return None;
}
let x = (rect.min.x * scale).round().clamp(0.0, size[0] as f32) as u32;
let y = (rect.min.y * scale).round().clamp(0.0, size[1] as f32) as u32;
let right = (rect.max.x * scale).round().clamp(x as f32, size[0] as f32) as u32;
let bottom = (rect.max.y * scale).round().clamp(y as f32, size[1] as f32) as u32;
(right > x && bottom > y).then_some([x, y, right - x, bottom - y])
}
fn background_params(rect: Rect, clip: Rect, colors: [Color32; 2], outside: Color32, scale: f32, srgb: bool) -> Params {
let mut p = [0.0; 24];
p[2] = u8::from(srgb) as f32;
p[4..8].copy_from_slice(&[rect.min.x * scale, rect.min.y * scale, rect.max.x * scale, rect.max.y * scale]);
p[8..12].copy_from_slice(&[clip.min.x * scale, clip.min.y * scale, clip.max.x * scale, clip.max.y * scale]);
for (out, color) in p[12..24].as_chunks_mut::<4>().0.iter_mut().zip(colors.into_iter().chain([outside])) {
out.copy_from_slice(&color.to_normalized_gamma_f32());
}
p
}
fn pass(encoder: &mut wgpu::CommandEncoder, label: &'static str, view: &wgpu::TextureView, clear: wgpu::Color) -> wgpu::RenderPass<'static> {
attachment_pass(encoder, label, view, wgpu::LoadOp::Clear(clear))
}
fn load_pass(encoder: &mut wgpu::CommandEncoder, label: &'static str, view: &wgpu::TextureView) -> wgpu::RenderPass<'static> {
attachment_pass(encoder, label, view, wgpu::LoadOp::Load)
}
fn attachment_pass(
encoder: &mut wgpu::CommandEncoder,
label: &'static str,
view: &wgpu::TextureView,
load: wgpu::LoadOp<wgpu::Color>,
) -> wgpu::RenderPass<'static> {
encoder
.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(label),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations { load, store: wgpu::StoreOp::Store },
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
})
.forget_lifetime()
}
impl Gpu {
fn new(device: &wgpu::Device, format: wgpu::TextureFormat, size: [u32; 2], steps: usize, offset: f32, counts: &mut Counters) -> Self {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("blur bindings"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: std::num::NonZeroU64::new(96),
},
count: None,
},
],
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("blur clamp"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("SolidCraft blur"),
source: wgpu::ShaderSource::Wgsl(include_str!("blur.wgsl").into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("blur pipeline layout"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let background_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("blur background uniform only"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: std::num::NonZeroU64::new(96),
},
count: None,
}],
});
let background_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("blur source cannot sample composition"),
bind_group_layouts: &[Some(&background_layout)],
immediate_size: 0,
});
let pipeline = |entry: &str, target, blend, layout: &wgpu::PipelineLayout| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(entry),
layout: Some(layout),
vertex: wgpu::VertexState { module: &module, entry_point: Some("vertex"), buffers: &[], compilation_options: Default::default() },
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some(entry),
targets: &[Some(wgpu::ColorTargetState { format: target, blend, write_mask: wgpu::ColorWrites::ALL })],
compilation_options: Default::default(),
}),
multiview_mask: None,
cache: None,
})
};
let down = pipeline("down", wgpu::TextureFormat::Rgba16Float, None, &pipeline_layout);
let up = pipeline("up", wgpu::TextureFormat::Rgba16Float, None, &pipeline_layout);
let panel = pipeline("panel", format, Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING), &pipeline_layout);
let present = pipeline("present", format, None, &pipeline_layout);
let background_pipeline = pipeline("background", format, None, &background_pipeline_layout);
counts.pipelines_created += 5;
counts.live_pipelines += 5;
let source = Target::new(device, size, format, counts);
let composition = Target::new(device, size, format, counts);
let background = Binding::background(device, &background_layout, counts);
let presentation = Binding::new(device, &layout, &sampler, &composition.view, [0.0; 24], counts);
let mut chain: Vec<Step> = Vec::new();
let mut dimensions = Vec::with_capacity(steps + 1);
dimensions.push(size);
for _ in 0..steps {
let last = dimensions.last().copied().unwrap_or(size);
dimensions.push(last.map(|d| d.div_ceil(2)));
}
for (index, dims) in dimensions.iter().skip(1).enumerate() {
let input = chain.last().map_or(&composition.view, |s| &s.target.view);
let mut p = [0.0; 24];
p[0] = offset;
p[1] = u8::from(index == 0 && !format.is_srgb()) as f32;
let binding = Binding::new(device, &layout, &sampler, input, p, counts);
let target = Target::new(device, *dims, wgpu::TextureFormat::Rgba16Float, counts);
chain.push(Step { target, binding, down: true });
}
for dims in dimensions.iter().take(steps).rev() {
let input = chain.last().map_or(&composition.view, |s| &s.target.view);
let mut p = [0.0; 24];
p[0] = offset;
let binding = Binding::new(device, &layout, &sampler, input, p, counts);
let target = Target::new(device, *dims, wgpu::TextureFormat::Rgba16Float, counts);
chain.push(Step { target, binding, down: false });
}
Self {
size,
steps,
source,
composition,
chain,
background,
presentation,
markers: Vec::new(),
background_pipeline,
down,
up,
panel,
present,
layout,
sampler,
valid: None,
pending: None,
ready_serial: 0,
}
}
fn grow_markers(&mut self, device: &wgpu::Device, count: usize, counts: &mut Counters) {
let Some(last) = self.chain.last() else { return };
while self.markers.len() < count {
self.markers.push(Binding::new(device, &self.layout, &self.sampler, &last.target.view, [0.0; 24], counts));
}
}
}
impl Target {
fn new(device: &wgpu::Device, size: [u32; 2], format: wgpu::TextureFormat, counts: &mut Counters) -> Self {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("blur target"),
size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 },
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
counts.textures_created += 1;
counts.live_textures += 1;
let view = texture.create_view(&Default::default());
Self { _texture: texture, view }
}
}
impl Binding {
fn background(device: &wgpu::Device, layout: &wgpu::BindGroupLayout, counts: &mut Counters) -> Self {
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("blur background parameters"),
size: 96,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
counts.buffers_created += 1;
counts.live_buffers += 1;
counts.live_bytes += 96;
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("blur background has no input texture"),
layout,
entries: &[wgpu::BindGroupEntry { binding: 2, resource: uniform.as_entire_binding() }],
});
counts.bind_groups_created += 1;
counts.live_bind_groups += 1;
Self { uniform, group }
}
fn new(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
sampler: &wgpu::Sampler,
view: &wgpu::TextureView,
params: Params,
counts: &mut Counters,
) -> Self {
use wgpu::util::DeviceExt as _;
let uniform = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("blur parameters"),
contents: &bytes_of(¶ms),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
counts.buffers_created += 1;
counts.live_buffers += 1;
counts.live_bytes += 96;
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("blur sample"),
layout,
entries: &[
wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(view) },
wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(sampler) },
wgpu::BindGroupEntry { binding: 2, resource: uniform.as_entire_binding() },
],
});
counts.bind_groups_created += 1;
counts.live_bind_groups += 1;
Self { uniform, group }
}
}