[Materials] Implement correct glTF alpha blending, transmission, volume, and refraction

[proggeramlug]

Parent: #126

Problem

Bloom's glTF import currently cannot represent standard physically based translucent content faithfully. In particular, alphaMode: BLEND is treated as cutout/mask behavior and transmission is approximated as a mirror-like material. This breaks glass, decals, foliage edges, smoke-like surfaces, and canonical glTF assets before lighting quality is even evaluated.

Outcome

Spec-correct glTF alpha modes plus a production translucent/refractive path:

• OPAQUE, MASK, and BLEND preserve their distinct semantics;
• KHR_materials_transmission, KHR_materials_volume, and IOR produce thickness-aware refraction and Beer-Lambert absorption;
• transparent ordering/composition has a documented high-quality path and constrained fallback;
• asset import never silently changes a blend material into a cutout or chrome substitute.

Import contract

Update native/shared/src/models_gltf.rs and cooked material metadata to preserve:

• alpha mode, cutoff, base-color alpha, double-sided flag, and texture transforms;
• transmission factor/texture, thickness factor/texture, attenuation distance/color, and IOR;
• whether thickness is authored, approximated, or unavailable;
• unsupported extension diagnostics with asset/material names.

Round-trip these values through scene/world serialization where applicable.

Render architecture

Buckets

• Opaque: existing deferred/visibility path.
• Masked: opaque depth/shadow semantics with coverage preservation through mip levels; alpha-to-coverage where MSAA supports it.
• Transparent: forward shading after opaque lighting with depth test/no opaque-depth write.
• Refractive: forward pass with explicit scene-color/depth input supplied by the render graph.

Composition

Implement one production baseline:

• depth-sort conventional alpha for small/simple sets; and
• weighted blended OIT (or a better documented bounded alternative) for intersecting/high-count surfaces.

Expose the selected mode/capability. Sorting keys must be deterministic and account for material bucket, depth, and stable object ID.

Refraction/transmission

• Reconstruct entry/exit distance from authored thickness, backface/depth information, or a clearly labeled approximation.
• Apply Snell refraction using material IOR and Beer-Lambert absorption using attenuation color/distance.
• Sample the correct pre-translucency scene-color snapshot; prevent read/write feedback.
• Use SSR/planar/ray-query/env fallback hierarchy for reflection without treating missing reflection data as full mirror energy.
• Conserve energy between reflection, transmission, absorption, and diffuse lobes.

GI, shadows, temporal

• Transparent objects receive direct/IBL lighting.
• Masked objects participate in shadows, velocity, depth, and GI surface representation.
• Transparent motion/reactive data is provided to temporal reconstruction where possible; otherwise mark reactive regions to prevent history smearing.
• Define whether/how refractive objects cast shadows; unsupported colored transmission is explicit.

Acceptance criteria

• Khronos-style alpha/transmission/volume validation assets render with correct bucket selection and no import warnings for supported fields.
• BLEND produces fractional coverage, never binary cutoff.
• Two intersecting transparent surfaces remain stable during camera motion under the selected OIT path.
• Glass shows view-dependent Fresnel reflection, background refraction, thickness-dependent absorption, and plausible total energy versus tools/bloom-reference/Cycles.
• Masked foliage preserves silhouette coverage across mip/LOD changes and appears correctly in shadows and motion vectors.
• Refractive scene-color access is declared in the render graph; no same-resource read/write validation errors or backend-specific black frames.
• Web/mobile fallback behavior is visually correct within its documented limits and never silently changes material type.
• Import, serialization, and golden tests cover all alpha modes plus missing/invalid extension data.

Likely files

• native/shared/src/models_gltf.rs, models.rs
• native/shared/src/renderer/material_pipeline.rs, material_system.rs, scene_pass.rs, graph.rs
• native/shared/shaders/material_abi.wgsl and shared shader modules
• src/models/, world material serialization, quality/capability APIs

Verification

Attach stills and motion captures against approved glTF reference renders, plus GPU timings and overdraw statistics for sorted and OIT modes.

Non-goals

• Strand hair rendering.
• Spectral dispersion.
• Order-independent refraction of arbitrarily deep nested dielectrics.

Dependencies

• [Renderer] Compile the render graph with lifetime planning, aliasing, and topology caching #129 for safe scene-color snapshots.
• Can implement import fidelity and masked/BLEND separation before the graph upgrade lands.

[proggeramlug]

Implemented the first production milestone for this issue: spec-distinct glTF alpha modes plus a sorted forward BLEND path. This is partial progress; the issue remains open for OIT and physical transmission/volume/refraction.

Import and data contract now implemented

• Added an explicit MaterialAlphaMode::{Opaque, Mask, Blend} to imported mesh and retained-scene material data.
• Both glTF loader paths now preserve alphaMode, MASK-only alphaCutoff, base-color alpha, and doubleSided instead of translating BLEND to MASK at 0.5.
• Procedural meshes default explicitly to OPAQUE.
• Model-to-scene attachment transfers alpha mode, cutoff, and double-sided state without losing semantics.
• Cached drawModel uploads retain the same metadata, so attached scene nodes and the common cached-model path agree.
• The shader ABI uses a private alpha tag: 0 = OPAQUE, positive = MASK cutoff, negative = BLEND. OPAQUE ignores unused texture alpha, MASK alone discards, and BLEND retains fractional sampled alpha.

Render path now implemented

• BLEND primitives are excluded from the depth prepass, opaque main submission, GPU-driven indirect submission, directional shadow caster submission, and planar-reflection opaque submission.
• They render after opaque lighting into the HDR target with standard alpha compositing, opaque depth testing, and no depth write.
• Both retained-scene nodes and cached models use this path, including skinned cached draws.
• Ordering is deterministic back-to-front using the actual world-AABB center plus stable submission/node ID, rather than a potentially unrelated model origin.
• Cached transparent draws are camera-frustum culled.
• glTF doubleSided BLEND primitives use a no-cull pipeline and flip the back-face shading normal.
• A BLEND node no longer disables GPU-driven submission for a large opaque retained-scene subset.
• Opaque-only frames have an O(1) translucent-pass gate. Presence is maintained during scene preparation/model caching and submission; the renderer does not rescan all nodes/draws just to discover that the pass is empty.

Explicit temporary policy

Until the later physical-transmission milestones land, conventional BLEND surfaces:

• receive the existing direct and IBL lighting;
• depth-test against opaque geometry but do not write opaque depth;
• do not cast directional shadows or enter the opaque planar-reflection list;
• are not silently converted back into cutouts or chrome.

This avoids contaminating opaque depth/shadow paths with binary coverage, but colored/partial transparent shadows and temporal reactive data are still remaining work.

Regression coverage and qualification

• Import tests parse a minimal glTF containing OPAQUE, MASK, and BLEND materials and verify all three remain distinct.
• Shader-tag test verifies MASK cutoff is preserved and BLEND cannot become a positive binary cutoff.
• Real-GPU integration test verifies 50% BLEND lands strictly between background and opaque endpoints through both retained-scene and cached-model routes.
• Full shared library suite: 190 passed, 0 failed, 1 ignored.
• golden_lit_primitives_3d: passed unchanged.
• 10,240-draw / 192-point-light opaque stress capture:
  • no translucent_pass was recorded;
  • two independent runs produced byte-identical final color, HDR scene, depth, and all three shadow cascades;
  • quality reproducibility gate passed;
  • CPU mean was 15.11 ms and 14.43 ms (previous comparable capture: 15.83 ms); render_total was 7.08 ms and 6.73 ms (previous: 7.48 ms);
  • the quality run reports failure only because tools/quality/baselines/portable/draw-light-stress.png has not been human-approved/installed.

Remaining independent work packages

