diff --git a/crates/nodes/src/pattern/coordinates.rs b/crates/nodes/src/pattern/coordinates.rs new file mode 100644 index 0000000..d8b58ea --- /dev/null +++ b/crates/nodes/src/pattern/coordinates.rs @@ -0,0 +1,104 @@ +use super::{footprint::Footprint, region::Region}; +use crate::function::truncate_float; + +/// The two signed coordinate gradients for a stamp whose edges land on whole pixels. +pub(super) struct PixelPlanes { + axes: [Axis; 2], + swap: bool, +} + +struct Axis { + base: f64, + step: f64, +} + +impl PixelPlanes { + pub fn new(frame: &Footprint, region: &Region, center: [f32; 2], size: [f32; 2], dimensions: [u32; 2]) -> Option { + let swap = frame.cosine == 0.0; + let signs = if swap && frame.sine.abs() == 1.0 { + [-frame.sine * size[1].signum(), frame.sine * size[0].signum()] + } else if frame.sine == 0.0 && frame.cosine.abs() == 1.0 { + [frame.cosine * size[0].signum(), frame.cosine * size[1].signum()] + } else { + return None; + }; + let bounds: [[f64; 2]; 2] = std::array::from_fn(|axis| region.pixel_interval(axis, center[axis], frame.radius[axis], dimensions[axis])); + let extents = bounds.map(|[left, right]| right - left); + let padded = extents.map(|extent| (extent + 0.5) as f32); + // Fractional edges and extents too large to retain the half pixel use the ordinary footprint calculation. + if bounds.iter().flatten().any(|edge| edge.fract() != 0.0) + || extents.iter().zip(padded).any(|(&extent, pad)| !(1.0..8_388_608.0).contains(&extent) || f64::from(pad) != extent + 0.5) + { + return None; + } + let reciprocal = area_reciprocal(truncate_float(f64::from(padded[0]) * f64::from(padded[1]))); + let axes = std::array::from_fn(|axis| { + let basis = truncate_float(f64::from(padded[1 - axis]) * f64::from(reciprocal)); + let span = (2.0 + extents[axis].recip()) as f32; + let step = f64::from(gradient_product(basis, span)); + let left = bounds[axis][0]; + let origin = (left.max(0.0) * 0.25).floor() * 4.0; + let base = truncate_float((origin - left).mul_add(step, -1.0)); + let sign = f64::from(signs[axis]); + Axis { base: ((0.5 - origin) * step + f64::from(base)) * sign, step: step * sign } + }); + Some(Self { axes, swap }) + } + + pub fn sample(&self, x: u32, y: u32) -> [f32; 2] { + let mut p = [self.axes[0].sample(x), self.axes[1].sample(y)]; + if self.swap { + p.swap(0, 1); + } + p + } +} + +impl Axis { + fn sample(&self, pixel: u32) -> f32 { + let value = f64::from(pixel).mul_add(self.step, self.base); + let stored = truncate_float(value); + if value < 0.0 && f64::from(stored) == value { stored.next_up() } else { stored } + } +} + +// Interpolate 1/x from its two endpoints and midpoint in each normalized mantissa interval. +// The three samples use quarter units. The squared interpolation fraction retains sixteen bits. +fn area_reciprocal(area: f32) -> f32 { + let bits = area.to_bits(); + let start = 2 * (128 + i64::from((bits >> 16) & 127)); + let [a, b, c] = [start, start + 1, start + 2].map(|denominator| (1_i64 << 34) / denominator); + let t = i64::from(bits & 0xffff); + let square = (t * t) >> 16; + let value = (a << 16) + (4 * b - 3 * a - c) * t + (2 * a - 4 * b + 2 * c) * square; + let significand = ((value + (1 << 17)) >> 18) as u32; + f32::from_bits(((252 - (bits >> 23)) << 23) + significand) +} + +fn gradient_product(basis: f32, span: f32) -> f32 { + // Both inputs are positive normal values. Round the magnitude of each signed radix-four + // partial product before accumulating it. The low bit of the span is a separate row. + const FRACTION: u32 = (1 << 23) - 1; + let significand = |value: f32| i64::from((value.to_bits() & FRACTION) | (1 << 23)); + let a = significand(span); + let b = significand(basis); + let rounding_error = |row: i64| { + let magnitude = row.abs(); + let rounded = (magnitude + (1 << 16)) & !((1 << 17) - 1); + row.signum() * (rounded - magnitude) + }; + let mut product = a * b + rounding_error((a & 1) * b); + let mut carry = 0; + // Higher rows are already multiples of 2^17 and contribute no rounding error. + for bit in (1..17).step_by(2) { + let pair = (a >> bit) & 3; + let high = pair >> 1; + let digit = (pair & 1) - 2 * high + carry; + product += rounding_error((digit * b) << bit); + carry = high; + } + let product = (product + (1 << 20)) as u64; + let overflow = u32::from(product >= 1 << 47); + let exponent = (span.to_bits() >> 23) + (basis.to_bits() >> 23) - 127 + overflow; + f32::from_bits((exponent << 23) | ((product >> (23 + overflow)) as u32 & FRACTION)) +} diff --git a/crates/nodes/src/pattern/mod.rs b/crates/nodes/src/pattern/mod.rs index f509dbb..5198a92 100644 --- a/crates/nodes/src/pattern/mod.rs +++ b/crates/nodes/src/pattern/mod.rs @@ -1,6 +1,7 @@ mod bitmap; mod blend; mod catalog; +mod coordinates; mod evaluation; mod footprint; mod pattern_stamp; diff --git a/crates/nodes/src/pattern/raster.rs b/crates/nodes/src/pattern/raster.rs index 8b1280c..1c794c5 100644 --- a/crates/nodes/src/pattern/raster.rs +++ b/crates/nodes/src/pattern/raster.rs @@ -2,7 +2,7 @@ use craft_texture::{Image, Kind, Limits}; use materialcraft_core::OutputFormat; use std::sync::Arc; -use super::{bitmap, blend, footprint::Footprint, pattern_stamp::PatternStamp, region::Region, shape}; +use super::{bitmap, blend, coordinates::PixelPlanes, footprint::Footprint, pattern_stamp::PatternStamp, region::Region, shape}; use crate::CookContext; use crate::atomic::input_resize::{InputResize, resized_input}; use crate::function::flush_subnormal; @@ -107,11 +107,21 @@ pub(super) fn render(context: &CookContext, stamps: &[PatternStamp], max_depth: let center = [center[0] + repeat_x as f32 * period[0], center[1] + repeat_y as f32 * period[1]]; let [[left, right], [top, bottom]] = render_region.bounds(center, radius, [width, height]); let samples = u64::from(right.saturating_sub(left)) * u64::from(bottom.saturating_sub(top)); + if samples == 0 { + continue; + } budget = budget.checked_sub(samples).ok_or("pattern rendering exceeded its pixel budget")?; + // Sampled bitmaps keep the texture coordinates used by point and mip filtering. + let planes = if texture.is_none() { PixelPlanes::new(&frame, &render_region, center, stamp.size, [width, height]) } else { None }; for y in top..bottom { for x in left..right { - let point = render_region.point([x, y], [width, height]); - let Some(local) = frame.local(point, center, stamp.size) else { continue }; + let local = if let Some(planes) = &planes { + planes.sample(x, y) + } else { + let point = render_region.point([x, y], [width, height]); + let Some(local) = frame.local(point, center, stamp.size) else { continue }; + local + }; let (foreground, stamp_alpha) = if let Some((input, format)) = &texture { let sample = bitmap::sample(input, local, *format, stamp.filtering == 2).map(flush_subnormal); diff --git a/crates/nodes/src/pattern/region.rs b/crates/nodes/src/pattern/region.rs index f18b5b1..b54c3ab 100644 --- a/crates/nodes/src/pattern/region.rs +++ b/crates/nodes/src/pattern/region.rs @@ -33,6 +33,12 @@ impl Region { std::array::from_fn(|axis| self.start[axis] + (pixel[axis] as f32 + 0.5) / size[axis] as f32 * self.span[axis]) } + pub fn pixel_interval(&self, axis: usize, center: f32, radius: f32, pixels: u32) -> [f64; 2] { + let origin = f64::from(center) - f64::from(self.start[axis]); + let scale = f64::from(pixels) / f64::from(self.span[axis]); + [(origin - f64::from(radius)) * scale, (origin + f64::from(radius)) * scale] + } + pub fn bounds(&self, center: [f32; 2], radius: [f32; 2], size: [u32; 2]) -> [[u32; 2]; 2] { std::array::from_fn(|axis| { let a = (center[axis] - radius[axis] - self.start[axis]) / self.span[axis]; diff --git a/crates/nodes/src/pattern/tests.rs b/crates/nodes/src/pattern/tests.rs index a619b17..09ec420 100644 --- a/crates/nodes/src/pattern/tests.rs +++ b/crates/nodes/src/pattern/tests.rs @@ -269,6 +269,50 @@ fn stamp_gradients_keep_the_phase_of_extended_turns() { } } +#[test] +fn gaussian_stamp_coordinates_follow_the_pixel_footprint() { + let definition = find("fx_map").unwrap(); + let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant); + graph.nodes[0].parameters = BTreeMap::from([ + ("patterntype".into(), Value::Int(6)), + ("blendingmode".into(), Value::Int(1)), + ("patternsize".into(), Value::Float2([3.0, 1.5])), + ("frameoffset".into(), Value::Float2([-0.25; 2])), + ]); + let params = resolve_params( + definition, + &BTreeMap::from([ + ("pattern".into(), Value::PatternGraph(Box::new(graph))), + ("color_mode".into(), Value::Bool(false)), + ("roughness".into(), Value::Float(0.0)), + ("opacity".into(), Value::Float(0.995)), + ]), + ); + for (w, h, x, y, expected) in [ + (16, 16, 7, 1, 0x3ef8_8006), + (16, 32, 0, 14, 0x3eb2_37e3), + (32, 32, 0, 14, 0x3eac_19c4), + (8, 64, 0, 30, 0x3e9b_8a3c), + (64, 128, 2, 62, 0x3e85_65a0), + (128, 256, 0, 126, 0x3e69_16dd), + ] { + let context = CookContext { + w, + h, + seed: 223, + format: materialcraft_core::OutputFormat::F32, + input_formats: &[], + tile: false, + inputs: &[], + params: ¶ms, + resource: &|_| None, + vars: &BTreeMap::new(), + }; + let image = (definition.cook)(&context).unwrap().remove(0); + assert_eq!(image.get_gray(x, y, false).to_bits(), expected, "{w}x{h} at ({x},{y})"); + } +} + #[test] fn oblique_square_keeps_the_last_sample_inside_its_edge() { let mut graph = PatternGraph::with_root(PatternNodeKind::Quadrant); diff --git a/docs/parity-fixes.md b/docs/parity-fixes.md index e08f1b0..cd0cfa7 100644 --- a/docs/parity-fixes.md +++ b/docs/parity-fixes.md @@ -510,6 +510,30 @@ Draw an unrotated, white, single stamp on black with maximum blending and no til Every reference Gaussian pixel outside its paired disc was zero in both sweeps, 29,406/29,406 and 127,365/127,365. The probes leave equality at exactly r² = 1 unresolved. The implementation applies the cutoff only above one. Differences in the interior remain. On the earlier whole-root matrices, Alveolus still matches 332,280/334,336 pixels and the pattern variant 201,876/203,264. Their maximum U8/U16/F16/F32 errors are 0/1,000/0/3.05175781e−5 and 0/2/0/1.52587891e−5 respectively. The two brick-generator Tile helpers each retain 114,688/114,688 LUM16 pixels across four renders. The boundary regression failed before the fix. All 262 release node tests, formatting, strict workspace Clippy, layers and WebAssembly passed. +### Pixel coordinates for whole-pixel pattern stamps + +The two Alveolus roots use the same Gaussian stamp at different resolutions. In the 32×16 unfilled Alveolus case, the 16² generator pixel at (15,9) previously stored 31,807 in U16. The reference stores 31,808. It moves two output pixels, at (7,9) and (23,9). An original 16² Gaussian at center (.25,.25), size (3,1.5), maximum blend, opacity .995 and zero rotation distinguishes the coordinate step before storage. At (7,1) its F32 bits are `3ef88006`. The earlier three-guard-bit product gives `3ef88001`. At physical stamp size 48×24 the measured steps are `3d2aaaa9` horizontally and `3daaaaab` vertically. + +For an axis-aligned analytic stamp whose edges land on whole pixels, form its two pixel extents plus .5. Truncate their product to F32 before taking its reciprocal. The interpolation basis on each axis is the opposite padded extent times that reciprocal, truncated to F32. The coordinate step multiplies this basis by F32(2 + 1/extent). Treat the span’s lowest significand bit as a separate partial product. Recode the remaining bits in signed radix four, round each partial product’s magnitude to a multiple of 2¹⁷, and add 2²⁰ before storing the normalized product. Use the left edge and the preceding four-pixel boundary to set up the affine coordinate. The saved regression exercises six rectangular and square Gaussian samples. Fractional edges and oblique angles still have separate unverified cases. Sampled images retain their point and mip filtering coordinates. + +**Independent interpolation check.** Render a four-vertex triangle strip with a 4×4 viewport and pixel-space corners (0,0), (X,0), (0,Y), (X,Y). Give the corners the respective attributes (0,0), (A,0), (0,A), (A,A), with clip W equal to one. Read the raw F32 pair at pixel (0,0) and double it to obtain the two gradients. The two directions matched at 78,000/78,000 calibration values and 40,000/40,000 held-out values, maximum error zero. The held-out set included quarter-pixel extents up to 1,600 and amplitudes with eleven exponent values. Truncating the area corrected the 1,000 held-out products that differed with a nearest-rounded area. + +For a shorter reproducible sweep, start a 32-bit unsigned state at `0x51c37e29`. Advance by `state = 1664525 × state + 1013904223` modulo 2³². For each of 8,192 rectangles take three successive states a, b and c. Obtain X and Y from a and b with `1 + (s mod 1599) + ((s >> 20) & 3)/4`. Use the F32 amplitude with bits `((121 + c mod 11) << 23) | (c >> 9)`. The unit-amplitude check matches 16,384/16,384 gradients and the variable-amplitude check matches 16,384/16,384, maximum error zero, on the same Direct3D 11 device as the reference. + +| Complete output or independent control | Renders | Exact pixels | Maximum error | +|---|---:|---:|---:| +| Alveolus, earlier root matrices | 41 | 334,336/334,336 | 0 | +| Pattern Alveolus, earlier root matrices | 33 | 203,264/203,264 | 0 | +| Alveolus, follow-up matrix | 25 | 681,728/681,728 | 0 | +| Pattern Alveolus, follow-up matrix | 25 | 681,728/681,728 | 0 | +| Unit horizontal ramp at zero and half turns, F32 | 72 | 2,032,128/2,032,128 | 0 | +| Paraboloid, Gaussian and horizontal ramp in three render regions, F32 | 90 | 552,960/552,960 | 0 | +| Previously verified roots using the pattern primitive | 167 | 3,139,328/3,139,328 | 0 | + +For each root’s 25 follow-up renders, the 5,120 U8, 553,728 U16, 78,336 F16 and 44,544 F32 output pixels also match after reopening its MaterialCraft save in both apps. The 17 previously verified roots were rechecked with their recorded settings, including the matching preview size for Position Debug. Gradient Linear 1 still differs at 224/435,968 pixels across 47 renders. The extended 1.5-turn case remains open. Gradient Linear 3 now matches 277,760/277,760 pixels across its earlier 23 renders. [Root settings and saved-file checks](#reopening-sbs-files-with-release-number-headers) · [Ramp dimensions, seeds and extended turns](#linear-gradient-sampling-on-rectangular-targets) · [Render-region controls](#pattern-coordinates-under-a-change-of-render-region) + +In a single-worker release run, four interleaved measurements of the 128² default, 256² default and 512² filled cases gave median whole-graph cook times of 46, 259 and 1,138 ms for Alveolus (previously 45, 247 and 1,068 ms). Pattern Alveolus took 45, 253 and 1,083 ms (previously 43, 238 and 1,045 ms). + ### Reopening SBS files with release-number headers Save both Alveolus roots, then open each saved file as a user package in the reference app (16.0.7). With the earlier writer both files declare format version `0.1.3` and updater `0.4.1`. Both opens fail. Changing only the format revision to `1.1.0.202502` makes both files open. Changing only the updater, package identity or graph name leaves both opens failing. diff --git a/docs/sbs-root-nodes.md b/docs/sbs-root-nodes.md index f37e6b8..1f0f0ff 100644 --- a/docs/sbs-root-nodes.md +++ b/docs/sbs-root-nodes.md @@ -35,7 +35,7 @@ A graph may accept input pins and still be a root under the dependency criterion Statuses: **Not checked**, **In progress**, **Parity** (exact pixels or typed values for the linked measured cases), or **Too hard** (reason recorded). Function calls do not count as regular graph dependencies. -The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard**. The current inventory has **376 Parity**, **170 In progress** and **0 Too hard**. The November 17–20 comparisons include raw counts, output formats and remaining differences. [November 17 measurements](parity-fixes.md#2026-11-17-root-comparisons) · [November 18 measurements](parity-fixes.md#2026-11-18-root-comparisons) · [November 19 measurements](parity-fixes.md#2026-11-19-root-comparisons) · [November 20 measurements](parity-fixes.md#2026-11-20-root-comparisons) +The first pass covered all **546 roots**, with **166 Parity** and **380 Too hard**. The current inventory has **378 Parity**, **168 In progress** and **0 Too hard**. The November 17–20 comparisons include raw counts, output formats and remaining differences. [November 17 measurements](parity-fixes.md#2026-11-17-root-comparisons) · [November 18 measurements](parity-fixes.md#2026-11-18-root-comparisons) · [November 19 measurements](parity-fixes.md#2026-11-19-root-comparisons) · [November 20 measurements](parity-fixes.md#2026-11-20-root-comparisons) [Pattern tiling axes and copy bounds across 215 renders](parity-fixes.md#tiling-axes-and-pattern-copy-bounds) · [Grayscale sampler measurements](parity-fixes.md#grayscale-sampling-of-color-inputs) · [Value sampling across 240 typed comparisons](parity-fixes.md#value-processor-texture-filtering) · [Five saved graphs reopened in the reference](parity-fixes.md#saved-filter-graphs-and-scalar-levels-controls) @@ -71,6 +71,8 @@ Reduced Sharpen now matches 16,704/16,704 pixels on the held-out signed field an A change to Gaussian stamp coverage was checked against 61 roots. Additional rectangular captures reopened both brick-generator Tile helpers. [Root checks](parity-fixes.md#root-checks-after-clipping-gaussian-stamps) [Tile input and shape comparisons](parity-fixes.md#rectangular-fields-in-the-two-brick-generator-tile-helpers) +Both Alveolus roots now match every measured pixel. The corrected stamp coordinates also match all 2,032,128 pixels in the 72 zero- and half-turn gradient controls. [Coordinate and complete-root measurements](parity-fixes.md#pixel-coordinates-for-whole-pixel-pattern-stamps) + The reference app reopened both intact Alveolus graphs saved with the corrected SBS schema header. In each app all 1,363,456 pixels across 50 reopened renders match that app’s output before saving. [Save and reopen measurements](parity-fixes.md#reopening-sbs-files-with-release-number-headers) ## Complete inventory @@ -96,7 +98,7 @@ The reference app reopened both intact Alveolus graphs saved with the corrected | [3d_viewer.sbs/ibl_specular_contrib_anisotropic/panoramic_lod](../assets/sbs/3d_viewer.sbs) | 1 | Yes | [Parity · 20 cases, 219,392 exact pixels](parity-fixes.md#large-transform-offsets-and-additive-blends) | | [3d_volume_mask.sbs/3d_volume_mask](../assets/sbs/3d_volume_mask.sbs) | 1 | No | [Parity · 116 renders, all 1,029,632 pixels exact](parity-fixes.md#pixel-quotients-and-volume-mask-interpolation) | | [3d_worley_noise.sbs/3D_worley_noise](../assets/sbs/3d_worley_noise.sbs) | 1 | No | [Parity · 34 renders, 312,832 exact pixels](parity-fixes.md#per-pixel-random-initialization) | -| [alveolus.sbs/alveolus](../assets/sbs/alveolus.sbs) | 0 | Yes | [In progress · 332,280/334,336 pixels across 41 renders](parity-fixes.md#square-and-rectangular-pattern-generators) · [Single-stamp render-region comparisons](parity-fixes.md#pattern-coordinates-under-a-change-of-render-region) · [Gaussian disc-boundary sweeps](parity-fixes.md#gaussian-coverage-at-the-disc-boundary) · [262,144/262,144 pixels after isolating the generator](parity-fixes.md#alveolus-filters-after-the-first-differing-stage) · [Two-stamp reconstruction at eight sizes](parity-fixes.md#four-source-pixels-in-the-filled-alveolus-cells) | +| [alveolus.sbs/alveolus](../assets/sbs/alveolus.sbs) | 0 | Yes | [Parity · 1,016,064/1,016,064 pixels across 66 renders](parity-fixes.md#pixel-coordinates-for-whole-pixel-pattern-stamps) · [Single-stamp render-region comparisons](parity-fixes.md#pattern-coordinates-under-a-change-of-render-region) · [Gaussian disc-boundary sweeps](parity-fixes.md#gaussian-coverage-at-the-disc-boundary) · [262,144/262,144 pixels after isolating the generator](parity-fixes.md#alveolus-filters-after-the-first-differing-stage) · [Two-stamp reconstruction at eight sizes](parity-fixes.md#four-source-pixels-in-the-filled-alveolus-cells) | | [angle_to_vector.sbs/angle_to_vector](../assets/sbs/angle_to_vector.sbs) | 1 | No | [Parity: 4 cases](parity-fixes.md#verified-cases) | | [anisotropic_blur.sbs/anisotropic_blur](../assets/sbs/anisotropic_blur.sbs) | 1 | No | [Parity · 29 renders, 200,192 exact pixels across four formats](parity-fixes.md#integer-and-oblique-directional-blur) | | [anisotropic_blur.sbs/anisotropic_blur_grayscale](../assets/sbs/anisotropic_blur.sbs) | 1 | No | [Parity · 29 renders, 200,192 exact pixels across four formats](parity-fixes.md#integer-and-oblique-directional-blur) | @@ -430,7 +432,7 @@ The reference app reopened both intact Alveolus graphs saved with the corrected | [paths_tools.sbs/paths_trace](../assets/sbs/paths_tools.sbs) | 2 | No | [In progress · 58,213/58,624 pixels in 19 renders](parity-fixes.md#paths-caustics-and-cell-fields-after-pattern-sampling) · [Stamp-width recheck](parity-fixes.md#pixel-reciprocals-for-stamp-edge-widths) | | [paths_tools.sbs/vertex_processor](../assets/sbs/paths_tools.sbs) | 9 | No | [Parity · 18 renders, all 57,600 pixels exact](parity-fixes.md#marked-variable-reads-in-path-and-mipmap-graphs) | | [paths_tools.sbs/vertex_processor_simple](../assets/sbs/paths_tools.sbs) | 5 | No | [Parity · 18 renders, all 57,600 pixels exact](parity-fixes.md#marked-variable-reads-in-path-and-mipmap-graphs) | -| [pattern_alveolus.sbs/alveolus](../assets/sbs/pattern_alveolus.sbs) | 0 | No | [In progress · 201,876/203,264 pixels across 33 renders](parity-fixes.md#square-and-rectangular-pattern-generators) · [Single-stamp render-region comparisons](parity-fixes.md#pattern-coordinates-under-a-change-of-render-region) · [Gaussian disc-boundary sweeps](parity-fixes.md#gaussian-coverage-at-the-disc-boundary) · [262,144/262,144 pixels after isolating the generator](parity-fixes.md#alveolus-filters-after-the-first-differing-stage) · [Two-stamp reconstruction at eight sizes](parity-fixes.md#four-source-pixels-in-the-filled-alveolus-cells) | +| [pattern_alveolus.sbs/alveolus](../assets/sbs/pattern_alveolus.sbs) | 0 | No | [Parity · 884,992/884,992 pixels across 58 renders](parity-fixes.md#pixel-coordinates-for-whole-pixel-pattern-stamps) · [Single-stamp render-region comparisons](parity-fixes.md#pattern-coordinates-under-a-change-of-render-region) · [Gaussian disc-boundary sweeps](parity-fixes.md#gaussian-coverage-at-the-disc-boundary) · [262,144/262,144 pixels after isolating the generator](parity-fixes.md#alveolus-filters-after-the-first-differing-stage) · [Two-stamp reconstruction at eight sizes](parity-fixes.md#four-source-pixels-in-the-filled-alveolus-cells) | | [pattern_arc_pavement.sbs/arc_pavement](../assets/sbs/pattern_arc_pavement.sbs) | 1 | No | [In progress · 206,911/211,200 pixels across 27 renders](parity-fixes.md#pattern-rotation-phase) · [Stamp-width recheck](parity-fixes.md#pixel-reciprocals-for-stamp-edge-widths) | | [pattern_brick_1.sbs/brick_1](../assets/sbs/pattern_brick_1.sbs) | 0 | No | [In progress · 310,861/365,824 pixels across 53 renders](parity-fixes.md#pixel-reciprocals-for-stamp-edge-widths) · [Earlier settings](parity-fixes.md#paper-brick-fiber-mesh-polygon-and-shape-roots) | | [pattern_brick_2.sbs/brick_2](../assets/sbs/pattern_brick_2.sbs) | 0 | No | [In progress · 310,928/365,824 pixels across 53 renders](parity-fixes.md#pixel-reciprocals-for-stamp-edge-widths) · [Earlier settings](parity-fixes.md#paper-brick-fiber-mesh-polygon-and-shape-roots) |