1. One global transparent ordering contract: imported cached draws, retained nodes, and custom material commands currently sort deterministically within their own lists, but are not globally interleaved. Introduce a common transparent draw descriptor/key (bucket, view depth, stable object ID) and a single dispatcher.
2. Intersecting/high-count baseline: add weighted blended OIT (or another bounded documented method), capability/selected-mode telemetry, two-intersecting-surface motion tests, and overdraw/GPU budgets. Keep conventional sorted alpha for small/simple sets where it is more accurate.
3. Transmission metadata: replace the current KHR_materials_transmission -> metallic=1, roughness=0 chrome fallback only after preserving factor/texture, IOR, volume thickness/texture, attenuation color/distance, authored/approximated thickness provenance, material names, and unsupported-extension diagnostics through cooked/serialized data.
4. Physical refractive shading: use the existing render-graph-managed pre-translucency color/depth snapshot; implement Fresnel/Snell refraction, thickness reconstruction or labeled approximation, Beer-Lambert absorption, reflection fallback hierarchy, and energy conservation.
5. GI/shadow/temporal policy: transparent/refractive shadow mode (including explicit lack of colored transmission on constrained tiers), reactive/velocity output for TAA/TSR, and a deliberate transparent GI representation.
6. Masked quality: coverage-preserving mip generation/LOD behavior and alpha-to-coverage on supported MSAA configurations.
7. Validation assets: Khronos alpha/transmission/volume fixtures, missing/invalid extension cases, approved still/motion references versus bloom-reference/Cycles, and web/mobile fallback captures.

No golden images or portable baselines were changed by this milestone.

[proggeramlug]

Completed the next image-neutral milestone: lossless import and CPU-path retention for KHR_materials_transmission, KHR_materials_volume, IOR, physical texture bindings, and thickness provenance.

The existing chrome fallback is intentionally still active. This change establishes authoritative source data first so the later refractive shader can replace the fallback atomically rather than guessing missing fields or changing current images halfway through.

Data contract added

MeshData, retained PbrMaterial, and cached GPU-mesh CPU metadata now retain:

• whether transmission, volume, and IOR were explicitly authored;
• transmission factor;
• IOR (spec default 1.5 when absent);
• thickness factor;
• attenuation distance/color (spec defaults: infinity/white);
• thickness provenance: unavailable, authored, or approximated (the importer emits unavailable/authored; approximated is reserved for a documented renderer fallback);
• transmission and thickness texture bindings;
• each binding's original glTF texture index, source image index, resolved runtime texture ID when one exists, UV set, offset, rotation, scale, and KHR_texture_transform UV override.

The source/runtime split matters: CPU-only loading preserves the original binding without fabricating a GPU handle; staged and direct GPU loaders resolve the same source metadata to their appropriate runtime IDs.

Loader and handoff coverage

• Enabled the upstream glTF features for IOR, volume, texture transforms, and unknown-extension inspection.
• Direct textured loading, staged loading/commit, and plain CPU-only GLB loading all populate the same physical material contract.
• Staged commit remaps transmission/thickness runtime texture IDs alongside base-color/normal/MR/emissive/occlusion textures.
• bloom_scene_attach_model copies the physical contract into the retained material.
• Cached-model upload retains it for the future refractive bucket.
• The metadata-only retained setter deliberately does not dirty/rebuild the current GPU material, so this milestone cannot alter the established fallback output or add per-frame work.
• The path-aware FFI loader now supplies the exact source path to diagnostics.

Validation and diagnostics

• Invalid transmission factor, IOR, thickness, attenuation distance, or attenuation color is rejected at Bloom's import boundary with the asset/material identity and failing field. The upstream parser validates structure but did not enforce all extension numeric ranges, so relying on it alone could admit invalid shader inputs.
• Unknown material extensions produce a named asset + material warning instead of disappearing silently.
• Missing physical extensions retain Khronos defaults and never invent thickness.
• A literal generated GLB test proves BLEND + transmission + IOR + volume survive through both plain and staged loaders into MeshData.
• Texture tests prove source indices, runtime resolution, UV set override, and transform values survive exactly.
• Retained-scene test proves the contract round-trips without dirtying the legacy shader.

Qualification

• Full shared library suite: 196 passed, 0 failed, 1 ignored.
• cargo check --no-default-features: passed (the lightweight/no-model configuration remains intact).
• Real-GPU retained + cached fractional-BLEND integration: passed.
• golden_lit_primitives_3d: passed unchanged.
• Sponza versus the pre-metadata capture: SSIM 1.00000, luminance RMSE 0.00007, no translucent pass.
• Two post-change Sponza captures passed the full reproducibility gate for final color, HDR, depth, all cascades, CPU timing, and GPU timing. CPU mean differed by 0.27%; GPU p95 by 1.44%.
• The quality runner still reports only the known missing human-approved portable Sponza baseline; no baseline/golden was changed.

Boundary for the next milestone

apply_transmission_hack still maps strong transmission to the established mirror-like PBR fallback. Do not remove it until the refractive bucket consumes the preserved contract and passes reference/energy/image/performance gates. The next implementation should route authored transmission into the render-graph-managed scene-color/depth snapshot, then land Fresnel/Snell + thickness + Beer-Lambert as one reversible path with the old fallback available as a comparison/kill switch.

[proggeramlug]

Implemented the next production milestone: a dedicated physical imported-refraction path backed by the render graph, with retained and cached model parity.

This replaces the chrome substitution by default, but keeps that exact legacy behavior behind a startup kill switch. This is substantial partial progress; the issue remains open for global OIT, masked coverage work, colored/transmitted shadows, reactive masks, and approved reference-motion qualification.

Material and routing contract

• MaterialTransmission::is_active() is the single classification predicate for authored physical transmission.
• The physical path is enabled by default. BLOOM_GLTF_REFRACTION=0, false, or off restores the previous chrome fallback at startup for comparison and emergency rollback.
• Active refractive primitives are excluded from the opaque depth prepass, opaque main pass, GPU-driven opaque submission, directional-shadow caster list, and opaque planar-probe list.
• They render in a dedicated forward pass after opaque lighting with opaque-depth testing and no opaque-depth write.
• Retained scene nodes and cached drawModel meshes feed one common refractive draw descriptor and one deterministic global back-to-front ordering key: view depth followed by stable object/submission ID.
• A physical material that is also alphaMode: BLEND is drawn once and premixes coverage correctly; it cannot also enter the conventional BLEND pass.
• Opaque-only applications keep an O(1) feature gate, do not compile the refractive shader, do not allocate refraction snapshots, and do not create physical material bindings.

Physical shading implemented

The dedicated shader variant now consumes:

• transmission factor/texture;
• authored thickness factor/texture and model-scale-aware thickness;
• IOR;
• attenuation color and distance;
• UV0 KHR_texture_transform metadata;
• immutable pre-translucency scene color and opaque depth on native backends.

It applies Snell refraction, IOR-derived Schlick Fresnel, Beer-Lambert absorption, depth-guarded screen-space distortion, a deterministic five-tap rough-transmission filter when roughness warrants it, environment reflection fallback, and an explicit energy partition between opaque surface response, reflection, transmission, and absorption. The distortion radius is bounded to 64 pixels, and final output is scrubbed for non-finite values.

The ordinary scene shader and its uniform ABI are unchanged. Physical fields live in a separate 96-byte refractive uniform, and only the lazy dedicated variant receives the added bindings/interpolant. This avoids silently increasing every ordinary material/draw cost.

Render-graph and temporal behavior

• Native imported refraction declares and receives graph-managed pre-translucency color and depth snapshots, avoiding same-resource read/write feedback.
• The refractive pass loads HDR and opaque depth, and writes the existing motion-vector attachment with per-object velocity.
• Folded Web/Android shader tiers retain the same material bucket and physical metadata but use the documented environment-transmission fallback instead of pretending the material is chrome.
• The topology advertises imported refraction separately from arbitrary custom scene readers, including on folded tiers where no snapshots are allocated.
• Public capability/selected-mode telemetry is available through getImportedRefractionMode() / bloom_get_imported_refraction_mode():
  • 0: disabled, legacy fallback;
  • 1: native scene-color/depth snapshot;
  • 2: constrained environment fallback.
• docs/imported-refraction.md documents the path, formulas, backend behavior, kill switch, temporal/shadow policy, and current limitations.

Explicit current constraints

• Transmission/thickness textures using TEXCOORD_1+ retain their source metadata but currently fall back to the scalar factor with a named warning instead of sampling the wrong UV.
• Refractive objects currently do not cast the opaque fake shadow. Colored/transmitted shadows remain an explicit follow-up.
• Velocity is emitted, but a dedicated temporal reactive mask is still outstanding.
• The current reflection contribution uses the environment fallback. Planar/SSR/ray-query selection and direct-light dielectric-specular refinement remain follow-up quality work.
• Arbitrarily nested/order-independent refraction is still a stated non-goal.

Regression and validation evidence

• Full shared library suite: 198 passed, 0 failed, 1 ignored.
• Dedicated WGSL tests parse both native and folded refractive variants and prove the ordinary shader does not acquire refractive bindings.
• Real-GPU physical transmission integration:
  • compiles the lazy physical pipeline;
  • verifies Beer-Lambert red absorption;
  • verifies native scene-color/depth snapshot graph nodes;
  • verifies cached and retained routes match within 3 channel values;
  • passes both normally and with BLOOM_VSM=1.
• Existing fractional-BLEND GPU integration: passed unchanged.
• Existing golden_lit_primitives_3d: passed unchanged.
• Native, no-default-feature, Web/model, and Android/model compile checks passed. The unrelated full-default wasm audio build remains blocked in minimp3-sys by its missing wasm libc header; the no-default + models3d wasm build covering this path passes.
• FFI manifest/parity validation: 0 failures, 0 warnings across native platforms and Web.
• git diff --check: passed.

Opaque Sponza qualification:

• graph plan ID: 7ead8d0477965a86;
• 24 passes;
• zero physical transient slots/bytes;
• no translucent or refractive pass on the opaque scene;
• compared with the preceding metadata-only build: SSIM 1.00000, luminance RMSE 0.00011, OKLab mean delta 0.00000, edge mean delta 0.00000, 0.06% of pixels above 0.002;
• two same-build captures passed the full reproducibility contract;
• CPU mean/p95: 5.978/11.076 ms and 5.159/9.419 ms;
• GPU mean/p95: 23.303/39.066 ms and 24.894/40.333 ms.

The quality runner's only reported failure is still the missing human-approved portable Sponza baseline. No golden or portable baseline was changed.

Remaining acceptance work

1. Add and qualify the bounded high-count/intersection path (weighted blended OIT or a documented better alternative), including two-intersecting-surface camera-motion and overdraw budgets.
2. Finish masked-material quality: coverage-preserving mip/LOD behavior and alpha-to-coverage where MSAA supports it.
3. Add transparent/refractive reactive coverage, colored/transmitted shadow policy, and deliberate transparent GI representation.
4. Extend the reflection hierarchy beyond environment fallback and qualify dielectric direct/reflected energy against tools/bloom-reference/Cycles.
5. Add Khronos transmission/volume validation assets plus approved still and motion references on native and folded tiers.
6. Add UV1 physical-texture sampling after the mesh/shader UV ABI can represent it without widening the ordinary path.

Evidence bundles:

• tools/quality/out/issue-133-refraction-sponza/result.json
• tools/quality/out/issue-133-refraction-sponza-rerun/result.json
• tools/quality/out/issue-133-refraction-vs-metadata/

[proggeramlug]

Implemented the next production milestone: hybrid sorted transparency plus lazy weighted-blended OIT for intersecting/high-count imported glTF BLEND surfaces.

This completes the bounded conventional-transparency composition baseline requested by this issue. The issue remains open for masked coverage quality, temporal reactive coverage, colored/transmitted shadows, transparent GI policy, expanded reflection sources, and approved native/folded-tier reference assets.

Composition contract

• Added three explicit modes:
  • sorted: retain deterministic back-to-front alpha blending;
  • auto (default): use sorted alpha below 64 visible imported BLEND draws, weighted OIT at/above 64;
  • weighted: force weighted OIT whenever at least one contributing imported BLEND draw is visible.
• Auto selection counts the visible retained + cached imported set and frustum-culls cached draws before making the decision. A large offscreen set therefore cannot allocate or activate OIT.
• Startup override: BLOOM_TRANSPARENCY=sorted|auto|weighted.
• Runtime/native/Web APIs:
  • setTransparencyCompositionMode("sorted" | "auto" | "weighted");
  • getTransparencyCompositionMode();
  • getActiveTransparencyCompositionMode() ("sorted" or "weighted").
• Retained scene nodes and cached drawModel meshes now feed one common imported-transparent descriptor, visible-set builder, material/uniform binding contract, depth key, and stable object/submission ID.
• The sorted route globally orders retained and cached imported BLEND draws. Existing user custom-material translucent commands retain their established sorted/additive pass after the imported OIT resolve; they are not yet globally interleaved with imported draws.
• Physical transmission remains in the dedicated refractive bucket and is excluded from conventional BLEND/OIT, preventing double submission.

Weighted path

The production bounded approximation uses two graph-owned render-resolution targets:

• transparency-accumulation: RGBA16Float, additive;
• transparency-revealage: R16Float, multiplicative revealage.

For normalized opaque depth z, the bounded weight is:

w = 0.1 + 0.9 * (1 - z)^3

Fragments accumulate color * alpha * w and alpha * w; revealage multiplies by 1 - alpha. Resolve reconstructs the weighted color and coverage, scrubs non-finite values, and alpha-composites into HDR. The bounded weight avoids high-layer-count RGBA16Float overflow.

The feature is fully lazy:

• no weighted shader compilation, pipelines, bind group, render-graph resources, or pass when inactive;
• the two physical targets exist only in weighted plans and are owned by the translucent graph node;
• the resolve bind group is cached by compiled plan ID + transient-pool rebuild epoch;
• targets consume exactly 10 bytes per render pixel while active (5,184,000 bytes at 960x540);
• ordinary scene WGSL and ordinary material ABI remain unchanged.

docs/transparency-composition.md records the formulas, routing rules, memory cost, controls, backend contract, and current limitations.

Regression coverage

• Pure selection test proves the 63/64 auto boundary, forced sorted kill switch, and no empty forced-weighted activation.
• Render-graph test proves disabled plans allocate no OIT resources and active plans allocate exactly the two declared targets.
• WGSL tests parse both dedicated variants and prove the ordinary scene shader does not acquire the weighted entry point.
• Existing real-GPU fractional BLEND test passes and proves a simple auto-mode scene remains on sorted alpha with no OIT graph resources.
• Existing physical retained + cached refraction test passes after the compositor refactor.
• New real-GPU intersection test combines retained green plus cached red/blue imported BLEND geometry:
  • sorted AB/BA is deliberately order-sensitive as a negative control;
  • weighted AB/BA mean channel difference is at most 0.02/255, maximum at most 2/255;
  • both graph targets are present;
  • a separate draw proves a user custom translucent material still renders after the imported resolve;
  • passes with both CSM and BLOOM_VSM=1.
• Shared library suite: 201 passed, 0 failed, 1 ignored (202 total).
• Native models3d, no-default-feature, wasm no-default + models3d, Android aarch64-linux-android, and Web wasm checks pass.
• FFI manifest/parity validation: 0 failures, 0 warnings across native platforms and Web.
• cargo fmt --check and git diff --check pass.

The repository-wide line-count script still reports the five already-over-limit cumulative files (physics_jolt.rs, material_system.rs, renderer/mod.rs, scene.rs, and Web lib.rs). This milestone moved its policy/pipeline implementation into a new 339-line weighted_transparency.rs and reduced renderer/mod.rs by 334 lines; it does not attempt an unrelated whole-repository split.

Visual and performance qualification

Added a deterministic quality-transparency corpus scene with 96 animated imported BLEND layers arranged as 12 intersecting cells, TAA enabled, fixed 1/60 s simulation, and forced weighted composition. No portable baseline was created or changed.

Two unchanged-source Apple M1 Max captures:

• capture A CPU mean/p95: 3.195 / 4.940 ms;
• capture B CPU mean/p95: 3.421 / 5.015 ms;
• capture A GPU mean/p95: 19.476 / 24.834 ms;
• capture B GPU mean/p95: 19.440 / 24.813 ms;
• weighted accumulation + resolve GPU mean: 2.901 / 2.962 ms;
• corpus budgets: CPU p95 12 ms, GPU p95 30 ms.

The strict reproducibility check passes:

• stable metadata identical;
• final color, HDR scene, depth, and all three shadow cascades are byte-identical;
• CPU mean/p95 and GPU mean/p95 all pass the original noise bounds without loosening them.

The quality runner marks each report-only capture failed solely because tools/quality/baselines/portable/weighted-transparency.png has not been human-approved.

Opaque Sponza remains on the exact non-OIT topology:

• no weighted pass;
• zero weighted transient slots/bytes;
• same 24-pass plan;
• prior-refraction-build versus OIT-source comparison: SSIM 1.00000, luminance RMSE 0.00006, RGB RMSE at most 0.00008, OKLab/edge mean delta 0.00000.

Remaining acceptance work

1. Finish masked-material quality: coverage-preserving mip/LOD behavior and alpha-to-coverage where MSAA supports it.
2. Add transparent/refractive reactive coverage for TAA/TSR and qualify camera-motion history stability.
3. Define and implement colored/transmitted shadow behavior plus a deliberate transparent GI representation.
4. Extend dielectric reflection selection beyond the environment fallback (planar/SSR/ray query) and qualify energy against tools/bloom-reference/Cycles.
5. Add Khronos transmission/volume fixtures and approved still/motion references on native and folded Web/Android tiers.
6. Add UV1 physical-texture sampling when the mesh/shader UV ABI can represent it without widening the ordinary path.
7. Consider global interleaving between imported descriptors and arbitrary custom translucent material commands; the current documented boundary preserves the established custom pass after imported resolve.

Evidence:

• tools/quality/out/issue-133-weighted-transparency-final-2/result.json
• tools/quality/out/issue-133-weighted-transparency-final-3/result.json
• tools/quality/out/issue-133-weighted-transparency-final-strict/result.json
• tools/quality/out/issue-133-oit-vs-refraction/

[proggeramlug]

Completed the next production milestone: coverage-preserving imported glTF MASK silhouettes across minification, depth, velocity, and directional shadows.

This completes the masked-material quality package requested by this issue for the currently supported single-sample targets. The issue remains open for transparent/refractive reactive coverage, transmitted-shadow/GI policy, expanded reflection sources, reference assets, and UV1 physical-texture sampling.

Import and mip contract

• For every textured MASK material, the importer derives the texture-space reference as alphaCutoff / baseColorFactor.a.
• Variants are keyed by unique (source image, effective cutoff), so two MASK materials sharing an image but using different factors or cutoffs cannot corrupt one another.
• OPAQUE, BLEND, normal-map, and ordinary standalone texture chains retain their established path and bytes.
• Level zero of a coverage variant is byte-identical to the decoded source.
• Lower-level alpha stores the exact fraction of the source footprint that survives the effective cutoff.
• Non-power-of-two reduction is area-correct: odd rows and columns contribute instead of being duplicated or discarded.
• Lower-level RGB is the coverage-weighted mean in linear light.
• Empty reduced texels receive the nearest covered color, preventing bilinear sampling from pulling transparent border colors into foliage and fence edges.
• References above one intentionally produce zero lower-mip coverage, matching materials whose factor alpha can never reach the authored cutoff.
• glTF COLOR_0 now correctly multiplies baseColorFactor; it no longer replaces the factor. This keeps level-zero alpha and the coverage reference consistent with the glTF contract.
• Direct, staged, retained-scene, cached-model, and GPU-driven material routes carry the coverage semantic.
• MASK-only images do not duplicate an unreachable ordinary chain. Their first coverage chain occupies the existing texture slot. An ordinary chain is retained only when OPAQUE, BLEND, normal, emissive, occlusion, metallic-roughness, transmission, or thickness usage shares the image.

Raster contract

• Magnification and level zero keep the exact authored hard alpha test.
• At LOD 1 and below, lower-mip alpha is interpreted as coverage probability.
• The 0.5-to-1.0 LOD interval blends level-zero hard coverage with level-one coverage explicitly, avoiding both a discrete pop and trilinear mixing of incompatible alpha meanings.
• Scene color, depth prepass, velocity, compatibility submission, GPU-driven indirection, and shadow cutouts use the same material flag and LOD rule.
• Shadow cutouts now include vertex alpha, so caster and visible silhouettes agree.
• The prepassed main shader still strips its redundant discard block, preserving the existing early-Z optimization.
• Ordinary materials do not execute the coverage branch.

Bloom currently renders these targets at sample count 1. Hardware alpha-to-coverage is therefore unavailable and is not reported as supported. The production fallback is a deterministic 4x4 Bayer coverage test, stabilized by the existing TAA/velocity path. Android retains the established exact one-mip hard-cutout path until multi-level Vulkan uploads are qualified on real devices; it does not claim coverage-mip support.

Telemetry now reports:

• registered coverage-mip variants;
• target coverage-mip support;
• actual sample count;
• alpha-to-coverage support;
• active single-sample fallback.

BLOOM_MASK_COVERAGE=0|off|false|disabled is an import-time same-binary diagnostic control. It restores the established ordinary mip path and adds no normal-frame check.

Regression and shader coverage

• Mip tests cover byte-exact ordinary reduction, authored 75% survival, odd NPOT borders, linear-light RGB, transparent-edge color dilation, and empty coverage.
• Import tests cover per-cutoff variants, OPAQUE/BLEND isolation, zero cutoff, factor-adjusted cutoff, MASK-only storage aliasing, shared-image ordinary-chain retention, direct/staged routing, diagnostic parsing, and COLOR_0 * baseColorFactor.
• WGSL validation covers compatibility, GPU-driven indirection, shadow cutouts, refraction variants, and weighted-transparency variants.
• Real-GPU masked test proves the coverage chain retains the authored subpixel silhouette instead of filling the card. It passes with both CSM and BLOOM_VSM=1.
• Full shared library suite: 211 passed, 0 failed, 1 ignored.
• Full golden/real-GPU suite: 14 passed, 0 failed, 2 hardware-oracle tests ignored.
• Quality-runner unit suite: 8 passed, 0 failed.
• FFI parity: 0 failures, 0 warnings, covering 485 manifest functions.
• Host no-default, wasm no-default + models3d/web, and Android aarch64 models3d checks pass. Existing unrelated platform warnings remain; this milestone adds no Android warning.
• cargo fmt --check and git diff --check pass.

The repository line ratchet still reports only the same five cumulative files already over their limits (physics_jolt.rs, material_system.rs, renderer/mod.rs, scene.rs, and Web lib.rs). models_gltf.rs remains below the 2,000-line limit after moving its tests to models_gltf_tests.rs.

Visual and performance qualification

Added a deterministic masked-alpha-coverage corpus case with 48 moving imported MASK cards, six separated projected mip bands, TAA, CSM, fixed 1/60 s simulation, and final/HDR/depth/all-cascade capture. No portable baseline or golden image was created or changed.

Two unchanged-source corpus captures:

• all six artifacts are byte-identical;
• capture A CPU mean/p95: 2.955 / 3.177 ms;
• capture B CPU mean/p95: 4.382 / 10.761 ms;
• capture A GPU mean/p95: 13.528 / 16.784 ms;
• capture B GPU mean/p95: 12.753 / 16.398 ms;
• corpus budgets: CPU p95 12 ms, GPU p95 30 ms;
• one coverage variant is resident and the scene still has exactly one texture.

The strict reproducibility check passes stable metadata, every pixel artifact, GPU mean, and GPU p95. Its CPU relative-noise check fails because unrelated Perry release builds have continuously occupied cores during qualification; both captures still pass the unchanged absolute CPU budget. Bounds were not loosened.

A counterbalanced same-binary Sponza A/B ran two coverage-on and two diagnostic-off captures after identical 180-frame warmups and 300-frame measured windows:

• coverage on GPU mean/p95 average: 45.138 / 50.931 ms;
• coverage off GPU mean/p95 average: 45.380 / 51.600 ms;
• coverage on CPU mean/p95 average: 3.497 / 7.175 ms;
• coverage off CPU mean/p95 average: 4.076 / 10.564 ms;
• resident textures: 69 on, 69 off;
• registered coverage variants: 3 on, 0 off.

The same-setting pairs reproduce at SSIM above 0.999997. The on/off change is repeatable (SSIM 0.98902, luminance RMSE 0.01131) and its heatmap is confined to the two foliage groups. Earlier milestone-to-milestone depth and color comparisons likewise localize to those MASK surfaces; shadow-cascade SSIM is at least 0.9999986.

The quality runner marks report-only captures failed only because the new portable baseline has not received independent human review.

Remaining acceptance work

1. Add transparent/refractive reactive coverage for temporal reconstruction.
2. Define and implement colored/transmitted shadow behavior and a deliberate transparent GI representation.
3. Extend dielectric reflection selection beyond the environment fallback and qualify energy against bloom-reference/Cycles.
4. Add Khronos alpha/transmission/volume fixtures and approved native plus folded-tier still/motion references.
5. Add UV1 physical-texture sampling without widening the ordinary material path.
6. Consider global interleaving between imported transparency and arbitrary custom translucent commands.

Evidence:

• tools/quality/out/issue-133-masked-alpha-final-a/result.json
• tools/quality/out/issue-133-masked-alpha-final-b/result.json
• tools/quality/out/issue-133-mask-ab/
• tools/quality/out/issue-133-masked-alpha-sponza-diff/

[proggeramlug]

Milestone: temporal reactive coverage for imported BLEND + transmission

Implemented the temporal/reactive subpackage of #133 without widening the established opaque or custom-material paths.

What landed

• Added a compiled-graph transient named transparency-reactive (r8unorm, render resolution, color-attachment + sampled).
• Imported writers union coverage with src + dst * (1 - src):
  • sorted glTF BLEND: shaded base alpha;
  • weighted OIT: resolved opacity (1 - revealage);
  • opaque physical transmission: transmission weight;
  • BLEND + transmission: base alpha, matching the final snapshot composite.
• Added a lazy TAA variant that samples coverage at the same unjittered UV as current color and uses max(motion, disocclusion, reactive) as current-frame weight.
• Added visible-draw selection for cached and retained imported content. TAA-off, feature-off, and visible-BLEND cases short-circuit before an unnecessary refraction scan.
• Split mixed imported/custom sorted translucency only while reactive coverage is active; custom material pipelines and ABI remain unchanged.
• Added BLOOM_TEMPORAL_REACTIVE=0 as an exact A/B kill switch.
• Added runtime evidence under renderer_paths.temporal_reactive and documentation in docs/temporal-reactive-coverage.md.
• Extended the transparency fixture with opt-in --sorted and --refractive validation routes; its default weighted corpus is unchanged.

No-regression/laziness guarantees

The existing TAA, sorted-alpha, weighted-OIT, and refraction pipelines remain selected unchanged when reactive coverage is inactive. Opaque frames:

• allocate no reactive texture;
• compile no reactive shader/pipeline;
• keep the existing nine-binding TAA ABI;
• execute no additional texture sample;
• retain the prior stack-built TAA layout descriptor (no new startup heap allocation).

TAA-disabled imported transparency also restores the previous graph topology and skips reactive visibility work. Custom-only translucency remains on its previous single-target pass.

Validation

• Shared library: 215 passed, 1 ignored.
• GPU/golden suite: 14 passed, 2 ignored.
  • Includes explicit TAA-on/TAA-off graph assertions for sorted BLEND and physical transmission.
  • Includes TAA-active weighted OIT plus a custom translucent material, exercising the split pass and both attachment layouts.
• All four generated WGSL variants parse through naga: TAA, sorted BLEND, weighted resolve, native/folded refraction.
• Live Metal validation succeeded for all three imported writer routes (weighted, --sorted, --refractive) with no wgpu validation errors or black frames.
• Full 96-layer animated weighted corpus:
  • CPU mean/p95: 4.760 / 10.368 ms;
  • GPU mean/p95: 21.482 / 27.434 ms;
  • both remain inside the case's 12 ms CPU / 30 ms GPU p95 budgets;
  • recorded failure is only the repository's already-known missing approved baseline.
• Same-binary reactive on/off capture:
  • luminance SSIM 0.99996;
  • luminance RMSE 0.00063;
  • OKLab mean delta 0.00009;
  • differences are localized to transparent coverage/edges.
• Allocation proof at 1920x1080 weighted OIT:
  • off: 2 slots / 20,736,000 bytes;
  • on: 3 slots / 22,809,600 bytes;
  • exact delta: 2,073,600 bytes = one byte per render pixel.
• Cross-target compile gates pass:
  • host --no-default-features;
  • wasm32-unknown-unknown with models3d,web;
  • Android aarch64-linux-android with models3d and NDK clang.
• Quality runner unit tests: 8/8; FFI parity: 0 failures, 0 warnings across 485 manifest functions.
• cargo fmt --check and git diff --check pass. File-line audit reports only the five pre-existing cumulative over-limit files; the new module is 636 lines.

Remaining #133 packages

This does not close #133. Remaining work includes colored/transmitted shadows and transparent GI, reflection hierarchy beyond the environment fallback, Khronos/reference asset qualification, UV1 physical textures, and global interleaving of custom/imported translucent draws.

[proggeramlug]

Milestone: transmitted directional shadows + transparent GI

Completed the remaining shadow/GI package of #133 with bounded,
diagnosable representations. The issue remains open for the reflection-source
hierarchy, approved Khronos/reference captures, UV1 physical textures, and the
documented custom/imported interleaving boundary.

Colored/transmitted directional shadows

Physical-transmission materials no longer become opaque CSM blockers merely
to cast a shadow. The established 2048² opaque/MASK cascades remain unchanged
and authoritative. When an eligible retained, cached, or cached-skinned glass
caster is actually submitted, Bloom lazily adds one 1024² RGBA8 transmittance
map and one 1024² Depth16 nearest-layer map for each of three cascades.

The nearest layer evaluates:

• base color, vertex color, instance tint, and BLEND coverage;
• MASK cutoff;
• metallic suppression and transmission factor/texture;
• thickness factor/texture and model scale;
• attenuation color/distance; and
• IOR-derived Fresnel partitioning.

Opaque visibility is checked before writing, so glass behind a nearer opaque
blocker cannot tint that blocker's shadow. Each cascade is cached by
light-matrix, caster/material/transform signature, and opaque-depth generation.
A conservative per-cascade AABB test and 1,024-draw cap bound submission.

The optional graph resolve reconstructs receiver position and geometric normal,
samples the established opaque/cloud visibility, and applies only:

direct_sun * opaque_visibility * cloud_visibility * (transmittance - 1)

It therefore cannot multiply emissive, ambient, IBL, GI, or later
translucency. The pass runs after path tracing and before translucent
composition.

Before activation there is no allocation, pipeline creation, graph resource,
or pass. Active persistent storage is exactly 18,874,368 bytes (18 MiB);
transient storage remains zero. BLOOM_TRANSMITTED_SHADOWS=0 is the exact A/B
control. Telemetry under renderer_paths.transmitted_shadows reports
enable/active state, nearest-layer-rgb-depth, resolution, exact bytes, and
caster count.

Bounded transparent GI

SSGI now continues through one nearest physical-transmission instance instead
of treating glass as an opaque GI blocker.

On hardware ray query:

• opaque TLAS instances retain mask 0xff;
• contributing dielectric instances use bit 1 (0x02);
• the ordinary first-hit query remains 0xff and sees both;
• only when the nearest hit is glass does the lazy specialization issue one
  extra mask-0x01 query, skipping the complete glass instance and finding
  the nearest opaque surface behind it;
• hardware probe tracing and world-space radiance-cache baking share the rule.

On the software backend:

• contributing glass is omitted from the scene-wide opaque SDF;
• the established opaque SDF trace remains unchanged;
• one nearest conservative retained-instance world-AABB crossing is selected
  and composed over the opaque hit/miss result;
• clipmap mode/scene-version changes cancel stale staging jobs and publish only
  a current atomic bake.

Transport reuses previously unused lanes in the existing 144-byte
InstanceGiDataCpu record: RGB Beer-Lambert absorption, BLEND coverage,
dielectric transmission weight, and Fresnel pass fraction. It adds no texture,
buffer, bind group, graph resource, graph pass, transient slot, or GPU byte.
Scalar transmission is metallic-suppressed, IOR-aware, thickness/model-scale
aware, and preserves the uncovered part of BLEND. Fully metallic authored
transmission remains an opaque TLAS/SDF blocker.

The hardware, SDF, and hardware-WSRC pipelines are compiled only after an
eligible retained transmission instance appears. Opaque scenes keep the
compile-time-false ordinary shaders and now perform no environment lookup,
transmission scan, pipeline selection, or per-instance transport calculation.
Scene preparation supplies an O(1) gate. Route changes force one probe-history
refresh, invalidate WSRC cascades, and request a versioned SDF rebake.

BLOOM_TRANSPARENT_GI=0 is the opaque-GI A/B control. Telemetry under
renderer_paths.transparent_gi reports enable/active state,
one-layer-colored-continuation, zero additional persistent bytes, and live
retained instance count.

Two correctness fixes landed with this representation:

• the SDF WGSL instance struct now mirrors the CPU record's missing geo and
  mat_params tail; its previous 112-byte stride read every record after the
  first at the wrong offset;
• capacity-sized instance buffers zero stale tail records when the retained
  set shrinks, preventing removed card/glass metadata from being observed by
  arrayLength-based SDF loops.

Explicit bounds

• Both shadow and GI representations keep at most one nearest transmission
  layer; arbitrarily deep dielectric stacks remain outside this baseline.
• The software GI selector is conservative AABB-based rather than
  triangle-entry-accurate.
• GI transport currently uses scalar transmission/thickness/metallic factors
  and flat instance albedo; per-hit physical texture modulation stays in the
  camera/shadow shaders.
• GI follows the established retained-node/GI-proxy contract. Immediate cached
  model draws do not enter Mesh-Cards/TLAS/SDF.
• The transmitted-shadow resolve reconstructs geometric receiver normals and
  covers the primary directional light; local-light transmitted shadows remain
  separate work.

Detailed contracts are in docs/transmitted-shadows.md,
docs/transparent-gi.md, and docs/imported-refraction.md.

Visual and performance evidence

Transmitted shadows, 96 moving glass layers at 960×540:

• caster/resolve mean GPU time: approximately 0.95 / 0.69 ms;
• feature-on/off GPU p95: within measurement noise;
• on/off image: SSIM 0.9999938, luminance RMSE 0.0002146,
  max channel error 0.01961, zero pixels over the 0.02 tolerance;
• live property test verifies a non-trivial receiver region and authored
  cyan attenuation ordering.

Transparent GI, 96 moving retained panes, 120 warm-up + 240 measured frames:

• transmitted shadows disabled per node to isolate GI;
• specialized HW probe trace mean: 0.254 ms versus 0.195 ms opaque
  control, a 0.059 ms delta in the saturated route;
• feature-on total GPU p95: 90.88 ms versus 93.41 ms off (noise);
• feature-on CPU p95: 8.38 ms versus 9.19 ms off (noise);
• both routes: one cached 24-pass graph, three transient slots,
  26,956,800 transient bytes, zero GI-specific bytes;
• neutral stress final image: bit-identical; a separate GI-only glass/emitter
  property test produces a deterministic 19,407-pixel cyan/green-weighted
  indirect-light change while camera-facing geometry is unchanged.

Opaque pbr-spheres-high, 120 warm-up + 300 measured frames:

• transparent GI inactive with zero instances;
• one cached 24-pass graph, zero transient bytes/slots;
• CPU mean/p95 2.25 / 2.62 ms;
• GPU mean/p95 15.47 / 16.49 ms, within the existing 20 ms budget.

The quality report is marked failed only because the repository still has no
human-approved portable pbr-spheres-high baseline.

Validation

• shared library: 221 passed, 1 ignored;
• live/golden renderer suite: 17 passed, 2 hardware-oracle ignores;
• exact path-tracing goldens: zero differing pixels;
• all ordinary plus transparent HW/SDF/WSRC WGSL variants parse through naga;
• live Metal hardware ray-query and software SDF transparent-GI routes pass;
• host minimal, shared WebAssembly/folded-bind-group, shared Android
  aarch64/lean-MRT, and full Web wrapper checks pass;
• quality-runner tests: 8/8;
• FFI parity: 0 failures, 0 warnings across all declared platforms;
• cargo fmt --check and git diff --check pass.

The full Android wrapper check is locally blocked before Bloom code by the
missing aarch64-linux-android-clang{,++} NDK tools; the shared renderer's
Android target check passes. The repository line ratchet still reports the
cumulative oversized aggregate/legacy files, while the new modules remain
below policy (transmitted_shadows.rs: 1,305 lines;
transparent_gi.rs: 322 lines). No baseline or golden image was changed.

Evidence:

• tools/quality/out/issue-133-transparent-gi-opaque/result.json
• tools/quality/out/issue-133-transparent-gi-stress/ab.json
• tools/quality/out/issue-133-transparent-gi-stress/

[proggeramlug]

Milestone: bounded refractive reflection-source hierarchy

Completed the reflection-source package for imported physical transmission. #133 remains open for approved Khronos/reference captures, UV1 physical textures, and the documented custom/imported interleaving boundary.

Native source hierarchy

Native refractive materials now select reflected radiance in this order:

1. Explicit planar probe when the glass fragment lies on the first active probe plane and its unperturbed normal aligns with that plane.
2. Glass-local screen-space reflection when no planar probe applies.
3. Prefiltered environment for misses, rough surfaces, disabled SSR, and constrained targets.

The ordinary opaque SSR image is deliberately not reused: it was traced from the opaque surface behind the glass and therefore owns the wrong origin/normal. The glass tier instead launches a bounded ray from the dielectric fragment against the immutable opaque color/depth snapshots already required by native refraction.

The screen tier is fixed at eight quadratically spaced samples over at most eight world units. It uses a depth-thickness confidence test, an eight-pixel boundary fade, NaN scrubbing, and a roughness fade to the prefiltered environment by roughness 0.45.

A matching explicit planar probe is authoritative for its plane. Its non-zero alpha marks captured geometry; alpha zero follows the established planar-material contract and reveals the environment sky without paying for a dense screen-space miss march. The exact single-mip probe fades to the environment from roughness 0.18 to 0.45. Position and normal guards prevent the global first-probe choice from leaking onto unrelated glass that merely crosses the plane.

Planar correctness fix

The live oracle exposed a pre-existing planar capture defect: Bloom applied the common OpenGL [-w,w] oblique-near-plane equation to wgpu/Metal's [0,w] depth convention. Valid above-plane geometry was rejected by mirrored-frustum CPU culling and then clipped again by rasterization.

The replacement z row is now plane / dot(plane, far_corner), which maps the explicit plane to wgpu z=0. A regression test pins the on-plane, kept-side, and rejected-side invariants. With that correction, the probe captures and the glass floor visibly reflects the rotating Damaged Helmet.

Laziness, cost bounds, and fallback

• No graph resource, pass, image, transient slot, or image byte was added.
• The hierarchy reuses physical refraction's existing opaque color/depth snapshots and any probe the application explicitly created.
• One lazy 160-byte uniform plus a dedicated native group-4 layout/bind group appears only after the first physical-transmission material.
• The dedicated route no longer also rebuilds the unused legacy seven-binding scene-input group.
• Ordinary scene shaders/layouts and folded Web/Android four-group shaders are unchanged.
• BLOOM_REFRACTIVE_REFLECTIONS=0|off|false|disabled compiles the exact previous environment-only reflection expression and skips the hierarchy layout/uniform/bind group.
• Runtime SSR disable turns off the screen tier while preserving a matching explicit planar probe.
• Telemetry under renderer_paths.refractive_reflections reports enable/active state, actual source order, fixed march bounds, 160 lazy bytes, and zero graph/image cost.

This milestone deliberately does not launch a per-fragment ray query on screen misses. The retained TLAS does not cover every immediate draw, and shading arbitrary hits would require a second material/radiance representation. A miss-only query would therefore add correctness gaps and scene-dependent performance cliffs. Hardware ray query remains confined to the bounded transparent-GI path where its representation and cost are explicit.

Visual evidence

Added the unversioned examples/quality-transparency/main.ts --reflection-hierarchy oracle: smooth imported transmission on a horizontal planar probe reflects a rotating Damaged Helmet. The versioned default weighted-transparency corpus is unchanged.

Final counterbalanced on/off/off/on captures used 120 warm-up + 240 measured frames each:

• both hierarchy-on final images are byte-identical (02320edd...a584);
• both environment-only final images are byte-identical (06e30f81...e180);
• on/off luminance SSIM: 0.98076;
• luminance RMSE: 0.03709;
• 2.95% of pixels exceed 0.02, confined by the heatmap to the reflected helmet;
• OKLab mean delta: 0.00497; edge mean delta: 0.00162.

No unrelated surface, silhouette, background, or direct helmet pixel changes.

Sustained performance evidence

Apple M1 Max / Metal, averages of the two runs per mode:

• hierarchy on CPU mean/p95: 2.988 / 3.395 ms;
• environment-only CPU mean/p95: 3.005 / 3.323 ms;
• hierarchy on GPU mean/p95: 17.772 / 19.447 ms;
• environment-only GPU mean/p95: 17.460 / 19.282 ms;
• refractive pass mean: 1.143 ms on / 1.123 ms off — 0.021 ms feature delta;
• graph in both modes: 25 passes, 3 transient slots, 6,739,200 transient bytes.

The overall GPU p95 delta is 0.165 ms (<1%) and both routes remain well inside the fixture's 12 ms CPU / 30 ms GPU p95 budgets. CPU mean and render/submit means are slightly lower with the hierarchy. The planar capture itself is identical work in both modes; the comparison isolates only dielectric reflection selection.

Validation

• shared library: 223 passed, 1 ignored;
• full live/golden renderer suite: 17 passed, 2 hardware-oracle ignores;
• post-optimization retained + cached physical-transmission GPU test: passed;
• all native environment-only, native hierarchy, and folded refractive WGSL variants parse through naga;
• host minimal, folded WebAssembly, shared Android aarch64/lean-MRT, and full Web wrapper checks pass;
• quality-runner tests: 8/8;
• FFI parity: 0 failures, 0 warnings across 485 manifest functions;
• cargo fmt --check and git diff --check pass.

The shader split keeps current package files under policy (core.rs: 1,987 lines, weighted.rs: 94, refractive_reflections.rs: 225). The repository line ratchet still reports the cumulative oversized aggregate/legacy files (physics_jolt.rs, material_system.rs, renderer mod.rs, scene.rs, golden_render.rs, and Web lib.rs); this package introduces no new over-limit file.

Documentation: docs/refractive-reflections.md, updated docs/imported-refraction.md, and tools/quality/README.md.

Evidence:

• tools/quality/out/issue-133-reflection-authoritative/on-a/
• tools/quality/out/issue-133-reflection-authoritative/on-b/
• tools/quality/out/issue-133-reflection-authoritative/off-a/
• tools/quality/out/issue-133-reflection-authoritative/off-b/
• tools/quality/out/issue-133-reflection-authoritative/diff/

[proggeramlug]

Milestone: lazy TEXCOORD_1 physical-texture support

Completed the UV1 package for imported physical transmission. Transmission
and volume thickness textures can now independently select TEXCOORD_0 or
TEXCOORD_1 across the camera, transmitted-shadow, and temporal-reactive
routes. #133 remains open for approved Khronos/reference qualification and
the documented custom/imported translucent interleaving boundary.

Import and fallback contract

• Direct GPU, staged/committed, and CPU-only glTF loaders retain
  TEXCOORD_1 only when an active transmission or thickness binding requests
  it.
• The sidecar is accepted only when its element count exactly matches
  POSITION. Ordinary, scalar-only, and UV0-only meshes do not read, retain,
  upload, or allocate it.
• Transmission and thickness keep independent UV selectors, including
  independent KHR_texture_transform values. Mixed UV0/UV1 materials do not
  collapse onto one coordinate set.
• Missing/malformed UV1 and preserved TEXCOORD_2+ requests produce an
  explicit diagnostic and use the scalar physical factor. They never silently
  alias the texture to UV0 or change the material bucket.
• Retained base geometry and each retained LOD carry optional CPU/GPU
  sidecars. If an active UV1 material selects a LOD without a valid sidecar,
  the draw uses the valid base geometry rather than sampling unrelated
  coordinates.
• Model attachment and LOD attachment transfer the sidecar through the
  existing FFI routes.

Lazy renderer architecture

• Vertex3D remains exactly 96 bytes. UV1 is a separate
  8-byte-per-vertex stream at vertex slot 1 / location 7.
• The physical uniform remains exactly 96 bytes. Independent texture
  selectors use previously reserved lanes.
• The established UV0 camera, reactive, and transmitted-shadow shaders and
  pipeline layouts remain unchanged. A UV1 variant is compiled only after a
  resolved physical texture actually needs it.
• Cached geometry in the shared arena uses a mesh-localized draw only for
  UV1. This binds primary/index buffers at the mesh byte offsets with zero
  base vertex so mesh-local sidecar indices stay aligned. The ordinary cached
  route keeps its original whole-arena first_index / base_vertex path.
• Retained, retained-LOD, cached, and cached-skinned physical draws select the
  same UV contract in the refractive camera pass and nearest-layer
  transmitted-shadow caster.
• TAA reactive coverage uses the same selected physical coordinates as the
  shaded transmission result.
• The bounded transparent-GI representation remains deliberately scalar, as
  documented in the preceding package; no texture or per-hit UV ABI was
  smuggled into TLAS/SDF records.

Telemetry under renderer_paths.physical_texture_uv reports supported sets,
whether the lazy UV1 pipeline was initialized, the unchanged ordinary stride,
the sidecar stride, and exact graph/image cost. The UV0 control reported:

{
  "supported_sets": [0, 1],
  "uv1_pipeline_initialized": false,
  "ordinary_vertex_stride_bytes": 96,
  "uv1_sidecar_stride_bytes": 8,
  "additional_graph_passes": 0,
  "additional_image_bytes": 0
}

Correctness coverage

• Literal glTF importer fixtures prove exact UV1 values survive both plain and
  staged loaders.
• A UV0-only physical material proves an unreferenced UV1 accessor is not
  retained.
• Missing UV1 preserves the authored material metadata while leaving the
  sidecar absent and selecting scalar fallback.
• ABI tests pin the 96-byte ordinary vertex, 96-byte physical uniform,
  8-byte sidecar layout, location 7, and independent transmission/thickness
  selectors.
• Naga parses native environment-only, native reflection-hierarchy, folded
  Web/Android, temporal-reactive, and transmitted-shadow variants with and
  without UV1.
• A live Metal oracle uses a texture that is white at UV0 and black at UV1.
  It proves:
  • UV1 output is materially different from scalar/UV0 fallback;
  • retained and cached outputs agree to less than 0.5 mean RGB code value;
  • the UV1 transmitted-shadow caster executes without validation errors; and
  • the UV1 temporal-reactive pipeline renders successfully.
• Existing retained/cached physical transmission, colored transmitted shadow,
  transparent-GI hardware/software, path-tracing golden, render-target, and
  ordinary shader tests remain green.

Cross-target and regression qualification

• Shared library: 227 passed, 1 ignored.
• Live/golden renderer suite: 18 passed, 2 hardware-oracle ignores.
• Render-target suite: 3 passed.
• Folded Web wrapper: wasm32-unknown-unknown check passed.
• Android wrapper: aarch64-linux-android check passed with NDK clang.
• FFI parity: 0 failures, 0 warnings across 485 manifest functions.
• cargo fmt --check and git diff --check pass.
• The package-local shader file is back under the 2,000-line policy
  (core.rs: 1,980; focused tests: 60). The line ratchet reports only the six
  cumulative aggregate/legacy overages already present elsewhere in the
  roadmap work.

Counterbalanced old/new quality capture

The saved pre-UV1 executable
66557b3800c0686a4835ac19b06a8f388b8b5c4adc10639699cc8b620a31d5ee
and the current executable ran the same 96-layer physical-transmission scene
at 1920×1080, preset 3, with 120 warm-up + 240 measured frames in both
old/new and new/old orderings.

Average of the two runs per binary:

Metric	Pre-UV1	Current	Delta
CPU mean	4.590 ms	4.652 ms	+0.062 ms / +1.36%
CPU p95	7.052 ms	7.201 ms	+0.149 ms / +2.11%
GPU mean	95.458 ms	94.475 ms	-0.983 ms / -1.03%
GPU p95	127.030 ms	125.291 ms	-1.739 ms / -1.37%
measured wall time	203,388.526 ms	202,798.306 ms	-590.219 ms / -0.29%

The small CPU-counter movement is below the repository's reproducibility
bounds (0.35 ms mean, 1.0 ms p95), while measured wall time and both GPU
metrics improve. More importantly, both binaries compile the identical cached
graph: plan 87947527a4410b3b, 25 passes, 3 transient slots, and 26,956,800
transient bytes. The current UV0 control proves the UV1 pipeline stayed
uninitialized and added no graph pass or image byte.

Both strict image comparisons pass:

Pair	Luminance RMSE	SSIM	Max error	Pixels > 0.02	OKLab / edge mean
old-a → new-a	0.000054	0.99999994	0.011765	0%	0.00000142 / 0.00000163
old-b → new-b	0.000057	0.99999994	0.011765	0%	0.00000145 / 0.00000168

No golden image or approved portable baseline was changed.

Documentation is in docs/imported-refraction.md,
docs/transmitted-shadows.md, and tools/quality/README.md.

Evidence:

• tools/quality/out/issue-133-uv1/{old-a,new-a,new-b,old-b}/
• tools/quality/out/issue-133-uv1/uv0-old-new-strict-metrics.json
• tools/quality/out/issue-133-uv1/uv0-old-new-reverse-metrics.json

[proggeramlug]

Implemented the next #133 package: global depth ordering between imported
BLEND geometry and custom translucent materials.

Problem closed

Imported glTF BLEND draws (immediate, cached, and retained) and custom
Transparent/Refractive/Additive material draws were each stable-sorted,
but the renderer submitted the complete imported list before the complete
custom list. A custom draw that belonged between two imported surfaces
therefore blended at the wrong point.

Conventional sorted composition now uses one deterministic order:

1. view depth, far to near;
2. source rank only at exactly equal depth (imported before custom);
3. source-local stable object/submission ID.

The two already-sorted source ranges are merged linearly during dispatch. No
combined draw list or per-frame combined allocation was added. Imported-only,
custom-only, opaque, and weighted-OIT dispatch retain their existing paths.
Weighted OIT remains an imported aggregate resolved before custom material
commands because its accumulation is intentionally order-independent.

TAA/reactive-mask compatibility

Imported sorted translucency writes the R8 temporal-reactive attachment, while
the arbitrary custom pipeline previously targeted only HDR. A mixed TAA frame
now lazily compiles an attachment-compatible sibling of each participating
custom translucent pipeline:

• identical user shader, HDR format/blend, depth state, vertex layout, and
  culling;
• a second R8Unorm target with an empty color-write mask;
• no shader ABI/source change and no ability for the custom shader to overwrite
  imported reactive coverage;
• initialized only when that material first participates in a mixed
  imported/custom sorted TAA frame.

This allows the globally ordered draws to remain in one render pass instead of
splitting imported reactive coverage and custom translucency into two physical
passes. It adds no draw, logical graph pass, image, or transient allocation.

BLOOM_SORTED_INTERLEAVING=0|false|off|disabled restores the prior whole-list
boundary for exact startup/fallback A/B. Telemetry under
renderer_paths.transparency reports the ordering contract, enable state, lazy
reactive sibling count, and invariant zero additional draws/graph passes.

Regression oracles

• Unit oracle covers far-to-near depth, exact-depth source tie, and stable-ID
  tie; the production comparison uses f32::total_cmp.
• GPU oracle proves ordinary compilation remains lazy, the sibling compiles
  once, a two-attachment pass validates, HDR receives the custom draw, and the
  R8 attachment remains at its clear value.
• Full renderer property oracle proves a custom pane moved behind vs. in front
  of imported layers changes the fully overlapped center pixel. The old
  whole-list boundary cannot satisfy that property.
• Existing negative sorted-order and WBOIT AB/BA properties remain green.
• The opt-in examples/quality-transparency --sorted-interleaving fixture
  interleaves 96 imported and 96 custom layers across 12 cells with TAA active.
  It does not alter the versioned/default fixture.

The focused final images are byte-deterministic within each mode:

• global A/B SHA-256:
  dbfacec1982037bc67ef801b9a054ec3d7edf6a86bd9a6cda7027a203356a6dc
• legacy A/B SHA-256:
  360f83f7d1fef6a75c977c826bb11ecf9adcb2781a2d20d4423f9d45e461c556

The intentional global-vs-legacy correction is localized to the custom panes
and overlap edges: SSIM 0.99887, luminance RMSE 0.00383, mean OKLab delta
0.00213, edge delta 0.00016, and 8.18% of pixels above 0.02.

Counterbalanced performance evidence

Apple Metal, preset 3, render scale 1.0, 60 warm-up + 120 measured frames,
order global / legacy / legacy / global:

metric	legacy mean	global mean	delta
CPU frame mean	3.883 ms	4.002 ms	+0.119 ms (+3.06%)
CPU frame p95	6.162 ms	6.258 ms	+0.096 ms (+1.56%)
GPU frame mean	61.208 ms	61.331 ms	+0.122 ms (+0.20%)
GPU frame p95	86.610 ms	86.029 ms	-0.581 ms (-0.67%)
measured wall	56.191 s	57.216 s	+1.025 s (+1.82%)

CPU and GPU deltas are inside the repository's tighter same-machine absolute
reproducibility allowances (0.35/1.0 ms mean and 1.0/12 ms p95). Both modes
compile the same logical graph plan 90506f74bcaf8629: 24 passes, one
transient slot, and 2,073,600 transient bytes. The global route reports one
lazy custom reactive sibling; the legacy route reports zero. Both report zero
additional draws and graph passes.

Evidence is retained locally under
tools/quality/out/issue-133-sorted-interleaving/.

Qualification

• shared library: 229 passed, 0 failed, 1 ignored
• golden/live renderer suite: 18 passed, 0 failed, 2 hardware ignores
• render-target suite: 3 passed
• folded Web wrapper: passed
• Android aarch64-linux-android wrapper with NDK clang: passed
• FFI validation: 0 failures, 0 warnings; 485 manifest functions
• cargo fmt --check: passed
• git diff --check: passed
• file-line ratchet: the same six cumulative/pre-existing oversized files
  remain; this package adds no oversized file, shrinks
  material_system.rs/scene_pass.rs/golden_render.rs, and keeps the new
  implementation and golden child modules below 400 lines.

Documentation now covers the global key, lazy reactive sibling, weighted and
physical-transmission boundaries, exact kill switch, telemetry, and focused
fixture.

I am leaving #133 open for the remaining approved Khronos/reference-image
qualification rather than treating the focused synthetic oracle as art
approval.

[proggeramlug]

Milestone: pinned Khronos alpha/transmission/volume qualification

Completed the official-corpus qualification package and synchronized the acceptance checklist to 7/8 complete. The issue stays open because explicit human reference-image approval for the glass/reference criterion is still outstanding.

What landed

• Added an opt-in runner pinned to Khronos glTF-Sample-Assets revision 2bac6f8c57bf471df0d2a1e8a8ec023c7801dddf.
• SHA-256 verifies AlphaBlendModeTest, TransmissionTest, AttenuationTest, and TransmissionOrderTest and records each upstream license.
• Each control renders twice, rejects supported-field import/validation diagnostics, rejects flat/black output, and requires byte-exact same-machine repeatability.
• The tool writes candidates only. It cannot install or approve a baseline.

Defect found and corrected

The first official AttenuationTest run exposed lost static glTF node scale in KHR_materials_volume. The pre-fix Node Scale row was effectively flat: [36, 39, 36, 37, 39] blue-minus-red from scale 0.25 through 2.0.

The importer now retains baked static-node mean scale separately from authored thicknessFactor, then consumes the effective thickness consistently in camera refraction, transmitted shadows, and transparent GI. The corrected ramp is [18, 29, 36, 41, 42]. The automated semantic gate fails the clean pre-fix binary and passes the corrected one.

The isolated change is localized to the five scale-row cubes: luminance RMSE 0.004399808, SSIM 0.998071194, 2.013852835% of pixels above 0.02, OKLab mean delta 0.000606760, edge mean delta 0.000184952. AlphaBlendModeTest, TransmissionTest, and TransmissionOrderTest remain byte-for-byte unchanged.

Final result

At b40d28b3f52332fc210f1382fa9cb4efa5450f8f, all four controls passed twice with identical hashes, semantic gates, and zero supported-field diagnostics. The 96-byte GPU transmission uniform is unchanged; there is no added render pass, draw, GPU allocation, texture sample, binding, or shader branch. Joint/weight accessors are also no longer repeatedly decoded inside the vertex loop.

Regression gates passed for native models3d, WebAssembly, FFI/schema parity on all declared platforms, file-size policy, the complete shared/GPU suite, quality governance, visual-diff fault controls, and the cooker.

Evidence: human-readable report and machine-readable measurements.

Remaining boundary: independent human approval of the reference candidates. No portable baseline or golden image was changed.