Preserve CPU compatibility WIP and exact C28 host; validation remains incomplete
This commit is contained in:
1 parent
7cf392d7c3
commit
b3a01bf400
52 files changed
+67137
No files matched your search
@@ -235,3 +235,13 @@ compilation are pending at curation; the planned 983 cases are all UNRUN.
|
||||
Apply only on the exact C27 failed-source composition, not arbitrary main.
|
||||
|
||||
The single-host recovery has now been independently source-reviewed and adopted locally. Compilation, all 983 planned cases and native each-pass image acceptance remain pending.
|
||||
|
||||
## Progressive CPU compatibility WIP, isolated fixture and exact C28 host — 31 October
|
||||
|
||||
[Separated source packages and exact bindings](../2026-10-31/progressive-compatibility-wip/README.md)
|
||||
preserve 34 uncompiled WIP candidates plus the actual earlier formatted C28 host
|
||||
(35 source files). C28: 28 PASS / 1 font-fixture FAIL / 954 UNRUN, two actual
|
||||
CPU-supported markers; no postchecks/native acceptance. The corrected test is
|
||||
UNRUN. Compatibility remains NOT ADOPTED, UNCOMPILED and UNRUN; fixed Record
|
||||
ABI/accounting and one P3 parameter-list omission remain pending. No full CI or
|
||||
readiness claim, no implied composition of overlapping UI and font-fix files.
|
||||
@@ -0,0 +1,65 @@
|
||||
# Progressive CPU: preserved compatibility WIP and isolated fixture fix
|
||||
|
||||
31 October 2026. Source preservation for #6201; **local curation, not a production
|
||||
source change or completed integration**. Four WIP subpackages retain 34 RAW
|
||||
candidates, and a fifth package preserves the exact earlier compiled C28 host
|
||||
reference: 35 source files total, with per-file RAW bindings and LF patches.
|
||||
They are deliberately separate; this archive supplies no combined source.
|
||||
|
||||
## Actual earlier C28 result, separate from these proposals
|
||||
|
||||
The C28 source build succeeded with five library artifacts and ten inventories.
|
||||
Of 983 selected cases, **28 passed, one failed and 954 were not run**; two actual
|
||||
CPU-supported branch markers were observed before the stop. The failed case 976
|
||||
panicked because its separate UI test context had no ui-semibold font binding.
|
||||
It did not reach a failing SPP/cap assertion. This is the earlier exact C28 result,
|
||||
not a pass for the changed source packages below.
|
||||
|
||||
The isolated one-line font fixture correction is preserved in fontfix and remains
|
||||
UNRUN. It uses the actual bundled-font bootstrap already used by app and Harness,
|
||||
with every original assertion intact. It is not a change to product typography.
|
||||
|
||||
## Independent packages and required composition
|
||||
|
||||
- [core](core/README.md): 26 source candidates for one serializable runtime cadence
|
||||
authority, strict command handling, sparse legacy producer/host behavior and
|
||||
eight written tests. Requires ui and prefs.
|
||||
- [ui](ui/README.md): five source candidates for captured preference identity and
|
||||
copy-only Interactive sampling, plus six neutral constructors and five tests.
|
||||
- [prefs](prefs/README.md): two candidates, including the locale v2 successor; two
|
||||
independent true-default bools and one preference-contract test.
|
||||
- [fontfix](fontfix/README.md): one isolated existing-test fixture correction.
|
||||
- [current-c28-host](current-c28-host/README.md): the exact formatted host from the
|
||||
earlier C28 build, separate from the 34 uncompiled WIP candidates. Its recovery
|
||||
preimage differs by exactly one LF; this file is not a complete build snapshot.
|
||||
|
||||
All compatibility proposals are **NOT ADOPTED, UNCOMPILED and UNRUN**. Their 14
|
||||
new tests and the corrected existing test are not results. Exact later composition
|
||||
must preserve both overlapping render_workspace_tests.rs deltas; neither full
|
||||
candidate may replace the other. No hypothetical precedence is implied.
|
||||
|
||||
The source has independent static Kernel and UI reviews. No demonstrated P1/P2
|
||||
functional defect was reported in those bounded reviews. One known P3 remains:
|
||||
the earlier typed-job controls list at core/candidate/crates/engine/src/cmd/render.rs
|
||||
line 127 omits cpu_progressive_every_pass although later documentation and the
|
||||
parser admit it. The source bytes are preserved without silently fixing it.
|
||||
|
||||
Actual Record layout/ABI and sufficient fixed admission accounting are pending.
|
||||
An unchanged size assertion is not a measured layout or runtime pass. Resource
|
||||
budgets must not be raised, and no allocation hidden, to satisfy these checks.
|
||||
|
||||
No native application acceptance, full CI, renderer parity, first-launch policy
|
||||
qualification, readiness or merge is claimed. BIN/native validation for the
|
||||
earlier source remains a separate activity and is not blocked or replaced here.
|
||||
|
||||
## How to review
|
||||
|
||||
Each candidate is byte-identical to its closed owner packet; no formatter or
|
||||
production edit was run by the curator. source-bindings.json in each directory
|
||||
pins every RAW preimage and candidate. delta-LF-review.patch normalizes line endings
|
||||
for reading; candidate bytes remain authoritative for mixed-EOL files. Do not apply
|
||||
the archive to arbitrary main or qualify it using historical test results.
|
||||
|
||||
Only public-safe source, portable bindings, review patches and these notes are
|
||||
included. Private ledgers, scripts, grants, control receipts, logs, binaries and
|
||||
local paths are excluded.
|
||||
@@ -0,0 +1,19 @@
|
||||
# Canonical request and producer compatibility WIP
|
||||
|
||||
26 exact RAW candidates from the sealed W3 proposal. **NOT ADOPTED, UNCOMPILED,
|
||||
UNRUN; not a complete workspace.** Eight new tests are written, not executed.
|
||||
The sole runtime authority is ImageRequest.cpu_progressive_every_pass, with the
|
||||
same strict top-level Start control: omitted/true keeps every-pass publication,
|
||||
false survives serialization and restores the earlier sparse policy. Saved jobs
|
||||
retain their own sampling authority. No skipped nested alias is introduced.
|
||||
|
||||
The UI package supplies six required constructor updates and capture wiring;
|
||||
prefs supplies two independent switches. Source reviews are not runtime proof.
|
||||
The fixed Record embeds ImageRequest: actual target layout/ABI and sufficient
|
||||
fixed admission accounting remain unqualified. Existing task/frame/metadata
|
||||
assertions were preserved; their preservation is not a compiled PASS.
|
||||
|
||||
Known P3: candidate crates/engine/src/cmd/render.rs:127 has an earlier saved-job
|
||||
control list omitting cpu_progressive_every_pass; later parameter documentation
|
||||
and the parser admit it. Correct that sentence during coordinated integration.
|
||||
No demonstrated P1/P2 source defect was reported by the independent review.
|
||||
+441
@@ -0,0 +1,441 @@
|
||||
//! Render capability discovery and persistent intent. No rendering or host probing.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_doc::render_settings::{RenderSettings, RenderSetup};
|
||||
|
||||
use super::CommandSpec;
|
||||
use crate::params::bad;
|
||||
use crate::{Result, Session};
|
||||
|
||||
mod clear_coat;
|
||||
mod effects;
|
||||
mod environment;
|
||||
mod jobs;
|
||||
mod library;
|
||||
mod library_data;
|
||||
#[cfg(test)]
|
||||
mod light_union_tests;
|
||||
mod lights;
|
||||
mod optical_bindings;
|
||||
mod physical_library;
|
||||
mod resources;
|
||||
mod shots;
|
||||
mod staging;
|
||||
mod studio_presets;
|
||||
mod surface_bindings;
|
||||
mod textures;
|
||||
mod transmission;
|
||||
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("render.environment.set", "Set Render Environment", crate::checked!("render.environment.set", environment::set)).icon("settings").doc_only()
|
||||
.contract(&environment::CONTRACT)
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render::EnvironmentResult>)
|
||||
.params("name; set?: numerical setup patch; rotation_deg?: finite degrees within +/-1000000, wrapped to [-180,180); intensity?: finite linear intensity 0..64 CPU or 0..100 GPU. Edits the existing HDR, sky or constant environment in one undo, without selecting a source, moving the camera or starting a render. Absent environments and raster refuse."),
|
||||
CommandSpec::new("render.lights.set", "Set Render Light", crate::checked!("render.lights.set", lights::set))
|
||||
.icon("render_scene").doc_only()
|
||||
.contract(&crate::schema::TypedContract::<crate::schema::render_lights::EditParams>::new())
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render_lights::EditResult>)
|
||||
.params("name; id except add; settings?: full unsaved RenderSetup; expected_revision?:u64; set for set/add: kind directional/point/spot/area, intensity_ev, temperature_k, softness, azimuth_deg, elevation_deg, distance_mm, size_mm, aim_at, width_mm, height_mm, position_mm, direction, edge_u_mm, edge_v_mm, radiance, colour, reference_distance_mm, minimum_distance_mm. Validated finite light edit in one undo. Existing family caps and backend support apply; refusal is atomic. Names remain defaults."),
|
||||
CommandSpec::new("render.lights.add", "Add Light", crate::checked!("render.lights.add", lights::add))
|
||||
.icon("render_scene").doc_only()
|
||||
.contract(&crate::schema::TypedContract::<crate::schema::render_lights::EditParams>::new())
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render_lights::EditResult>)
|
||||
.params("name; id except add; settings?: full unsaved RenderSetup; expected_revision?:u64; set for set/add: kind directional/point/spot/area, intensity_ev, temperature_k, softness, azimuth_deg, elevation_deg, distance_mm, size_mm, aim_at, width_mm, height_mm, position_mm, direction, edge_u_mm, edge_v_mm, radiance, colour, reference_distance_mm, minimum_distance_mm. Validated finite light edit in one undo. Existing family caps and backend support apply; refusal is atomic. Names remain defaults."),
|
||||
CommandSpec::new("render.lights.duplicate", "Duplicate Render Light", crate::checked!("render.lights.duplicate", lights::duplicate))
|
||||
.icon("render_scene").doc_only()
|
||||
.contract(&crate::schema::TypedContract::<crate::schema::render_lights::EditParams>::new())
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render_lights::EditResult>)
|
||||
.params("name; id except add; settings?: full unsaved RenderSetup; expected_revision?:u64; set for set/add: kind directional/point/spot/area, intensity_ev, temperature_k, softness, azimuth_deg, elevation_deg, distance_mm, size_mm, aim_at, width_mm, height_mm, position_mm, direction, edge_u_mm, edge_v_mm, radiance, colour, reference_distance_mm, minimum_distance_mm. Validated finite light edit in one undo. Existing family caps and backend support apply; refusal is atomic. Names remain defaults."),
|
||||
CommandSpec::new("render.lights.remove", "Remove Render Light", crate::checked!("render.lights.remove", lights::remove))
|
||||
.icon("render_scene").doc_only()
|
||||
.contract(&crate::schema::TypedContract::<crate::schema::render_lights::EditParams>::new())
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render_lights::EditResult>)
|
||||
.params("name; id except add; settings?: full unsaved RenderSetup; expected_revision?:u64; set for set/add: kind directional/point/spot/area, intensity_ev, temperature_k, softness, azimuth_deg, elevation_deg, distance_mm, size_mm, aim_at, width_mm, height_mm, position_mm, direction, edge_u_mm, edge_v_mm, radiance, colour, reference_distance_mm, minimum_distance_mm. Validated finite light edit in one undo. Existing family caps and backend support apply; refusal is atomic. Names remain defaults."),
|
||||
CommandSpec::new("render.lights.list", "List Render Lights", crate::checked!("render.lights.list", lights::list))
|
||||
.icon("list").noundo().doc_only()
|
||||
.contract(&crate::schema::TypedContract::<crate::schema::render_lights::ListParams>::new())
|
||||
.output(crate::schema::output_schema_for::<crate::schema::render_lights::ListResult>)
|
||||
.params("setup?: saved setup name OR settings?: complete RenderSetup snapshot; neither uses defaults. Returns {lights:[{id,kind,name,name_key,number,implicit,intensity,colour,...spatial fields}]}. IDs are kind:zero-based-source-slot, stable across numerical edits but not family changes/reordering/removal/rig replacement; point and spot share punctual slots. Includes implicit default/preset lights. GPU RGB radiance is factored as colour * intensity; area edges are full world-mm vectors. Read-only, no host, camera change, save, render, model evaluation or undo. See docs/render-settings.md."),
|
||||
CommandSpec::new("render.aging.describe","Layered Surface Aging",effects::aging).icon("appearance").noundo().doc_only()
|
||||
.params("Empty object. Read-only original Rust/patina/dust/grime/scratch/chip/fading presets and exact GPU aging contract. UI activation opens the shared Aging tab; edits remain a saved render draft, never engineering geometry or material-property mutation."),
|
||||
CommandSpec::new("render.effects.describe","Lens and Creative Effects",effects::presentation).icon("camera").noundo().doc_only()
|
||||
.params("Empty object. Read-only original photographic/creative filter defaults and constraints. UI activation opens shared Effects controls. Saved finishing and exact-master regrading preserve raw EXR bytes; no physical lens or branded-film calibration is implied."),
|
||||
CommandSpec::new("render.optics.bind","Save Optical Binding",optical_bindings::bind).icon("appearance")
|
||||
.params("name: GPU setup; set?: complete numerical setup patch; body_index and body_name: exact captured target; expected_revision; optics:{ior,absorption_per_mm:[r,g,b],boundary:closed_mesh|closed_box|thin_sheet,thickness_mm,shadow_transmission,subsurface?:{scattering_per_mm,anisotropy}}; replace?:false. Stores stable definition/feature/occurrence identity in one undo without modifying engineering geometry/materials. Nested media require separate job.options.nested_media and producer certification. Unresolved or incompatible targets refuse atomically."),
|
||||
CommandSpec::new("render.optics.unbind","Remove Optical Binding",optical_bindings::unbind).icon("appearance").doc_only()
|
||||
.params("name: saved setup; target: exact saved definition/feature/component/occurrence_path; expected_revision. Removes only that optical assignment in one undo without a device or file access."),
|
||||
CommandSpec::new("render.result.regrade", "Regrade Linear Master", jobs::regrade).icon("render_image").noundo().doc_only()
|
||||
.params("job: exact completed JobId; presentation: {exposure_ev?,tone_map?,finishing?,backdrop?,background?,transparent_background?}. Queues cancellable nondestructive PNG presentation from that retained native FLOAT32 master, not from PNG. Captured geometry/camera/lighting and source EXR remain unchanged; no path tracing, denoising, external EXR import or automatic file writes. Returns a distinct job with source identity and original-master digest. Existing frame retention and export rules still apply."),
|
||||
CommandSpec::new("render.camera.set", "Set Render Camera", set_camera).icon("camera").noundo().doc_only()
|
||||
.params("camera: complete Render Camera snapshot (target, yaw, pitch, distance, fov; roll defaults to 0 and up to z). Validates the same finite mm/radian bounds as saved render intent, preserves explicit roll/up and changes only transient view state. No model evaluation, setup save, renderer, dirty flag or undo step. Design view.apply retains its separate up-axis policy."),
|
||||
CommandSpec::new("render.camera.get", "Inspect Render Camera", get_camera).icon("camera").noundo()
|
||||
.params("No parameters. Returns the explicitly defined current view camera, or null if the session has no camera override. No camera is fitted, no job is started and no saved setup or engineering document is changed."),
|
||||
CommandSpec::new("render.camera.fit", "Frame Render Subject", fit_camera).icon("camera").noundo()
|
||||
.params("No parameters. Fits the current camera to the visible product bounds through the shared Camera::fit contract; changes only view state, not a saved setup, rendering job, stage or engineering geometry."),
|
||||
CommandSpec::new("render.preset.resolve", "Review Native Studio", studio_presets::resolve).icon("render_scene").noundo()
|
||||
.params("id: NATIVE-STUDIO-001..025; name; set?: typed GPU setup patch; expected_revision?:u64. Resolves original built-in HDR/rig/passive ground with conservative geometry clearance, returns all replacements and preserved fields without mutation. Unbound SCENE-* concepts are not accepted."),
|
||||
CommandSpec::new("render.preset.apply", "Apply Native Studio", studio_presets::apply).icon("render_scene")
|
||||
.params("Same reviewed input as render.preset.resolve, expected_revision required, replace_lighting_and_environment:true and replace_stage:true when an existing stage would change. Re-resolves the complete candidate and publishes one undo or no mutation; camera, optical bindings, geometry and engineering materials are preserved."),
|
||||
CommandSpec::new("render.quality.prepare", "Review Fixed Sampling Budget", studio_presets::quality).icon("settings").noundo().doc_only()
|
||||
.params("id: Q-*; variant:fixed_samples_png; acknowledge_omissions:true. Read-only bounded GPU still-budget projection, not full adaptive/convergence/linear-master quality acceptance. Returns dimensions/samples/depth/seed/denoise and explicit omissions. Never switches executor or mutates a shot."),
|
||||
CommandSpec::new("render.shot.duplicate", "Duplicate Render Shot", shots::duplicate).icon("copy").doc_only()
|
||||
.params("name, new_name, expected_revision:u64. Copies exact saved setup and resource references in one undo. Existing destinations refuse; captured jobs and camera navigation are unchanged."),
|
||||
CommandSpec::new("render.shot.rename", "Rename Render Shot", shots::rename).icon("settings").doc_only()
|
||||
.params("name, new_name, expected_revision:u64. Renames exact saved setup in one undo; an existing destination or stale review refuses."),
|
||||
CommandSpec::new("render.shot.remove", "Remove Render Shot", shots::remove).icon("delete").doc_only()
|
||||
.params("name, expected_revision:u64. Removes only that saved setup in one undo; retains resources, geometry and captured results."),
|
||||
CommandSpec::new("render.library.preview", "Inspect Original Surface Map", library::preview).icon("appearance").noundo().doc_only()
|
||||
.params("id: SURF-*. Returns bounded hash-verified original base-color PNG bytes and source-map fidelity label, not a rendered material thumbnail. No external paths, rendering or document edits."),
|
||||
CommandSpec::new("render.library.physical.prepare", "Prepare Physical Reference", physical_library::prepare).icon("inspect").noundo().doc_only()
|
||||
.params("id: named built-in physical profile, name: proposed new material label, acknowledge_reference:true. Read-only loss-aware creation plan using native ValidatedCard admission and one point density; returns source receipts, extended fields and omissions. Does not execute material.create, assign bodies or infer effective-part physics."),
|
||||
CommandSpec::new("render.stage.ground", "Save Render Ground", staging::ground).icon("render_scene")
|
||||
.params("name: typed raytrace setup, set?: setup patch, margin_fraction?:0.25, gap_mm?:0.1, reflectance_linear?:[0.18,0.18,0.18], replace_stage?:false. Fits one finite passive ground below the visible product once and saves its physical transforms in one undo. Product AABB separation is rechecked on every render."),
|
||||
CommandSpec::new("render.stage.backdrop", "Save Physical Render Background", staging::backdrop).icon("render_scene").doc_only()
|
||||
.params("name: typed raytrace setup, set?: setup patch, kind: floor_wall or cyclorama, reflectance_linear?: [0.18,0.18,0.18], expected_revision: reviewed revision, replace_stage?:false. Fits a finite floor/wall or a 24-strip polygonal cyclorama behind the visible subject using the saved camera azimuth; world +Z up and a minimum one-mm stage envelope. Preserves subject geometry, lighting, output, pose and engineering materials; one undo and rechecked product separation. Not an infinite/analytically smooth/terrain background."),
|
||||
CommandSpec::new("render.stage.clear", "Remove Render Stage", staging::clear).icon("render_scene").doc_only()
|
||||
.params("name: setup, set?: setup patch. Removes saved render-only panels atomically; CAD geometry and lighting are unchanged."),
|
||||
CommandSpec::new("render.library.surface.bind", "Save Surface Binding", surface_bindings::bind).icon("appearance")
|
||||
.params("name: GPU setup; set?: setup patch; surface: same input as render.library.surface.prepare; replace?: false. Pins exact source hashes and definition/feature/occurrence identity with local-mm mapping in one undo. No paths, mesh ordinals or physical material changes."),
|
||||
CommandSpec::new("render.library.surface.unbind", "Remove Surface Binding", surface_bindings::unbind).icon("appearance").doc_only()
|
||||
.params("name: setup, target: saved definition/feature/component/occurrence_path, set?: setup patch. Removes only that explicit binding in one undo; no device or current geometry required."),
|
||||
CommandSpec::new("render.result.pin", "Retain Displayed Render Result", jobs::pin).icon("inspect").noundo().doc_only()
|
||||
.params("job: completed JobId, or null to release the displayed-result pin. Retains at most one completed result independently of a newer completion; preserves exact export bytes and original host memory accounting. No design/undo change; preview or foreign jobs refuse."),
|
||||
CommandSpec::new("render.library.targets", "Find Render Library Targets", library::targets).icon("list").noundo()
|
||||
.params("query?: exact-name substring; offset?:0; limit?:128 (1..128). Returns a bounded page of captured body ordinals/names, revision and scene bounds. Settles the model through ordinary command handling; never returns a large mesh payload."),
|
||||
CommandSpec::new("render.library.list", "Browse Render Library", library::list).icon("list").noundo().doc_only()
|
||||
.params("kind?: surfaces, selene_appearances, hdr, rigs, scenes, materials, lighting, environments, quality, native_scenes, selene_shots or capabilities; query?: bounded search; availability?: all/usable/specification/blocked; offset?:0; limit?:48 (1..128). Returns source status and explicit implemented projections separately. No device, file IO or design change."),
|
||||
CommandSpec::new("render.library.describe", "Inspect Render Library Resource", library::describe).icon("inspect").noundo().doc_only()
|
||||
.params("kind, id: exact authored resource. Returns original specification, runtime projection variants and explicit omissions. A concept is not an executable preset."),
|
||||
CommandSpec::new("render.library.appearance.apply", "Apply Library Opaque Appearance", library::apply_appearance).icon("appearance")
|
||||
.params("id: SURF-* or SELENE-AP-*; variant: uniform_opaque (required); bodies: 1..256 exact body names. Applies the original scalar baseline through ordinary appearance assignment in one undo, preserving physical properties. Spatial maps and advanced target effects are explicitly excluded."),
|
||||
CommandSpec::new("render.library.environment.apply", "Apply Built-in HDR Environment", library::apply_environment).icon("settings").doc_only()
|
||||
.params("id: HDR-*; name: saved setup; set?: typed CPU/GPU setup patch; rotation_rad?: authored rotation (native origin offset is explicit in the reply); intensity?:1; samples?:16 for CPU; replace_environment?:false. Hash-verifies and embeds original bytes, saves one atomic undo without external files or a render device. An HDR-owned sun cannot duplicate an analytic sun."),
|
||||
CommandSpec::new("render.library.surface.prepare", "Prepare Authored Surface Maps", library::prepare_surface).icon("appearance").noundo()
|
||||
.params("id: SURF-*; body_index and body_name from render.scene; origin?:[0,0,0]; plane?:xy/yz/zx; scale?:1. Returns an explicit GPU planar map binding with source hashes, original millimetre scale, image-up normal orientation and absolute base-color semantics. No document change; height/displacement and true anisotropy are not included."),
|
||||
CommandSpec::new("render.library.studio.prepare", "Prepare Authored Studio Lights", library::prepare_studio).icon("inspect").noundo().doc_only()
|
||||
.params("id: RIG-*; variant: complete for emitter-only rigs, emitters_only for rigs with passive cards; center_mm and subject_extent_mm required. Converts exact rectangular half-edges and solar direction/radius to GPU lighting. Blocked calibration and external-sun rigs refuse. Returns a geometry-clearance review requirement; does not create cards or modify the scene."),
|
||||
CommandSpec::new("render.library.studio.apply", "Apply Authored Studio Lights", library::apply_studio).icon("settings")
|
||||
.params("rig: render.library.studio.prepare parameters; name; set?: typed GPU setup patch; replace_lighting_and_environment:true required. Saves the explicit rig projection in one undo, removing prior lighting/environment only with that confirmation. Subject clearance still needs review; passive cards are never silently omitted."),
|
||||
CommandSpec::new("render.hdr.inspect", "Inspect HDR Source", resources::inspect).icon("inspect").noundo().doc_only()
|
||||
.params("path: scoped Radiance HDR file; validates the complete bounded source and returns sha256, width, height, encoded_bytes and primaries without saving or rendering"),
|
||||
CommandSpec::new("render.settings.capture_hdr", "Save Render Settings with HDR", resources::capture_settings).icon("settings").doc_only()
|
||||
.params("name, set: typed CPU/GPU setup patch with hdr/environment unset; path: scoped HDR; expected_sha256?: digest returned by render.hdr.inspect (changed sources refuse); rotation_rad?:0, intensity?:1; samples?:1/4/16/64 for CPU only (default16); assume_linear_srgb?:false for GPU only. Captures immutable bytes and saves resource plus setup atomically in one undo, without a host; returns name/setup/resource metadata, never source bytes"),
|
||||
CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).icon("inspect").noundo().doc_only()
|
||||
.params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace, transient studio_weights, raster_lights and progressive_feedback may accompany it. raster_lights?: transient null (legacy studio) or 0..8 directional sources {direction:[x,y,z],color:[linear r,g,b],intensity:0..64}; empty array is dark direct lighting. Requires builtin Raster without studio_weights, raytrace, HDR, transmission or other method controls; existing RenderSetup.exposure_ev is captured for Raster within -32..32. Directions are finite/nonzero and bounded by 1e9; RGB is 0..1. Not saved; no shadows or physical glass. raster_punctual_lights?: transient null or 0..8 shared point/spot sources {position_mm:[x,y,z],color:[linear r,g,b],intensity:0..64,reference_distance_mm:0.001..1000000,minimum_distance_mm:0.001..reference_distance_mm,cone?:{emitted_axis:[x,y,z],inner_half_angle_radians,outer_half_angle_radians}}. Spot angles require 0<=inner<outer<=pi/2 and a finite nonzero emitted axis. raster_area_lights?: transient null or 0..4 rectangles {center_mm:[x,y,z],edge_u_mm:[x,y,z],edge_v_mm:[x,y,z],color:[linear r,g,b],intensity:0..64}; full perpendicular side lengths 0.000001..1000000mm, corners within +/-1000000000mm, U cross V emits. Local sources require a runtime request with settings.job:null or an untyped setup; saved typed jobs refuse them. All three absent/null collections preserve the legacy studio; any explicit local array, even empty, disables implicit sources, and absent raster_lights then means no directionals. Local images use unshadowed point/spot falloff and a one-point projected-area rectangle approximation; no finite footprint, soft shadows, environment, area_samples, softness or seed. Local light evaluations count within the existing projected-work limit; caps are 8directional+8shared point/spot+4rectangle, with the existing Raster memory envelope and one captured exposure. Positions and spot-axis components are finite and bounded by1e9; RGB0..1. No saved/UI local-light authoring yet. progressive_feedback?: false; transient protected display updates during CPU progressive rendering only; true refuses raster, GPU and fixed CPU requests. Omission preserves legacy admission/submission. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy requires fixed sampling; certified smooth thin-sheet/box dielectrics support fixed or progressive sampling under the same certificates and bounded optical transport. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption. nested_media?: false is the existing JobOptions opt-in; fixed or progressive CPU images admit only strictly nested certified closed_box boundaries with an exterior camera, while touching/partial overlaps, sheets within volumes and clearcoat combinations refuse. Other nondefault JobOptions remain unsupported on CPU; progressive/Interactive optics retain primary_samples:1 and selected reflections.samples:1 limits and never drop unsupported intent. GPU progressive uses the same nested_media field with its own certified-media contract; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/
Line truncated
|
||||
CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image")
|
||||
.params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"),
|
||||
CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only()
|
||||
.params("job: {session, serial, generation}. Non-blocking progress, error, optional CPU preview metadata {frame_sequence,samples_per_pixel,frame}, and completed frame metadata, optional sampling allocation/work counts and retained-master presentation provenance; no image bytes and no rendering in this call. Preview is separate from the exportable final image."),
|
||||
CommandSpec::new("render.cancel", "Cancel Render", jobs::cancel).icon("delete").noundo().doc_only()
|
||||
.params("job: {session, serial, generation}. Requests cooperative cancellation; completed jobs remain completed. Late cancelled frames cannot be published."),
|
||||
CommandSpec::new("render.result.copy", "Copy Render Image", jobs::copy).icon("copy").noundo().doc_only()
|
||||
.params("job: completed JobId. Validates the retained PNG for app clipboard copying (max 4096 per side, 4194304 pixels); headless returns frame metadata only. Never copies a provisional image or starts a job."),
|
||||
CommandSpec::new("render.export", "Export Render Image", jobs::export).icon("export").noundo().doc_only()
|
||||
.params("job: {session, serial, generation}, path: destination matching format?: png (default) or exr, overwrite?: false. EXR requires an opt-in raw linear master retained by that completed GPU job; never converts PNG pixels. Exports a retained completed image atomically; an existing destination is preserved on failure. See docs/render-jobs.md"),
|
||||
CommandSpec::new("render.backends", "Render Backends", backends).icon("list")
|
||||
.noundo()
|
||||
.doc_only()
|
||||
.params("No parameters. Returns {schema_version: 1, default_backend: builtin, backends: [{id, label, availability, executors: [{id, availability, profiles, limits, scratch}]}]}. Metadata only; does not start rendering or probe a GPU. See docs/render-backends.md"),
|
||||
CommandSpec::new("render.settings.get", "Render Settings", get_settings).icon("settings").noundo().doc_only()
|
||||
.params("name?: saved setup. Without name returns {setups, defaults}; with name returns {name, setup}. Does not evaluate the model or apply a camera. See docs/render-settings.md"),
|
||||
CommandSpec::new("render.settings.set", "Save Render Settings", set_settings).icon("settings").doc_only()
|
||||
.params("name: setup name, set: object of fields to replace (backend, mode, camera, width, height, format, exposure_ev, environment_rotation, environment_intensity, background, job, surfaces, stage). job?: typed active raster/cpu_raytrace/gpu_path configuration with optional validated embedded HDR reference; omitted preserves, null clears, object replaces the complete job. Creates from defaults and saves without a host, validates atomically, one undo step; identical edits are no-ops. See docs/render-settings.md"),
|
||||
CommandSpec::new("render.scene", "Inspect Render Scene", scene).noundo().at("RENDER", "SCENE").icon("render_scene")
|
||||
.params("No parameters. Authoritative product-scene metadata, without modelling overlays or mesh payloads. Explicitly settles stale geometry; does not render an image. See docs/render-workspace.md"),
|
||||
CommandSpec::new("render.settings.apply", "Apply Render Camera", apply_settings).icon("camera").noundo().doc_only()
|
||||
.params("name: saved setup. Applies its existing Camera snapshot including roll/up as view state, without modifying the document or starting a render."),
|
||||
];
|
||||
|
||||
fn set_camera(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
let cmd = "render.camera.set";
|
||||
if !params.as_object().is_some_and(|p| p.len() == 1 && p.contains_key("camera")) {
|
||||
return Err(bad(cmd, "expected exactly one camera snapshot"));
|
||||
}
|
||||
// Reuse strict saved-camera decoding and its numeric limits, without saving a setup.
|
||||
let setup: RenderSetup = serde_json::from_value(params.clone()).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
setup.validate().map_err(|e| bad(cmd, e.to_string()))?;
|
||||
s.camera = Some(setup.camera);
|
||||
Ok(json!({"camera":setup.camera,"document_changed":false}))
|
||||
}
|
||||
|
||||
fn get_camera(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
if !params.as_object().is_some_and(|p| p.is_empty()) {
|
||||
return Err(bad("render.camera.get", "expected an empty parameter object"));
|
||||
}
|
||||
Ok(json!({"camera":s.camera,"explicit_view":s.camera.is_some(),"document_changed":false}))
|
||||
}
|
||||
|
||||
fn fit_camera(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
if !params.as_object().is_some_and(|p| p.is_empty()) {
|
||||
return Err(bad("render.camera.fit", "expected an empty parameter object"));
|
||||
}
|
||||
let scene = crate::product_scene::extract(s)?;
|
||||
let mut camera = s.camera.unwrap_or_default();
|
||||
if !scene.bounds.is_empty() {
|
||||
camera.fit(&scene.bounds);
|
||||
}
|
||||
s.camera = Some(camera);
|
||||
Ok(json!({"camera":camera,"empty":scene.bounds.is_empty(),"document_changed":false}))
|
||||
}
|
||||
|
||||
fn scene(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
if !params.as_object().is_some_and(|p| p.is_empty()) {
|
||||
return Err(bad("render.scene", "expected an empty parameter object"));
|
||||
}
|
||||
let scene = crate::product_scene::extract(s)?;
|
||||
let mut stable = std::collections::BTreeMap::new();
|
||||
for (target, name) in surface_bindings::targets(s, "render.scene")? {
|
||||
if stable.insert(name, target).is_some() {
|
||||
return Err(bad("render.scene", "ambiguous stable occurrence name"));
|
||||
}
|
||||
}
|
||||
let bodies: Vec<_> = scene
|
||||
.meshes
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(ordinal,m)| json!({"ordinal":ordinal,"name":m.name,"stable_target":stable.get(&m.name),"triangles":m.mesh.triangles.len(),"color":m.color,"opacity":m.opacity,"face_appearances":m.faces.len(),"bounds":{"min":m.mesh.bounds().min,"max":m.mesh.bounds().max}}))
|
||||
.collect();
|
||||
Ok(
|
||||
json!({"bodies":bodies,"bounds":if scene.bounds.is_empty() { Value::Null } else { json!({"min":scene.bounds.min,"max":scene.bounds.max}) },"overlays":false}),
|
||||
)
|
||||
}
|
||||
|
||||
fn apply_settings(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
let request: GetSettings = serde_json::from_value(params.clone()).map_err(|e| bad("render.settings.apply", e.to_string()))?;
|
||||
let name = request.name.ok_or_else(|| bad("render.settings.apply", "`name` is required"))?;
|
||||
RenderSettings::validate_name(&name).map_err(|e| bad("render.settings.apply", e.to_string()))?;
|
||||
let setup = s.doc.render.setups.get(&name).ok_or_else(|| bad("render.settings.apply", "no saved render setup with that name"))?;
|
||||
setup.validate().map_err(|e| bad("render.settings.apply", e.to_string()))?;
|
||||
s.camera = Some(setup.camera);
|
||||
Ok(json!({"name":name,"camera":setup.camera}))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct GetSettings {
|
||||
name: Option<String>,
|
||||
}
|
||||
|
||||
fn get_settings(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
let cmd = "render.settings.get";
|
||||
let request: GetSettings = serde_json::from_value(params.clone()).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
match request.name {
|
||||
None => Ok(json!({"setups": s.doc.render.setups, "defaults": RenderSetup::default()})),
|
||||
Some(name) => {
|
||||
RenderSettings::validate_name(&name).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
let setup = s.doc.render.setups.get(&name).ok_or_else(|| bad(cmd, "no saved render setup with that name"))?;
|
||||
Ok(json!({"name": name, "setup": setup}))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct SetSettings {
|
||||
name: String,
|
||||
set: Value,
|
||||
}
|
||||
|
||||
fn set_settings(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
let cmd = "render.settings.set";
|
||||
if let Some(set) = params.get("set") {
|
||||
validate_saved_raster_lights(set, cmd)?;
|
||||
}
|
||||
let request: SetSettings = serde_json::from_value(params.clone()).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
let setup = patched_settings(s, &request.name, &request.set, cmd)?;
|
||||
let reply = json!({"name": request.name, "setup": setup});
|
||||
if s.doc.render.setups.get(&request.name) == Some(&setup) {
|
||||
return Ok(reply);
|
||||
}
|
||||
let mut settings = (*s.doc.render).clone();
|
||||
settings.setups.insert(request.name, setup);
|
||||
settings.validate().map_err(|e| bad(cmd, e.to_string()))?;
|
||||
s.doc_mut().render = Arc::new(settings);
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
fn patched_settings(s: &Session, name: &str, set: &Value, cmd: &str) -> Result<RenderSetup> {
|
||||
validate_saved_raster_lights(set, cmd)?;
|
||||
RenderSettings::validate_name(name).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
let patch = set.as_object().filter(|p| p.len() <= 13).ok_or_else(|| bad(cmd, "`set` must be an object with at most 13 fields"))?;
|
||||
if let Some(current) = s.doc.render.setups.get(name)
|
||||
&& let Some(solidcraft_doc::render_settings::RenderJob::Raster { lights, .. }) = ¤t.job
|
||||
{
|
||||
solidcraft_render::job::validate_raster_lights(lights).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
}
|
||||
let current = s.doc.render.setups.get(name).cloned().unwrap_or_default();
|
||||
let mut value = serde_json::to_value(¤t).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
let object = value.as_object_mut().ok_or_else(|| bad(cmd, "invalid render setup"))?;
|
||||
for (key, value) in patch {
|
||||
object.insert(key.clone(), value.clone());
|
||||
}
|
||||
let setup: RenderSetup = serde_json::from_value(value).map_err(|e| bad(cmd, e.to_string()))?;
|
||||
setup.validate().map_err(|e| bad(cmd, e.to_string()))?;
|
||||
Ok(setup)
|
||||
}
|
||||
|
||||
/// The new saved array is checked by reference before raw Value patch copies.
|
||||
fn validate_saved_raster_lights(settings: &Value, command: &str) -> Result<()> {
|
||||
if let Some(lights) = settings.get("job").and_then(|job| job.get("lights")) {
|
||||
let _ = solidcraft_render::job::deserialize_raster_lights(lights).map_err(|e| bad(command, e.to_string()))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn backends(s: &mut Session, params: &Value) -> Result<Value> {
|
||||
if !params.as_object().is_some_and(|p| p.is_empty()) {
|
||||
return Err(bad("render.backends", "expected an empty parameter object"));
|
||||
}
|
||||
Ok(json!({"schema_version": 1, "default_backend": "builtin", "backends": [s.render_backend()],
|
||||
"cpu_resource_profiles": solidcraft_render::job::CpuBudget::ALL.map(|budget| json!({"id":budget,"limits":budget.limits()}))}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::Arc;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn assert_unchanged(s: &mut Session, params: Value) -> Result<Value> {
|
||||
let doc = s.doc.clone();
|
||||
let before = (s.is_dirty(), s.revision, s.evaluations, s.model.is_stale());
|
||||
let camera = s.camera;
|
||||
let undo = s.undo.clone();
|
||||
let redo = s.redo.clone();
|
||||
let result = s.execute("render.backends", ¶ms);
|
||||
assert!(Arc::ptr_eq(&doc, &s.doc));
|
||||
assert_eq!(before, (s.is_dirty(), s.revision, s.evaluations, s.model.is_stale()));
|
||||
assert_eq!(camera, s.camera);
|
||||
for (before, after) in [(&undo, &s.undo), (&redo, &s.redo)] {
|
||||
assert_eq!(before.len(), after.len());
|
||||
for (a, b) in before.iter().zip(after.iter()) {
|
||||
assert!(Arc::ptr_eq(&a.doc, &b.doc));
|
||||
assert_eq!((&a.label, a.active_sketch, &a.pending_moves), (&b.label, b.active_sketch, &b.pending_moves));
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discovery_preserves_clean_dirty_and_undo_redo_state() {
|
||||
let mut s = Session::default();
|
||||
let r = assert_unchanged(&mut s, Value::Null).unwrap();
|
||||
assert_eq!(r["schema_version"], 1);
|
||||
assert_eq!(r["default_backend"], "builtin");
|
||||
assert_eq!(r["backends"].as_array().unwrap().len(), 1);
|
||||
let descriptor: crate::render::BackendDescriptor = serde_json::from_value(r["backends"][0].clone()).unwrap();
|
||||
assert_eq!(descriptor, crate::render::builtin_backend());
|
||||
s.execute("solid.box", &json!({"length": 10, "width": 20, "height": 5})).unwrap();
|
||||
s.execute("view.apply", &json!({"view": "top"})).unwrap();
|
||||
assert!(s.is_dirty());
|
||||
assert_unchanged(&mut s, json!({})).unwrap();
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert!(!s.redo.is_empty());
|
||||
assert_unchanged(&mut s, json!({})).unwrap();
|
||||
for p in [json!([]), json!(3), json!({"backend": "missing"}), json!({"width": "bad"})] {
|
||||
assert!(assert_unchanged(&mut s, p).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cooperative_host_never_discovers_cpu_raytracing_or_accepts_its_reserved_viewport_id() {
|
||||
use solidcraft_render::job::CpuHost;
|
||||
let mut s = Session::default();
|
||||
s.set_render_job_host(Some(CpuHost::cooperative())).unwrap();
|
||||
let reply = assert_unchanged(&mut s, json!({})).unwrap();
|
||||
let backend: solidcraft_render::BackendDescriptor = serde_json::from_value(reply["backends"][0].clone()).unwrap();
|
||||
assert!(backend.executors.iter().any(|d| d.id.as_str() == "cpu-product"));
|
||||
assert!(!backend.executors.iter().any(|d| d.id.as_str() == "cpu-raytrace"));
|
||||
let mut viewport = CpuHost::cooperative().descriptor().unwrap();
|
||||
viewport.id = solidcraft_render::ExecutorId::new("cpu-raytrace").unwrap();
|
||||
viewport.profiles[0].operation = solidcraft_render::RenderOperation::Viewport;
|
||||
viewport.profiles[0].formats.clear();
|
||||
assert!(s.set_render_viewport(Some(viewport)).unwrap_err().to_string().contains("reserved"));
|
||||
assert_eq!(s.render_backend(), backend);
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
#[test]
|
||||
fn native_cpu_discovery_matches_installed_features_and_preserves_raster_default() {
|
||||
use solidcraft_render::job::{CpuHost, Integrator};
|
||||
use solidcraft_render::{RenderFeature, RenderFormat, RenderMode, RenderOperation, RenderRequest};
|
||||
let host = CpuHost::for_platform().unwrap();
|
||||
// Query the host so the same test covers feature-off builds and workspace
|
||||
// feature unification without assuming the engine's own cfg is sufficient.
|
||||
let raytrace = host.validate_integrator(Integrator::Raytrace).is_ok();
|
||||
let mut s = Session::default();
|
||||
let doc = s.doc.clone();
|
||||
s.set_render_job_host(Some(host.clone())).unwrap();
|
||||
let reply = assert_unchanged(&mut s, json!({})).unwrap();
|
||||
assert!(Arc::ptr_eq(&doc, &s.doc));
|
||||
assert!(!s.is_dirty());
|
||||
assert!(s.undo.is_empty());
|
||||
let backend: solidcraft_render::BackendDescriptor = serde_json::from_value(reply["backends"][0].clone()).unwrap();
|
||||
let descriptors: Vec<_> = backend.executors.iter().filter(|d| d.id.as_str() == "cpu-raytrace").collect();
|
||||
assert_eq!(descriptors.len(), usize::from(raytrace));
|
||||
if let Some(descriptor) = descriptors.first() {
|
||||
assert_eq!(descriptor.availability, solidcraft_render::Availability::Available);
|
||||
assert_eq!(*descriptor, &host.descriptor_for(Integrator::Raytrace).unwrap());
|
||||
assert!(!descriptor.profiles.iter().any(|p| p.features.contains(&RenderFeature::Progressive)));
|
||||
}
|
||||
let request = RenderRequest {
|
||||
backend: None,
|
||||
mode: RenderMode::Preview,
|
||||
operation: RenderOperation::Image,
|
||||
width: 16,
|
||||
height: 16,
|
||||
format: Some(RenderFormat::Png),
|
||||
features: vec![RenderFeature::Pbr],
|
||||
policy: Default::default(),
|
||||
};
|
||||
assert_eq!(solidcraft_render::resolve_request(std::slice::from_ref(&backend), &request).unwrap().executor.as_str(), "cpu-product");
|
||||
assert_eq!(s.scratch().render_backend(), backend);
|
||||
s.set_render_job_host(Some(host)).unwrap();
|
||||
assert_eq!(s.render_backend(), backend, "reinstalling the same host cannot duplicate method descriptors");
|
||||
s.set_render_job_host(Some(CpuHost::cooperative())).unwrap();
|
||||
assert!(!s.render_backend().executors.iter().any(|d| d.id.as_str() == "cpu-raytrace"));
|
||||
s.set_render_job_host(None).unwrap();
|
||||
assert_eq!(s.render_backend(), solidcraft_render::builtin_backend());
|
||||
assert_unchanged(&mut s, json!({})).unwrap();
|
||||
assert!(Arc::ptr_eq(&doc, &s.doc));
|
||||
assert!(!s.is_dirty());
|
||||
assert!(s.undo.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discovery_does_not_settle_a_live_drag_or_rebuild_geometry() {
|
||||
let mut s = Session::default();
|
||||
for (id, p) in [
|
||||
("sketch.create", json!({"plane": "XY"})),
|
||||
("sketch.rectangle.two_point", json!({"p0": [5, 5], "p1": [25, 20]})),
|
||||
("sketch.dimension", json!({"entities": ["l1"], "value": 20})),
|
||||
("sketch.dimension", json!({"entities": ["l2"], "value": 15})),
|
||||
("sketch.finish", json!({})),
|
||||
("solid.extrude", json!({"distance": 5})),
|
||||
("sketch.edit", json!({"sketch": "Sketch1"})),
|
||||
("sketch.drag", json!({"entity": "l1.start", "from": [5, 5], "to": [4, 5], "live": true})),
|
||||
] {
|
||||
s.execute(id, &p).unwrap();
|
||||
}
|
||||
assert!(s.model.is_stale());
|
||||
s.evaluations = 0;
|
||||
let model = s.model.state();
|
||||
assert_unchanged(&mut s, json!({})).unwrap();
|
||||
assert_unchanged(&mut s, json!({"unexpected": true})).unwrap_err();
|
||||
assert!(Arc::ptr_eq(&model, &s.model.state()));
|
||||
assert_eq!(s.evaluations, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod settings_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod job_tests;
|
||||
|
||||
pub(super) fn prepare_interactive(s: &crate::Session, params: &serde_json::Value) -> crate::Result<crate::render_interactive::Prepared> {
|
||||
jobs::interactive(s, params)
|
||||
}
|
||||
+1622
File diff suppressed because it is too large.
Load diff
+861
@@ -0,0 +1,861 @@
|
||||
//! Per-document, transient render ownership. Captured scenes remain immutable when CAD edits
|
||||
//! continue; callers get the captured revision and must never present it as a newer scene.
|
||||
|
||||
use crate::render_interactive::{Controller, InteractiveRender, with_controller};
|
||||
use solidcraft_render::{
|
||||
ExecutorDescriptor,
|
||||
job::{CpuHost, ErrorCode, HostKind, Integrator, JobError, JobHandle, JobId, JobStatus, Phase, RenderFrame},
|
||||
};
|
||||
use std::collections::VecDeque;
|
||||
use std::sync::{
|
||||
Arc, Weak,
|
||||
atomic::{AtomicU64, Ordering},
|
||||
};
|
||||
|
||||
static NEXT_OWNER: AtomicU64 = AtomicU64::new(1);
|
||||
|
||||
/// The native CPU worker has two explicit execution methods. This pure metadata
|
||||
/// lookup neither creates a host nor enables raytracing in cooperative/feature-off builds.
|
||||
/// A stopped native host keeps its descriptor, marked unavailable by the host.
|
||||
pub(crate) fn cpu_raytrace_descriptor(host: Option<&CpuHost>) -> Option<ExecutorDescriptor> {
|
||||
let host = host.filter(|host| host.kind() == HostKind::NativeWorker)?;
|
||||
host.descriptor_for(Integrator::Raytrace).ok()
|
||||
}
|
||||
|
||||
fn owner() -> u64 {
|
||||
let mut n = NEXT_OWNER.load(Ordering::Relaxed);
|
||||
loop {
|
||||
let Some(next) = n.checked_add(1) else { return 0 };
|
||||
match NEXT_OWNER.compare_exchange_weak(n, next, Ordering::Relaxed, Ordering::Relaxed) {
|
||||
Ok(_) => return n,
|
||||
Err(current) => n = current,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct Execution {
|
||||
pub executor: solidcraft_render::ExecutorId,
|
||||
pub options: solidcraft_render::job::JobOptions,
|
||||
pub environment: Option<solidcraft_render::lighting::environment_input::EnvironmentInput>,
|
||||
}
|
||||
|
||||
pub(crate) struct Jobs {
|
||||
owner: u64,
|
||||
serial: u64,
|
||||
generation: u64,
|
||||
pub(crate) host: Option<CpuHost>,
|
||||
pub(crate) descriptor: Option<ExecutorDescriptor>,
|
||||
pub(crate) additional: Vec<(CpuHost, ExecutorDescriptor)>,
|
||||
live: Vec<JobHandle>,
|
||||
history: VecDeque<JobStatus>,
|
||||
last_good: Option<JobHandle>,
|
||||
/// One explicitly displayed completed result, independent of a newer completion.
|
||||
/// The existing frame Arc keeps its original host reservation accounted for.
|
||||
pinned: Option<JobHandle>,
|
||||
/// Preview lifetime only; it never joins final live/history/export ownership.
|
||||
interactive: Weak<Controller>,
|
||||
}
|
||||
|
||||
impl Default for Jobs {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
owner: owner(),
|
||||
serial: 0,
|
||||
generation: 0,
|
||||
host: None,
|
||||
descriptor: None,
|
||||
additional: Vec::new(),
|
||||
live: Vec::new(),
|
||||
history: VecDeque::new(),
|
||||
last_good: None,
|
||||
pinned: None,
|
||||
interactive: Weak::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Jobs {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.revoke_interactive();
|
||||
for job in &self.live {
|
||||
let _ = job.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Jobs {
|
||||
pub(crate) fn is_interactive_current(&self, controller: &Weak<Controller>) -> bool {
|
||||
Weak::ptr_eq(&self.interactive, controller)
|
||||
}
|
||||
|
||||
fn revoke_interactive(&mut self) -> Result<(), JobError> {
|
||||
let previous = std::mem::take(&mut self.interactive);
|
||||
match previous.upgrade() {
|
||||
Some(controller) => with_controller(&controller, |state| state.disable()),
|
||||
None => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
fn suspend_interactive(&self) -> Result<(), JobError> {
|
||||
match self.interactive.upgrade() {
|
||||
Some(controller) => with_controller(&controller, |state| state.set_final_active(true, std::time::Duration::ZERO)),
|
||||
None => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
fn final_active(&self) -> Result<bool, JobError> {
|
||||
for job in &self.live {
|
||||
if !job.status()?.progress.phase.terminal() {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
fn create_interactive(&mut self, document_uid: u64) -> Result<InteractiveRender, JobError> {
|
||||
let host = self.host.as_ref().ok_or_else(|| JobError::new(ErrorCode::HostUnavailable, "no CPU image host is installed"))?;
|
||||
if !host.is_available() || host.kind() != HostKind::NativeWorker {
|
||||
return Err(JobError::new(ErrorCode::HostUnavailable, "Interactive CPU requires an available native CPU host"));
|
||||
}
|
||||
host.validate_integrator(Integrator::Raytrace)?;
|
||||
let final_active = self.final_active()?;
|
||||
if document_uid == 0 || self.owner == 0 {
|
||||
return Err(JobError::new(ErrorCode::LimitExceeded, "render session identity exhausted"));
|
||||
}
|
||||
// Use the same allocator as final owners; never reuse the document uid or
|
||||
// scratch owner as a preview namespace. Zero reports allocator exhaustion.
|
||||
let preview_session = owner();
|
||||
if preview_session == 0 {
|
||||
return Err(JobError::new(ErrorCode::LimitExceeded, "Interactive owner identity exhausted"));
|
||||
}
|
||||
let next = InteractiveRender::new(document_uid, preview_session, final_active)?;
|
||||
self.revoke_interactive()?;
|
||||
self.interactive = next.weak();
|
||||
Ok(next)
|
||||
}
|
||||
|
||||
pub(crate) fn host_for(&self, executor: &solidcraft_render::ExecutorId) -> Option<&CpuHost> {
|
||||
if executor.as_str() == "cpu-raytrace" {
|
||||
return self
|
||||
.host
|
||||
.as_ref()
|
||||
.filter(|host| host.descriptor_for(solidcraft_render::job::Integrator::Raytrace).is_ok_and(|d| &d.id == executor));
|
||||
}
|
||||
if self.descriptor.as_ref().is_some_and(|d| &d.id == executor) {
|
||||
return self.host.as_ref();
|
||||
}
|
||||
self.additional.iter().find(|(_, d)| &d.id == executor).map(|(host, _)| host)
|
||||
}
|
||||
|
||||
pub(crate) fn scratch(&self) -> Self {
|
||||
let mut jobs = Self::default();
|
||||
jobs.host = self.host.clone();
|
||||
jobs.descriptor = self.descriptor.clone();
|
||||
jobs.additional = self.additional.clone();
|
||||
jobs
|
||||
}
|
||||
|
||||
pub(crate) fn collect(&mut self) -> Result<(), JobError> {
|
||||
let mut i = 0;
|
||||
while i < self.live.len() {
|
||||
let status = self.live.get(i).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing live job"))?.status()?;
|
||||
if !status.progress.phase.terminal() {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
let handle = self.live.remove(i);
|
||||
if status.progress.phase == Phase::Completed && self.last_good.as_ref().is_none_or(|old| old.id().serial < handle.id().serial) {
|
||||
self.last_good = Some(handle);
|
||||
}
|
||||
self.history.push_back(status);
|
||||
while self.history.len() > 4 {
|
||||
self.history.pop_front();
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn start_with_environment(
|
||||
&mut self,
|
||||
revision: u64,
|
||||
scene: solidcraft_render::ProductScene,
|
||||
request: solidcraft_render::job::ImageRequest,
|
||||
replace: bool,
|
||||
execution: Execution,
|
||||
) -> Result<JobStatus, JobError> {
|
||||
self.start_with_environment_and_feedback(revision, scene, request, replace, execution, false)
|
||||
}
|
||||
|
||||
pub(crate) fn start_with_environment_and_feedback(
|
||||
&mut self,
|
||||
revision: u64,
|
||||
scene: solidcraft_render::ProductScene,
|
||||
request: solidcraft_render::job::ImageRequest,
|
||||
replace: bool,
|
||||
execution: Execution,
|
||||
progressive_feedback: bool,
|
||||
) -> Result<JobStatus, JobError> {
|
||||
if progressive_feedback
|
||||
&& (request.integrator != Integrator::Raytrace || request.raytrace.as_ref().and_then(|options| options.progressive).is_none())
|
||||
{
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "progressive_feedback requires CPU progressive raytracing"));
|
||||
}
|
||||
let Execution { executor, options, environment } = execution;
|
||||
self.collect()?;
|
||||
let host = self.host_for(&executor).ok_or_else(|| JobError::new(ErrorCode::HostUnavailable, "resolved image host is not installed"))?.clone();
|
||||
if replace {
|
||||
for job in self.live.drain(..) {
|
||||
let mut status = job.cancel()?;
|
||||
// Replaced handles are deliberately abandoned: keep a cancellation tombstone,
|
||||
// not a permanently "cancelling" snapshot. The token already prevents any
|
||||
// publication; the host can finish releasing its buffers asynchronously.
|
||||
if !status.progress.phase.terminal() {
|
||||
status.progress.phase = Phase::Cancelled;
|
||||
}
|
||||
self.history.push_back(status);
|
||||
}
|
||||
while self.history.len() > 4 {
|
||||
self.history.pop_front();
|
||||
}
|
||||
}
|
||||
if self.live.len() >= 2 {
|
||||
return Err(JobError::new(ErrorCode::QueueFull, "this document already has an active and pending render"));
|
||||
}
|
||||
if self.owner == 0 {
|
||||
return Err(JobError::new(ErrorCode::LimitExceeded, "render session identity exhausted"));
|
||||
}
|
||||
let serial = self.serial.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render job identity exhausted"))?;
|
||||
let generation = self.generation.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render generation exhausted"))?;
|
||||
self.suspend_interactive()?;
|
||||
let id = JobId { session: self.owner, serial, generation };
|
||||
let handle = if progressive_feedback {
|
||||
host.submit_cpu_protected_partial_with_environment_and_options(id, revision, scene, request, options, environment)?
|
||||
} else {
|
||||
host.submit_with_environment_and_options(id, revision, scene, request, options, environment)?
|
||||
};
|
||||
let status = handle.status()?;
|
||||
self.serial = serial;
|
||||
self.generation = generation;
|
||||
self.live.push(handle);
|
||||
Ok(status)
|
||||
}
|
||||
|
||||
pub(crate) fn regrade(
|
||||
&mut self,
|
||||
source_id: JobId,
|
||||
presentation: solidcraft_render::job::presentation::Presentation,
|
||||
) -> Result<JobStatus, JobError> {
|
||||
presentation.validate()?;
|
||||
self.collect()?;
|
||||
let source = self.handle(source_id)?;
|
||||
let frame = source.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "regrade requires a completed frame"))?;
|
||||
let master = frame.master_source()?;
|
||||
// Prefer the source pool so its retained source and derivative work share
|
||||
// one admission authority. Regrading itself never invokes its executor.
|
||||
let host = self
|
||||
.host_for(&master.info.executor)
|
||||
.or(self.host.as_ref())
|
||||
.ok_or_else(|| JobError::new(ErrorCode::HostUnavailable, "no image host is installed for master presentation"))?
|
||||
.clone();
|
||||
if self.live.len() >= 2 {
|
||||
return Err(JobError::new(ErrorCode::QueueFull, "this document already has an active and pending render"));
|
||||
}
|
||||
let serial = self.serial.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render job identity exhausted"))?;
|
||||
let generation = self.generation.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render generation exhausted"))?;
|
||||
if self.owner == 0 {
|
||||
return Err(JobError::new(ErrorCode::LimitExceeded, "render session identity exhausted"));
|
||||
}
|
||||
self.suspend_interactive()?;
|
||||
let handle = host.submit_regrade(JobId { session: self.owner, serial, generation }, &source, presentation)?;
|
||||
let status = handle.status()?;
|
||||
self.serial = serial;
|
||||
self.generation = generation;
|
||||
self.live.push(handle);
|
||||
Ok(status)
|
||||
}
|
||||
|
||||
fn check_owner(&self, id: JobId) -> Result<(), JobError> {
|
||||
if id.session != self.owner {
|
||||
return Err(JobError::new(ErrorCode::WrongOwner, "render job belongs to another document session"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn handle(&self, id: JobId) -> Result<JobHandle, JobError> {
|
||||
self.check_owner(id)?;
|
||||
self.live
|
||||
.iter()
|
||||
.chain(self.last_good.iter())
|
||||
.chain(self.pinned.iter())
|
||||
.find(|j| j.id() == id)
|
||||
.cloned()
|
||||
.ok_or_else(|| JobError::new(ErrorCode::UnknownJob, "render job is no longer retained"))
|
||||
}
|
||||
|
||||
pub(crate) fn status(&mut self, id: JobId) -> Result<JobStatus, JobError> {
|
||||
self.check_owner(id)?;
|
||||
self.collect()?;
|
||||
if let Ok(handle) = self.handle(id) {
|
||||
return handle.status();
|
||||
}
|
||||
self.history.iter().find(|s| s.job == id).cloned().ok_or_else(|| JobError::new(ErrorCode::UnknownJob, "render job is no longer retained"))
|
||||
}
|
||||
|
||||
pub(crate) fn pin(&mut self, id: Option<JobId>) -> Result<Option<solidcraft_render::job::FrameInfo>, JobError> {
|
||||
let Some(id) = id else {
|
||||
self.pinned = None;
|
||||
return Ok(None);
|
||||
};
|
||||
let handle = self.handle(id)?;
|
||||
let frame = handle.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "only a completed result can be pinned"))?;
|
||||
let info = frame.info.clone();
|
||||
self.pinned = Some(handle);
|
||||
Ok(Some(info))
|
||||
}
|
||||
|
||||
pub(crate) fn frame(&mut self, id: JobId) -> Result<Arc<RenderFrame>, JobError> {
|
||||
self.collect()?;
|
||||
self.handle(id)?.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "render has no completed image"))
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Session {
|
||||
/// Explicit activation support. The caller owns one app-wide capture worker.
|
||||
/// This registers a lifetime only; it never captures or starts an image.
|
||||
pub fn interactive_render(&mut self) -> crate::Result<InteractiveRender> {
|
||||
self.render_jobs.create_interactive(self.uid).map_err(job_error)
|
||||
}
|
||||
|
||||
/// Bounded final-job metadata for current/background document scheduling.
|
||||
/// Retained completed images do not block Interactive; unknown status fails.
|
||||
pub fn render_final_active(&self) -> crate::Result<bool> {
|
||||
self.render_jobs.final_active().map_err(job_error)
|
||||
}
|
||||
|
||||
/// A host is installed by the application, never by document data or a command.
|
||||
pub fn set_render_job_host(&mut self, host: Option<CpuHost>) -> crate::Result<()> {
|
||||
if self.render_jobs.host.as_ref().zip(host.as_ref()).is_some_and(|(a, b)| a.same_host(b)) {
|
||||
return Ok(());
|
||||
}
|
||||
let descriptor = host.as_ref().map(CpuHost::descriptor).transpose().map_err(job_error)?;
|
||||
if descriptor.as_ref().is_some_and(|d| d.id.as_str() == "cpu-raytrace") {
|
||||
return Err(crate::EngineError::Other("cpu-raytrace is reserved for the native CPU raytrace integrator".into()));
|
||||
}
|
||||
let previous_raytrace = cpu_raytrace_descriptor(self.render_jobs.host.as_ref());
|
||||
let mut backend = self.render_backend();
|
||||
backend.executors.retain(|e| {
|
||||
self.render_jobs.descriptor.as_ref().is_none_or(|old| old.id != e.id) && previous_raytrace.as_ref().is_none_or(|old| old.id != e.id)
|
||||
});
|
||||
if let Some(d) = &descriptor {
|
||||
backend.executors.push(d.clone());
|
||||
}
|
||||
if let Some(raytrace) = cpu_raytrace_descriptor(host.as_ref()) {
|
||||
backend.executors.push(raytrace);
|
||||
}
|
||||
solidcraft_render::resolve_request(
|
||||
&[backend],
|
||||
&solidcraft_render::RenderRequest {
|
||||
backend: None,
|
||||
mode: solidcraft_render::RenderMode::Preview,
|
||||
operation: solidcraft_render::RenderOperation::Image,
|
||||
width: 1,
|
||||
height: 1,
|
||||
format: Some(solidcraft_render::RenderFormat::Png),
|
||||
features: Vec::new(),
|
||||
policy: Default::default(),
|
||||
},
|
||||
)
|
||||
.map_err(|e| crate::EngineError::Other(e.to_string()))?;
|
||||
let mut jobs = Jobs::default();
|
||||
jobs.additional = self.render_jobs.additional.clone();
|
||||
jobs.host = host;
|
||||
jobs.descriptor = descriptor;
|
||||
self.render_jobs = jobs;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Add an executor without replacing CPU jobs or their ownership. Applications share
|
||||
/// this host across document sessions; descriptor IDs must be unique in the registry.
|
||||
pub fn register_render_job_host(&mut self, host: solidcraft_render::job::ImageHost) -> crate::Result<()> {
|
||||
let descriptor = host.descriptor().map_err(job_error)?;
|
||||
if descriptor.id.as_str() == "cpu-raytrace" {
|
||||
return Err(crate::EngineError::Other("cpu-raytrace is reserved for the native CPU raytrace integrator".into()));
|
||||
}
|
||||
if self.render_jobs.additional.iter().any(|(old, _)| old.same_host(&host)) {
|
||||
return Ok(());
|
||||
}
|
||||
if descriptor.profiles.iter().any(|p| p.operation != solidcraft_render::RenderOperation::Image) {
|
||||
return Err(crate::EngineError::Other("image host must only register image profiles".into()));
|
||||
}
|
||||
let mut registry = self.render_backend();
|
||||
registry.executors.push(descriptor.clone());
|
||||
solidcraft_render::resolve_request(
|
||||
&[registry],
|
||||
&solidcraft_render::RenderRequest {
|
||||
backend: None,
|
||||
mode: solidcraft_render::RenderMode::Preview,
|
||||
operation: solidcraft_render::RenderOperation::Image,
|
||||
width: 1,
|
||||
height: 1,
|
||||
format: Some(solidcraft_render::RenderFormat::Png),
|
||||
features: Vec::new(),
|
||||
policy: Default::default(),
|
||||
},
|
||||
)
|
||||
.map_err(|e| crate::EngineError::Other(e.to_string()))?;
|
||||
self.render_jobs.additional.push((host, descriptor));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn render_job_host(&self) -> Option<&CpuHost> {
|
||||
self.render_jobs.host.as_ref()
|
||||
}
|
||||
|
||||
/// Explicit native CLI waiting is separate from non-blocking status commands.
|
||||
pub fn render_job_handle(&self, id: JobId) -> crate::Result<JobHandle> {
|
||||
self.render_jobs.handle(id).map_err(job_error)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn job_error(error: JobError) -> crate::EngineError {
|
||||
crate::EngineError::Other(error.to_string())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod displayed_result_tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
fn complete(s: &mut crate::Session, color: [u8; 3]) -> JobId {
|
||||
let reply = s.execute("render.start", &json!({"settings":{"width":8,"height":8,"background":color}})).unwrap();
|
||||
let id: JobId = serde_json::from_value(reply["job"].clone()).unwrap();
|
||||
let host = s.render_job_host().unwrap().clone();
|
||||
for _ in 0..10000 {
|
||||
host.pump(16384).unwrap();
|
||||
if s.render_job_handle(id).unwrap().status().unwrap().progress.phase.terminal() {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
panic!("bounded result fixture did not finish")
|
||||
}
|
||||
#[test]
|
||||
fn explicit_display_pin_preserves_the_old_exact_frame_without_unbounded_history() {
|
||||
let mut s = crate::Session::default();
|
||||
let host = CpuHost::cooperative();
|
||||
s.set_render_job_host(Some(host.clone())).unwrap();
|
||||
let before = s.doc.to_json();
|
||||
let undo = s.undo.len();
|
||||
let old = complete(&mut s, [10, 20, 30]);
|
||||
let bytes = s.render_job_handle(old).unwrap().frame().unwrap().unwrap().png().to_vec();
|
||||
s.execute("render.result.pin", &json!({"job":old})).unwrap();
|
||||
for color in [[40, 50, 60], [70, 80, 90], [100, 110, 120], [130, 140, 150], [160, 170, 180]] {
|
||||
let new = complete(&mut s, color);
|
||||
s.execute("render.status", &json!({"job":new})).unwrap();
|
||||
assert_eq!(s.render_job_handle(old).unwrap().frame().unwrap().unwrap().png(), bytes);
|
||||
}
|
||||
let retained = host.admitted_bytes();
|
||||
let foreign = JobId { session: old.session + 1, ..old };
|
||||
assert!(s.execute("render.result.pin", &json!({"job":foreign})).is_err());
|
||||
assert_eq!(host.admitted_bytes(), retained);
|
||||
assert!(s.execute("render.result.pin", &json!({})).is_err());
|
||||
s.execute("render.result.pin", &json!({"job":null})).unwrap();
|
||||
assert!(s.render_job_handle(old).is_err());
|
||||
assert!(host.admitted_bytes() < retained);
|
||||
assert_eq!(s.doc.to_json(), before);
|
||||
assert_eq!(s.undo.len(), undo);
|
||||
let reply = s.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap();
|
||||
assert!(s.execute("render.result.pin", &json!({"job":reply["job"]})).is_err(), "a pending result is never exportable");
|
||||
}
|
||||
}
|
||||
|
||||
// Original context ownership and real capture integration cases.
|
||||
#[cfg(all(test, feature = "raytrace-cpu", not(target_arch = "wasm32")))]
|
||||
mod interactive_context_tests {
|
||||
use super::*;
|
||||
use crate::render_interactive::{InteractiveRender, Snapshot, adopt_created};
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_render::job::interactive::{State, VisualRevision};
|
||||
use std::time::Duration;
|
||||
|
||||
fn native() -> crate::Result<(crate::Session, CpuHost)> {
|
||||
let host = CpuHost::for_platform().map_err(job_error)?;
|
||||
let mut session = crate::Session::default();
|
||||
session.set_render_job_host(Some(host.clone()))?;
|
||||
Ok((session, host))
|
||||
}
|
||||
|
||||
fn wire(background: [u8; 3]) -> Value {
|
||||
json!({"integrator":"raytrace","settings":{"width":16,"height":16,"background":background},"raytrace":{"lights":[],"shadows":false}})
|
||||
}
|
||||
|
||||
fn capture(context: &InteractiveRender, session: &crate::Session, request: &Value) -> crate::Result<Snapshot> {
|
||||
context.enable(VisualRevision { scene_generation: session.revision, visual_revision: 1 }, Duration::ZERO)?;
|
||||
let ticket = context
|
||||
.capture(Duration::from_millis(200))?
|
||||
.ok_or_else(|| crate::EngineError::Other("interactive fixture did not produce a capture ticket".into()))?;
|
||||
context.snapshot(session, ticket, request)
|
||||
}
|
||||
|
||||
fn terminal(job: &JobHandle) -> crate::Result<Phase> {
|
||||
// Completion watchdog follows existing native job tests; no speed assertion.
|
||||
Ok(job.wait_timeout(Duration::from_secs(60)).map_err(job_error)?.progress.phase)
|
||||
}
|
||||
|
||||
fn created(session: &crate::Session, ticket: solidcraft_render::job::interactive::CaptureTicket, request: &Value) -> crate::Result<JobHandle> {
|
||||
let p = crate::cmd::prepare_interactive(session, request)?;
|
||||
session
|
||||
.render_job_host()
|
||||
.ok_or_else(|| crate::EngineError::Other("interactive fixture has no render job host".into()))?
|
||||
.submit_with_environment_and_options(ticket.job_id(), ticket.revision().scene_generation, p.scene, p.request, p.options, p.environment)
|
||||
.map_err(job_error)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registration_is_explicit_and_preview_frames_never_join_final_registry() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let document = session.doc.clone();
|
||||
let history = (session.revision, session.undo.len(), session.redo.len());
|
||||
let context = session.interactive_render().unwrap();
|
||||
assert_eq!(context.state().unwrap(), State::Off);
|
||||
assert!(context.is_current(&session));
|
||||
assert!(context.capture(Duration::from_secs(1)).unwrap().is_none());
|
||||
let snapshot = capture(&context, &session, &wire([31, 67, 101])).unwrap();
|
||||
let ticket = snapshot.ticket();
|
||||
assert_ne!(ticket.job_id().session, session.render_jobs.owner);
|
||||
assert_eq!(snapshot.document_uid(), session.uid);
|
||||
assert!(snapshot.run().unwrap());
|
||||
let preview = context.current().unwrap().unwrap();
|
||||
assert_eq!(terminal(&preview).unwrap(), Phase::Completed);
|
||||
assert!(preview.frame().unwrap().is_some());
|
||||
assert!(session.render_job_handle(preview.id()).is_err());
|
||||
assert!(session.execute("render.status", &json!({"job":preview.id()})).is_err());
|
||||
assert!(session.render_jobs.live.is_empty());
|
||||
assert!(session.render_jobs.last_good.is_none());
|
||||
assert!(session.render_jobs.pinned.is_none());
|
||||
assert_eq!(history, (session.revision, session.undo.len(), session.redo.len()));
|
||||
assert!(Arc::ptr_eq(&document, &session.doc));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_final_start_preempts_only_interactive_and_finishes() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let context = session.interactive_render().unwrap();
|
||||
assert!(capture(&context, &session, &wire([11, 29, 47])).unwrap().run().unwrap());
|
||||
let old = context.current().unwrap().unwrap();
|
||||
let reply = session.execute("render.start", &wire([83, 107, 139])).unwrap();
|
||||
let final_id: JobId = serde_json::from_value(reply["job"].clone()).unwrap();
|
||||
let final_job = session.render_job_handle(final_id).unwrap();
|
||||
assert_ne!(final_id.session, old.id().session);
|
||||
assert_eq!(context.state().unwrap(), State::Paused);
|
||||
assert!(context.current().unwrap().is_none());
|
||||
assert!(context.capture(Duration::from_secs(100)).unwrap().is_none());
|
||||
assert_eq!(terminal(&final_job).unwrap(), Phase::Completed);
|
||||
assert!(matches!(terminal(&old).unwrap(), Phase::Cancelled | Phase::Completed));
|
||||
assert!(!session.render_final_active().unwrap());
|
||||
let digest = final_job.frame().unwrap().unwrap().info.png_sha256.clone();
|
||||
context.disable().unwrap();
|
||||
drop(context);
|
||||
assert_eq!(session.render_job_handle(final_id).unwrap().frame().unwrap().unwrap().info.png_sha256, digest);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replacement_context_revokes_old_capture_without_meshing() {
|
||||
let (mut session, host) = native().unwrap();
|
||||
session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Source"})).unwrap();
|
||||
let world = session.world_state();
|
||||
assert!(world.body("Source").unwrap().cached_mesh().is_none());
|
||||
let old = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&old, &session, &wire([1, 2, 3])).unwrap();
|
||||
let old_owner = snapshot.ticket().job_id().session;
|
||||
let fresh = session.interactive_render().unwrap();
|
||||
assert!(!old.is_current(&session));
|
||||
assert_eq!(old.state().unwrap(), State::Off);
|
||||
assert_eq!(fresh.state().unwrap(), State::Off);
|
||||
assert!(!snapshot.run().unwrap());
|
||||
assert!(world.body("Source").unwrap().cached_mesh().is_none());
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
let next = capture(&fresh, &session, &wire([4, 5, 6])).unwrap();
|
||||
assert_ne!(next.ticket().job_id().session, old_owner);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn host_a_b_a_cannot_revive_old_registration_in_the_same_document() {
|
||||
let (mut session, host_a) = native().unwrap();
|
||||
let uid = session.uid;
|
||||
let old = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&old, &session, &wire([1, 2, 3])).unwrap();
|
||||
let host_b = CpuHost::for_platform().unwrap();
|
||||
session.set_render_job_host(Some(host_b)).unwrap();
|
||||
assert_eq!(session.uid, uid);
|
||||
assert!(!old.is_current(&session));
|
||||
assert_eq!(old.state().unwrap(), State::Off);
|
||||
assert!(!snapshot.run().unwrap());
|
||||
session.set_render_job_host(Some(host_a.clone())).unwrap();
|
||||
assert!(!old.is_current(&session));
|
||||
old.enable(VisualRevision { scene_generation: session.revision, visual_revision: 2 }, Duration::ZERO).unwrap();
|
||||
let stale = old.capture(Duration::from_millis(200)).unwrap().unwrap();
|
||||
assert!(old.snapshot(&session, stale, &wire([7, 8, 9])).is_err());
|
||||
assert_eq!(host_a.admitted_bytes(), 0);
|
||||
assert!(session.interactive_render().unwrap().is_current(&session));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_design_and_equal_revision_foreign_session_refuse_old_tickets() {
|
||||
let (mut session, host) = native().unwrap();
|
||||
let context = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap();
|
||||
let ticket = snapshot.ticket();
|
||||
let uid = session.uid;
|
||||
let mut foreign = crate::Session::new((*session.doc).clone());
|
||||
foreign.revision = session.revision;
|
||||
foreign.set_render_job_host(Some(host.clone())).unwrap();
|
||||
assert_ne!(foreign.uid, uid);
|
||||
assert!(!context.is_current(&foreign));
|
||||
assert!(context.snapshot(&foreign, ticket, &wire([4, 5, 6])).is_err());
|
||||
session.execute("file.new", &json!({})).unwrap();
|
||||
assert_ne!(session.uid, uid);
|
||||
assert!(!context.is_current(&session));
|
||||
assert_eq!(context.state().unwrap(), State::Off);
|
||||
assert!(!snapshot.run().unwrap());
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scratch_drop_does_not_revoke_source_and_exhaustion_is_local() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let context = session.interactive_render().unwrap();
|
||||
drop(session.scratch());
|
||||
assert!(context.is_current(&session));
|
||||
assert_eq!(context.state().unwrap(), State::Off);
|
||||
assert!(InteractiveRender::new(session.uid, 0, false).is_err());
|
||||
let original_owner = session.render_jobs.owner;
|
||||
session.render_jobs.owner = 0;
|
||||
assert!(session.interactive_render().is_err());
|
||||
assert!(context.is_current(&session));
|
||||
session.render_jobs.owner = original_owner;
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_adoption_with_poisoned_controller_cancels_unpumped_cooperative_record() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let context = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap();
|
||||
let ticket = snapshot.ticket();
|
||||
let p = crate::cmd::prepare_interactive(&session, &wire([1, 2, 3])).unwrap();
|
||||
let mut request = p.request;
|
||||
request.integrator = Integrator::Raster;
|
||||
request.raytrace = None;
|
||||
// A real cooperative queue cannot complete without an explicit pump.
|
||||
// Adoption checks owner, then the poisoned lifecycle before integrator.
|
||||
let cooperative = CpuHost::cooperative();
|
||||
let job = cooperative.submit(ticket.job_id(), ticket.revision().scene_generation, p.scene, request).unwrap();
|
||||
assert_eq!(job.status().unwrap().progress.phase, Phase::Queued);
|
||||
let controller = session.render_jobs.interactive.upgrade().unwrap();
|
||||
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||||
let _guard = controller.lock().unwrap();
|
||||
panic!("original poison fixture");
|
||||
}));
|
||||
assert!(adopt_created(&controller, ticket, job.clone()).is_err());
|
||||
assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
|
||||
assert!(context.current().is_err(), "a poisoned lifecycle is not resumed");
|
||||
// No pump, sleeps, synthetic executor or large scene is needed. Removing
|
||||
// Unadopted::drop cancellation leaves Queued and fails this assertion.
|
||||
// Only controller poison is tested; record.data poison is best-effort.
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_fresh_equal_id_record_preserves_retained_completed_frame() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let context = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&context, &session, &wire([17, 31, 59])).unwrap();
|
||||
let ticket = snapshot.ticket();
|
||||
assert!(snapshot.run().unwrap());
|
||||
let accepted = context.current().unwrap().unwrap();
|
||||
assert_eq!(terminal(&accepted).unwrap(), Phase::Completed);
|
||||
let frame = accepted.frame().unwrap().unwrap();
|
||||
let digest = frame.info.png_sha256.clone();
|
||||
let duplicate = created(&session, ticket, &wire([83, 107, 139])).unwrap();
|
||||
assert_eq!(duplicate.id(), accepted.id());
|
||||
let controller = session.render_jobs.interactive.upgrade().unwrap();
|
||||
assert!(!adopt_created(&controller, ticket, duplicate.clone()).unwrap());
|
||||
let phase = duplicate.status().unwrap().progress.phase;
|
||||
assert!(phase.terminal() || phase == Phase::Cancelling);
|
||||
assert!(matches!(terminal(&duplicate).unwrap(), Phase::Cancelled | Phase::Completed));
|
||||
let retained = context.current().unwrap().unwrap().frame().unwrap().unwrap();
|
||||
assert!(Arc::ptr_eq(&retained, &frame));
|
||||
assert_eq!(retained.info.png_sha256, digest);
|
||||
// This native fixture proves accepted-record retention only. Completed
|
||||
// duplicate work does not prove a cancellation request; core queued
|
||||
// distinct-record acceptance covers that separate invariant.
|
||||
assert_eq!(accepted.status().unwrap().request.background, [17, 31, 59]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dropping_context_before_worker_start_keeps_the_source_mesh_cold() {
|
||||
let (mut session, host) = native().unwrap();
|
||||
session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Source"})).unwrap();
|
||||
let world = session.world_state();
|
||||
assert!(world.body("Source").unwrap().cached_mesh().is_none());
|
||||
let context = session.interactive_render().unwrap();
|
||||
let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap();
|
||||
drop(context);
|
||||
assert!(!snapshot.run().unwrap());
|
||||
assert!(world.body("Source").unwrap().cached_mesh().is_none());
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
}
|
||||
#[test]
|
||||
fn final_cpu_feedback_preserves_full_request_owner_and_exact_final_pixels() {
|
||||
let (mut session, host) = native().unwrap();
|
||||
assert_eq!(host.kind(), HostKind::NativeWorker);
|
||||
let before = session.doc.to_json();
|
||||
let history = (session.revision, session.undo.len(), session.redo.len());
|
||||
let request = json!({
|
||||
"integrator":"raytrace", "settings":{"width":13,"height":7,"background":[17,89,203]},
|
||||
"raytrace":{"lights":[],"shadows":false,"primary_samples":1,"progressive":{"samples_per_pixel":9,"seed":83}}
|
||||
});
|
||||
let mut baseline: Option<Vec<u8>> = None;
|
||||
for feedback in [false, true] {
|
||||
let mut params = request.clone();
|
||||
params["progressive_feedback"] = json!(feedback);
|
||||
let checked = session.execute("render.preflight", ¶ms).unwrap();
|
||||
if feedback {
|
||||
let captured: solidcraft_render::job::ImageRequest = serde_json::from_value(checked["request"].clone()).unwrap();
|
||||
let scene = solidcraft_render::ProductScene { meshes: Vec::new(), bounds: solidcraft_geom::Aabb3::EMPTY };
|
||||
let admitted = host
|
||||
.admit_cpu_protected_partial_with_environment_and_options(&scene, &captured, solidcraft_render::job::JobOptions::default(), None)
|
||||
.unwrap();
|
||||
assert_eq!(checked["admission"], serde_json::to_value(admitted).unwrap(), "Check uses the same authoritative protected admission");
|
||||
}
|
||||
let started = session.execute("render.start", ¶ms).unwrap();
|
||||
let job: JobId = serde_json::from_value(started["job"].clone()).unwrap();
|
||||
assert_eq!(job.session, session.render_jobs.owner);
|
||||
let handle = session.render_job_handle(job).unwrap();
|
||||
assert_eq!(serde_json::to_value(handle.status().unwrap().request).unwrap(), checked["request"]);
|
||||
assert_eq!(terminal(&handle).unwrap(), Phase::Completed);
|
||||
let status = handle.status().unwrap();
|
||||
assert_eq!((status.request.width, status.request.height), (13, 7));
|
||||
let options = status.request.raytrace.as_ref().unwrap().progressive.unwrap();
|
||||
assert_eq!((options.samples_per_pixel, options.seed), (9, 83));
|
||||
let frame = handle.frame().unwrap().unwrap();
|
||||
let image = image::load_from_memory(frame.png()).unwrap().to_rgba8();
|
||||
assert_eq!(image.dimensions(), (13, 7));
|
||||
assert!(image.pixels().all(|pixel| pixel.0 == [17, 89, 203, 255]), "independent constant-background miss oracle");
|
||||
if let Some(bytes) = &baseline {
|
||||
assert_eq!(frame.png(), bytes.as_slice());
|
||||
} else {
|
||||
baseline = Some(frame.png().to_vec());
|
||||
}
|
||||
let report = handle.protected_preview_report().unwrap();
|
||||
assert_eq!(report.is_some(), feedback);
|
||||
if let Some(report) = report {
|
||||
assert_eq!(report.quota_limit, 64);
|
||||
assert!(report.ordinary_used <= report.ordinary_limit);
|
||||
assert!(report.presentation_used <= report.presentation_limit);
|
||||
assert_eq!(report.quota_exhausted, report.accepted_snapshots == report.quota_limit);
|
||||
}
|
||||
assert!(!handle.request_partial_preview().unwrap(), "terminal demand cannot restart work");
|
||||
let foreign = JobId { session: job.session + 1, ..job };
|
||||
assert!(session.render_job_handle(foreign).is_err());
|
||||
assert!(session.execute("render.result.pin", &json!({"job":foreign})).is_err());
|
||||
session.execute("render.result.pin", &json!({"job":job})).unwrap();
|
||||
}
|
||||
assert_eq!(before, session.doc.to_json());
|
||||
assert_eq!(history, (session.revision, session.undo.len(), session.redo.len()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn final_cpu_feedback_saved_normalization_and_legacy_omission_are_explicit() {
|
||||
let (mut session, _) = native().unwrap();
|
||||
let typed = json!({"settings":{"width":13,"height":7,"background":[17,89,203],
|
||||
"job":{"method":"cpu_raytrace","options":{"primary_samples":1,"lights":[],"shadows":false,
|
||||
"progressive":{"samples_per_pixel":9,"seed":83}}}}});
|
||||
for feedback in [None, Some(false), Some(true)] {
|
||||
let mut params = typed.clone();
|
||||
if let Some(feedback) = feedback {
|
||||
params["progressive_feedback"] = json!(feedback);
|
||||
}
|
||||
let checked = session.execute("render.preflight", ¶ms).unwrap();
|
||||
let started = session.execute("render.start", ¶ms).unwrap();
|
||||
let job: JobId = serde_json::from_value(started["job"].clone()).unwrap();
|
||||
let handle = session.render_job_handle(job).unwrap();
|
||||
assert_eq!(terminal(&handle).unwrap(), Phase::Completed);
|
||||
assert_eq!(serde_json::to_value(handle.status().unwrap().request).unwrap(), checked["request"]);
|
||||
assert_eq!(handle.protected_preview_report().unwrap().is_some(), feedback == Some(true));
|
||||
}
|
||||
for mut invalid in
|
||||
[json!({"settings":{"width":13,"height":7}}), wire([17, 89, 203]), json!({"progressive":true,"settings":{"width":13,"height":7}})]
|
||||
{
|
||||
invalid["progressive_feedback"] = json!(true);
|
||||
for command in ["render.preflight", "render.start"] {
|
||||
let error = session.execute(command, &invalid).unwrap_err().to_string();
|
||||
assert!(error.contains("progressive_feedback"), "{error}");
|
||||
}
|
||||
}
|
||||
let mut malformed = typed;
|
||||
malformed["progressive_feedback"] = json!("true");
|
||||
assert!(session.execute("render.preflight", &malformed).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn final_cpu_protected_admission_accounts_captured_hdr_once_and_runs_real_host() {
|
||||
use solidcraft_render::job::{CpuProgressiveOptions, ImageRequest, JobOptions, RaytraceOptions};
|
||||
let (session, host) = native().unwrap();
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
integrator: Integrator::Raytrace,
|
||||
width: 13,
|
||||
height: 7,
|
||||
background: [17, 89, 203],
|
||||
raytrace: Some(RaytraceOptions {
|
||||
lights: Some(Vec::new()),
|
||||
shadows: false,
|
||||
primary_samples: 1,
|
||||
progressive: Some(CpuProgressiveOptions { samples_per_pixel: 9, seed: 83 }),
|
||||
..Default::default()
|
||||
}),
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
camera: Default::default(),
|
||||
transparent_background: false,
|
||||
};
|
||||
let scene = solidcraft_render::ProductScene { meshes: Vec::new(), bounds: solidcraft_geom::Aabb3::EMPTY };
|
||||
// Original equirectangular 2x1 RGBE source: two distinct texels, eight payload bytes.
|
||||
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 1 +X 2\n".to_vec();
|
||||
bytes.extend_from_slice(&[96, 64, 32, 129, 32, 64, 96, 129]);
|
||||
let encoded_capacity = bytes.capacity() as u64;
|
||||
// Independent allocation contract: 2 RGB f32 texels = 24 bytes, one
|
||||
// 2-pixel RGBE scanline = 8 bytes, plus the fixed 8192-byte task envelope.
|
||||
let expected_hdr_bytes = encoded_capacity + 24 + 8 + 8192;
|
||||
let source = solidcraft_render::lighting::HdrSource::new(bytes).unwrap();
|
||||
assert_eq!((source.info().width, source.info().height), (2, 1));
|
||||
assert_eq!(source.retained_encoded_bytes(), encoded_capacity);
|
||||
assert_eq!(source.info().decoded_rgb_bytes, 24);
|
||||
let environment = solidcraft_render::lighting::environment_input::EnvironmentInput::new(source, 0.25, 0.5, 1).unwrap();
|
||||
let plain = host.admit_cpu_protected_partial_with_environment_and_options(&scene, &request, JobOptions::default(), None).unwrap();
|
||||
let lit = host.admit_cpu_protected_partial_with_environment_and_options(&scene, &request, JobOptions::default(), Some(&environment)).unwrap();
|
||||
assert_eq!(environment.required_bytes().unwrap(), expected_hdr_bytes);
|
||||
assert_eq!(lit.preparation_bytes - plain.preparation_bytes, expected_hdr_bytes);
|
||||
assert_eq!(
|
||||
lit.estimated_total_bytes - plain.estimated_total_bytes,
|
||||
expected_hdr_bytes + std::mem::size_of::<solidcraft_render::lighting::environment_input::EnvironmentInfo>() as u64
|
||||
);
|
||||
let job = host
|
||||
.submit_cpu_protected_partial_with_environment_and_options(
|
||||
JobId { session: session.render_jobs.owner, serial: 1, generation: 1 },
|
||||
session.revision,
|
||||
scene,
|
||||
request,
|
||||
JobOptions::default(),
|
||||
Some(environment),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(terminal(&job).unwrap(), Phase::Completed);
|
||||
assert!(job.status().unwrap().environment.is_some());
|
||||
assert!(job.protected_preview_report().unwrap().is_some());
|
||||
assert_eq!(job.frame().unwrap().unwrap().info.width, 13);
|
||||
}
|
||||
}
|
||||
+354
@@ -0,0 +1,354 @@
|
||||
use super::super::{Executor, JobOptions, Task, open_headless};
|
||||
use super::*;
|
||||
use solidcraft_geom::{Mesh, Vec3};
|
||||
use solidcraft_render::{
|
||||
Camera, ProductMesh, ProductScene, StandardView,
|
||||
job::{CancelToken, ImageRequest, ImageWork, TaskPoll},
|
||||
surface::OpaqueSurface,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
type Guide = [[f64; 4]; 3];
|
||||
fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
|
||||
a.into_iter().zip(b).map(|(x, y)| x * y).sum()
|
||||
}
|
||||
fn diff(a: [f64; 4], b: [f64; 4]) -> [f64; 3] {
|
||||
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
|
||||
}
|
||||
fn xyz(a: [f64; 4]) -> [f64; 3] {
|
||||
[a[0], a[1], a[2]]
|
||||
}
|
||||
|
||||
// Independent f64 gather oracle: all inputs are averaged linear values, so the
|
||||
// GPU's accumulated-sample scaling is absent from this numerical implementation.
|
||||
fn reference(width: usize, input: &[[f64; 4]], guides: &[Guide], step: usize) -> Vec<[f64; 4]> {
|
||||
let height = input.len() / width;
|
||||
let kernel = [1.0, 4.0, 6.0, 4.0, 1.0];
|
||||
input
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, ¢er)| {
|
||||
let [a, n, p] = guides[i];
|
||||
if a[3] == 0.0 || center[3] < 0.999 {
|
||||
return center;
|
||||
}
|
||||
let mut result = [0.0; 4];
|
||||
let mut total = 0.0;
|
||||
for (ky, &wy) in kernel.iter().enumerate() {
|
||||
for (kx, &wx) in kernel.iter().enumerate() {
|
||||
let x = (i % width) as isize + (kx as isize - 2) * step as isize;
|
||||
let y = (i / width) as isize + (ky as isize - 2) * step as isize;
|
||||
if x < 0 || y < 0 || x >= width as isize || y >= height as isize {
|
||||
continue;
|
||||
}
|
||||
let j = y as usize * width + x as usize;
|
||||
let [b, m, q] = guides[j];
|
||||
let value = input[j];
|
||||
if a[3] != b[3] || (value[3] - center[3]).abs() > 0.01 {
|
||||
continue;
|
||||
}
|
||||
let albedo = diff(a, b);
|
||||
let position = diff(q, p);
|
||||
let plane = dot(position, xyz(n)).abs() + dot(position, xyz(m)).abs();
|
||||
let scale = (0.05 * p[3].max(q[3]) * step as f64).max(1e-6);
|
||||
let depth = (n[3] - m[3]).abs() / (8.0 * p[3].max(q[3]) * step as f64).max(1e-6);
|
||||
let color = diff(center, value);
|
||||
let maximum = |v: [f64; 3]| v.into_iter().fold(0.0, f64::max);
|
||||
let color_scale = 0.25 + 0.5 * maximum(xyz(center)).max(maximum(xyz(value)));
|
||||
let weight = wx
|
||||
* wy
|
||||
* (-dot(albedo, albedo) / 0.04 - plane / scale - depth - maximum(color.map(f64::abs)) / color_scale).exp()
|
||||
* dot(xyz(n), xyz(m)).max(0.0).powi(32);
|
||||
for k in 0..3 {
|
||||
result[k] += value[k] * weight;
|
||||
}
|
||||
total += weight;
|
||||
}
|
||||
}
|
||||
for v in result.iter_mut().take(3) {
|
||||
*v /= total;
|
||||
}
|
||||
result[3] = center[3];
|
||||
result
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn guide(x: usize, y: usize) -> Guide {
|
||||
[[0.5, 0.5, 0.5, 1.0], [0.0, 0.0, 1.0, 4.0], [x as f64, y as f64, 0.0, 1.0]]
|
||||
}
|
||||
fn fixture(size: usize) -> (Vec<[f64; 4]>, Vec<Guide>) {
|
||||
let mut pixels = Vec::new();
|
||||
let mut guides = Vec::new();
|
||||
for y in 0..size {
|
||||
for x in 0..size {
|
||||
// Deterministic white noise in [0.4, 0.6]. A pixel-frequency checker would
|
||||
// be invisible to the step-2 and step-4 passes, which only reach same-parity pixels.
|
||||
let hash = ((x * 7919 + y * 104_729) as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15) >> 40;
|
||||
let level = 0.4 + 0.2 * hash as f64 / f64::from(1u32 << 24);
|
||||
pixels.push([level, level, level, 1.0]);
|
||||
guides.push(guide(x, y));
|
||||
}
|
||||
}
|
||||
(pixels, guides)
|
||||
}
|
||||
#[test]
|
||||
fn f64_atrous_reduces_flat_noise_preserves_constant_and_coverage() {
|
||||
let (input, guides) = fixture(17);
|
||||
let mut result = input.clone();
|
||||
for step in [1, 2, 4] {
|
||||
result = reference(17, &result, &guides, step);
|
||||
}
|
||||
let variance = |image: &[[f64; 4]]| {
|
||||
let mean = image.iter().map(|p| p[0]).sum::<f64>() / image.len() as f64;
|
||||
image.iter().map(|p| (p[0] - mean).powi(2)).sum::<f64>() / image.len() as f64
|
||||
};
|
||||
println!("noise variance {} -> {}", variance(&input), variance(&result));
|
||||
assert!(variance(&result) < variance(&input) / 4.0, "noise variance {} -> {}", variance(&input), variance(&result));
|
||||
assert_eq!(reference(17, &vec![[0.7, 0.3, 0.1, 0.5]; 289], &guides, 1), vec![[0.7, 0.3, 0.1, 0.5]; 289]);
|
||||
let constant = reference(17, &vec![[0.75, 0.75, 0.75, 1.0]; 289], &guides, 4);
|
||||
assert!(constant.iter().all(|p| p[..3].iter().all(|x| (*x - 0.75).abs() < 1e-14)));
|
||||
}
|
||||
#[test]
|
||||
fn f64_atrous_preserves_body_normal_depth_and_albedo_edges() {
|
||||
for edge in 0..5 {
|
||||
let mut pixels = Vec::new();
|
||||
let mut guides = Vec::new();
|
||||
for y in 0..17 {
|
||||
for x in 0..17 {
|
||||
let mut g = guide(x, y);
|
||||
let c = if x < 8 { 0.0 } else { 1.0 };
|
||||
if x >= 8 {
|
||||
match edge {
|
||||
0 => g[0][3] = 2.0,
|
||||
1 => g[1] = [1.0, 0.0, 0.0, 4.0],
|
||||
2 => g[2][2] = 10.0,
|
||||
4 => g[1][3] = 1004.0,
|
||||
_ => g[0] = [1.0, 1.0, 1.0, 1.0],
|
||||
}
|
||||
}
|
||||
if edge == 3 && x < 8 {
|
||||
g[0] = [0.0, 0.0, 0.0, 1.0];
|
||||
}
|
||||
pixels.push([c, c, c, 1.0]);
|
||||
guides.push(g);
|
||||
}
|
||||
}
|
||||
let mut filtered = pixels.clone();
|
||||
for step in [1, 2, 4] {
|
||||
filtered = reference(17, &filtered, &guides, step);
|
||||
}
|
||||
assert!(filtered.iter().zip(&pixels).all(|(a, b)| (a[0] - b[0]).abs() < 1e-12), "edge {edge}");
|
||||
}
|
||||
}
|
||||
fn context() -> Option<Arc<Context>> {
|
||||
let (_, device, queue) = match open_headless() {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
// The path tracer runs on Vulkan or Metal only: where the backends in use leave both out
|
||||
// (`WGPU_BACKEND=dx12`), it is unavailable by design, not missing.
|
||||
let available = !crate::select::path_backends().is_empty();
|
||||
assert!(!available || std::env::var_os("SOLIDCRAFT_REQUIRE_GPU").is_none(), "required GPU unavailable: {e}");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
Some(Executor::new(device, queue).unwrap().context)
|
||||
}
|
||||
fn request(size: u32) -> ImageRequest {
|
||||
let mut camera = Camera { distance: 4.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
camera,
|
||||
width: size,
|
||||
height: size,
|
||||
background: [0; 3],
|
||||
transparent_background: false,
|
||||
environment: None,
|
||||
textures: None,
|
||||
}
|
||||
}
|
||||
fn plane() -> ProductScene {
|
||||
let mesh = Mesh {
|
||||
positions: vec![Vec3::new(-1.0, -1.0, 0.0), Vec3::new(1.0, -1.0, 0.0), Vec3::new(1.0, 1.0, 0.0), Vec3::new(-1.0, 1.0, 0.0)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
};
|
||||
ProductScene {
|
||||
bounds: mesh.bounds(),
|
||||
meshes: vec![ProductMesh {
|
||||
name: "original denoise plane".into(),
|
||||
mesh: Arc::new(mesh),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(0.5, 0.5, 0.5), 0.0, 1.0, 1.5).unwrap()),
|
||||
transmission: None,
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
}
|
||||
}
|
||||
fn read_guides(context: &Context, buffer: &wgpu::Buffer) -> Vec<[f32; 4]> {
|
||||
let staging = context.device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: None,
|
||||
size: buffer.size(),
|
||||
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let mut encoder = context.device.create_command_encoder(&Default::default());
|
||||
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, buffer.size());
|
||||
let submission = context.queue.submit([encoder.finish()]);
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
staging.slice(..).map_async(wgpu::MapMode::Read, move |v| {
|
||||
tx.send(v).unwrap();
|
||||
});
|
||||
context.device.poll(wgpu::PollType::Wait { submission_index: Some(submission), timeout: Some(TIMEOUT) }).unwrap();
|
||||
rx.recv().unwrap().unwrap();
|
||||
let mapped = staging.slice(..).get_mapped_range().unwrap();
|
||||
let values = mapped.as_chunks::<16>().0.iter().map(|v| [0, 4, 8, 12].map(|i| f32::from_le_bytes(v[i..i + 4].try_into().unwrap()))).collect();
|
||||
drop(mapped);
|
||||
staging.unmap();
|
||||
values
|
||||
}
|
||||
#[test]
|
||||
fn denoise_admission_counts_guides_and_ping_pong_only_when_enabled() {
|
||||
let scene = plane();
|
||||
let request = request(32);
|
||||
let plain = super::super::admission(&scene, &request, JobOptions::default()).unwrap();
|
||||
let filtered = super::super::admission(&scene, &request, JobOptions { denoise: true, ..Default::default() }).unwrap();
|
||||
assert_eq!(filtered.pixel_scratch_bytes - plain.pixel_scratch_bytes, 32 * 32 * 80);
|
||||
assert_eq!(filtered.estimated_total_bytes - plain.estimated_total_bytes, 32 * 32 * 80);
|
||||
let large = ImageRequest { width: 2000, height: 2000, ..request.clone() };
|
||||
assert!(super::super::admission(&scene, &large, JobOptions::default()).is_ok());
|
||||
// The production envelope deliberately admits this former 512 MiB refusal.
|
||||
// Still charge the guides/ping-pong in full, and reject outside the new edge.
|
||||
let large_plain = super::super::admission(&scene, &large, JobOptions::default()).unwrap();
|
||||
let large_filtered = super::super::admission(&scene, &large, JobOptions { denoise: true, ..Default::default() }).unwrap();
|
||||
assert_eq!(large_filtered.pixel_scratch_bytes - large_plain.pixel_scratch_bytes, 2000 * 2000 * 80);
|
||||
assert!(large_filtered.estimated_total_bytes > 512 * 1024 * 1024);
|
||||
assert!(large_filtered.estimated_total_bytes <= solidcraft_render::job::GPU_PATH_LIMITS.max_scratch_bytes);
|
||||
let excessive = ImageRequest { width: (solidcraft_render::job::GPU_PATH_LIMITS.max_dimension + 1) as u32, ..request.clone() };
|
||||
for denoise in [false, true] {
|
||||
assert!(super::super::admission(&scene, &excessive, JobOptions { denoise, ..Default::default() }).is_err());
|
||||
}
|
||||
assert!(!serde_json::from_str::<JobOptions>("{}").unwrap().denoise);
|
||||
assert!(serde_json::from_str::<JobOptions>(r#"{"denoise":"true"}"#).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn gpu_atrous_matches_f64_guides_and_leaves_input_unchanged() {
|
||||
let Some(context) = context() else {
|
||||
return;
|
||||
};
|
||||
let (mut input, mut guides) = fixture(13);
|
||||
for y in 0..13 {
|
||||
for x in 7..13 {
|
||||
guides[y * 13 + x][0][3] = 2.0;
|
||||
input[y * 13 + x][0] += 0.8;
|
||||
}
|
||||
}
|
||||
guides[0][0][3] = 0.0;
|
||||
input[1][3] = 0.5;
|
||||
let bytes: Vec<u8> = input.iter().flatten().flat_map(|x| (*x as f32).to_le_bytes()).collect();
|
||||
let device = &context.device;
|
||||
let make = |label, bytes: &[u8]| {
|
||||
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: Some(label),
|
||||
contents: bytes,
|
||||
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
|
||||
})
|
||||
};
|
||||
let raw = make("denoise fixture raw", &bytes);
|
||||
let dummy = make("denoise unused geometry", &[0; 64]);
|
||||
let mut task = Task::new(context.clone(), plane(), request(13), JobOptions::default(), CancelToken::default()).unwrap();
|
||||
task.sample = 1;
|
||||
let filter = Resources::new(&context, &task.uniform, [&dummy, &dummy, &dummy, &dummy, &dummy], &raw, bytes.len() as u64).unwrap();
|
||||
let guide_bytes: Vec<u8> = guides.iter().flatten().flatten().flat_map(|x| (*x as f32).to_le_bytes()).collect();
|
||||
context.queue.write_buffer(&filter._guides, 0, &guide_bytes);
|
||||
let before = task.read_linear_buffer(&raw).unwrap();
|
||||
filter.run_filter(&task).unwrap();
|
||||
assert_eq!(before, task.read_linear_buffer(&raw).unwrap());
|
||||
let actual = task.read_linear_buffer(filter.output()).unwrap();
|
||||
let mut expected = input;
|
||||
for step in [1, 2, 4] {
|
||||
expected = reference(13, &expected, &guides, step);
|
||||
}
|
||||
for (a, b) in actual.iter().zip(&expected) {
|
||||
for (x, y) in a.iter().zip(b) {
|
||||
assert!((f64::from(*x) - *y).abs() < 2e-5, "{a:?} vs {b:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn gpu_denoise_default_false_is_identical_and_true_preserves_raw() {
|
||||
let Some(context) = context() else {
|
||||
return;
|
||||
};
|
||||
let mut outputs = Vec::new();
|
||||
let mut pngs = Vec::new();
|
||||
for options in [
|
||||
JobOptions { samples: 4, ..Default::default() },
|
||||
JobOptions { samples: 4, denoise: false, ..Default::default() },
|
||||
JobOptions { samples: 4, denoise: true, ..Default::default() },
|
||||
] {
|
||||
let mut task = Task::new(context.clone(), plane(), request(8), options, CancelToken::default()).unwrap();
|
||||
assert_eq!(task.denoiser.is_some(), options.denoise);
|
||||
while task.sample < 4 {
|
||||
task.complete_sample().unwrap();
|
||||
}
|
||||
let raw = task.read_linear().unwrap();
|
||||
if let Some(filter) = &task.denoiser {
|
||||
filter.run(&task).unwrap();
|
||||
assert_eq!(raw, task.read_linear().unwrap());
|
||||
let filtered = task.read_linear_buffer(filter.output()).unwrap();
|
||||
assert!(filtered.iter().all(|p| p.iter().all(|v| v.is_finite())));
|
||||
let guides = read_guides(&context, &filter._guides);
|
||||
assert_eq!(guides[0], [0.0; 4]);
|
||||
let center = (4 * 8 + 4) * 3;
|
||||
assert_eq!(guides[center], [0.5, 0.5, 0.5, 1.0]);
|
||||
assert_eq!(guides[center + 1], [0.0, 0.0, 1.0, 16.0]);
|
||||
assert!((guides[center + 2][0] - 0.2).abs() < 1e-6);
|
||||
assert!((guides[center + 2][1] + 0.2).abs() < 1e-6);
|
||||
assert!((guides[center + 2][3] - 0.4).abs() < 1e-6);
|
||||
}
|
||||
outputs.push(raw);
|
||||
for _ in 0..100 {
|
||||
if let TaskPoll::Complete(png) = task.step(4096).unwrap() {
|
||||
pngs.push(png);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert_eq!(outputs[0], outputs[1]);
|
||||
assert_eq!(outputs[0], outputs[2]);
|
||||
assert_eq!(pngs.len(), 3);
|
||||
assert_eq!(pngs[0], pngs[1]);
|
||||
}
|
||||
#[test]
|
||||
fn gpu_denoise_preflight_reports_limits_without_changing_document() {
|
||||
let Some(context) = context() else {
|
||||
return;
|
||||
};
|
||||
let mut session = solidcraft_engine::Session::default();
|
||||
session.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
|
||||
session.register_render_job_host(solidcraft_render::job::ImageHost::with_executor(Arc::new(Executor { context })).unwrap()).unwrap();
|
||||
session.execute("solid.box", &serde_json::json!({"length":2,"width":2,"height":1})).unwrap();
|
||||
let before = session.doc.to_json();
|
||||
let mut params = serde_json::json!({"progressive":true,"denoise":true,"settings":{"width":8,"height":8}});
|
||||
let reply = session.execute("render.preflight", ¶ms).unwrap();
|
||||
assert_eq!(reply["options"]["denoise"], true);
|
||||
assert_eq!(reply["denoising"]["passes"], 3);
|
||||
assert_eq!(reply["denoising"]["raw_linear_accumulator_preserved"], true);
|
||||
assert_eq!(before, session.doc.to_json());
|
||||
params["progressive"] = serde_json::json!(false);
|
||||
assert!(session.execute("render.preflight", ¶ms).is_err());
|
||||
params["denoise"] = serde_json::json!(false);
|
||||
let reply = session.execute("render.preflight", ¶ms).unwrap();
|
||||
assert!(reply.get("denoising").is_none());
|
||||
}
|
||||
+3357
File diff suppressed because it is too large.
Load diff
+193
@@ -0,0 +1,193 @@
|
||||
//! Bounded native acceptance probe for explicit CPU profiles. This is not a speed
|
||||
//! benchmark or an application/UI test. Writes only to a new caller-selected folder.
|
||||
use serde_json::json;
|
||||
use solidcraft_geom::{Mesh, Vec3};
|
||||
use solidcraft_render::job::{CpuBudget, CpuHost, DirectionalLightOptions, ImageRequest, Integrator, JobId, JobOptions, Phase, RaytraceOptions};
|
||||
use solidcraft_render::{Camera, ProductMesh, ProductScene, StandardView, surface::OpaqueSurface};
|
||||
use std::{error::Error, fs, path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
fn scene() -> Result<ProductScene, Box<dyn Error>> {
|
||||
let mesh = Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(-20.0, -15.0, 0.0), Vec3::new(20.0, -15.0, 0.0), Vec3::new(20.0, 15.0, 0.0), Vec3::new(-20.0, 15.0, 0.0)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
Ok(ProductScene {
|
||||
bounds: mesh.bounds(),
|
||||
meshes: vec![ProductMesh {
|
||||
name: "Original CPU admission plate".into(),
|
||||
mesh,
|
||||
color: [92, 150, 210],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(0.1, 0.3, 0.6), 0.0, 0.5, 1.5)?),
|
||||
transmission: None,
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
})
|
||||
}
|
||||
fn request(width: u32, height: u32, budget: CpuBudget) -> ImageRequest {
|
||||
let mut camera = Camera { distance: 65.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: Integrator::Raytrace,
|
||||
raytrace: Some(RaytraceOptions {
|
||||
budget,
|
||||
lights: Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]),
|
||||
shadows: false,
|
||||
..Default::default()
|
||||
}),
|
||||
camera,
|
||||
width,
|
||||
height,
|
||||
background: [236, 240, 245],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn dense_scene() -> Result<ProductScene, Box<dyn Error>> {
|
||||
let side = 500u32;
|
||||
let vertices = (side + 1) * (side + 1);
|
||||
let mut positions = Vec::new();
|
||||
positions.try_reserve_exact(vertices as usize)?;
|
||||
for y in 0..=side {
|
||||
for x in 0..=side {
|
||||
positions.push(Vec3::new(-20.0 + 40.0 * f64::from(x) / f64::from(side), -15.0 + 30.0 * f64::from(y) / f64::from(side), 0.0));
|
||||
}
|
||||
}
|
||||
let mut triangles = Vec::new();
|
||||
triangles.try_reserve_exact((2 * side * side) as usize)?;
|
||||
for y in 0..side {
|
||||
for x in 0..side {
|
||||
let a = y * (side + 1) + x;
|
||||
let b = a + 1;
|
||||
let c = a + side + 2;
|
||||
let d = a + side + 1;
|
||||
triangles.push([a, b, c]);
|
||||
triangles.push([a, c, d]);
|
||||
}
|
||||
}
|
||||
let mesh =
|
||||
Arc::new(Mesh { positions, normals: vec![Vec3::Z; vertices as usize], tri_face: vec![0; triangles.len()], triangles, ..Default::default() });
|
||||
let mut result = scene()?;
|
||||
result.bounds = mesh.bounds();
|
||||
let body = result.meshes.first_mut().ok_or("missing fixture body")?;
|
||||
body.mesh = mesh;
|
||||
body.name = "Original 500000-triangle grid".into();
|
||||
Ok(result)
|
||||
}
|
||||
fn body_scene() -> Result<ProductScene, Box<dyn Error>> {
|
||||
let mut result = scene()?;
|
||||
let template = result.meshes.first().cloned().ok_or("missing fixture body")?;
|
||||
result.meshes.clear();
|
||||
result.meshes.try_reserve_exact(20_000)?;
|
||||
for y in 0..100 {
|
||||
for x in 0..200 {
|
||||
let (x, y) = (f64::from(x) - 99.5, f64::from(y) - 49.5);
|
||||
let mesh = Arc::new(Mesh {
|
||||
positions: vec![
|
||||
Vec3::new(x - 0.4, y - 0.4, 0.0),
|
||||
Vec3::new(x + 0.4, y - 0.4, 0.0),
|
||||
Vec3::new(x + 0.4, y + 0.4, 0.0),
|
||||
Vec3::new(x - 0.4, y + 0.4, 0.0),
|
||||
],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
let mut body = template.clone();
|
||||
body.name = format!("Original tile {x} {y}");
|
||||
body.mesh = mesh;
|
||||
result.meshes.push(body);
|
||||
}
|
||||
}
|
||||
result.bounds = solidcraft_geom::Aabb3 { min: Vec3::new(-100.0, -50.0, 0.0), max: Vec3::new(100.0, 50.0, 0.0) };
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
let out = std::env::args_os().nth(1).map(PathBuf::from).ok_or("usage: cpu_resource_smoke NEW_OUTPUT_DIRECTORY [4k|8k|dense|bodies]")?;
|
||||
fs::create_dir(&out)?;
|
||||
let host = CpuHost::for_platform()?;
|
||||
let case = std::env::args().nth(2).unwrap_or_else(|| "4k".into());
|
||||
let (width, height, budget, source) = match case.as_str() {
|
||||
"4k" => (3840, 2160, CpuBudget::Studio, scene()?),
|
||||
"8k" => (7680, 4320, CpuBudget::Workstation, scene()?),
|
||||
"dense" => (256, 256, CpuBudget::Studio, dense_scene()?),
|
||||
"bodies" => (512, 256, CpuBudget::Studio, body_scene()?),
|
||||
_ => return Err("case must be 4k, 8k, dense or bodies".into()),
|
||||
};
|
||||
let compact = request(width, height, CpuBudget::Compact);
|
||||
if host.admit(&source, &compact, JobOptions::default()).is_ok() {
|
||||
return Err("legacy Compact incorrectly admitted a deliberately oversized request".into());
|
||||
}
|
||||
let mut studio = request(width, height, budget);
|
||||
if case == "bodies" {
|
||||
studio.camera.fit(&source.bounds);
|
||||
}
|
||||
let admission = host.admit(&source, &studio, JobOptions::default())?;
|
||||
let id = JobId { session: 20261022, serial: 1, generation: 1 };
|
||||
let handle = host.submit(id, 1, source.clone(), studio)?;
|
||||
let status = match handle.wait_timeout(Duration::from_secs(300)) {
|
||||
Ok(status) => status,
|
||||
Err(error) => {
|
||||
let _ = handle.cancel();
|
||||
return Err(error.into());
|
||||
}
|
||||
};
|
||||
if status.progress.phase != Phase::Completed {
|
||||
return Err(format!("CPU render failed: {:?}", status.error).into());
|
||||
}
|
||||
let frame = handle.frame()?.ok_or("completed CPU result has no frame")?;
|
||||
let image = image::load_from_memory(frame.png())?.to_rgba8();
|
||||
if image.dimensions() != (width, height) || !image.pixels().any(|pixel| pixel.0 != [236, 240, 245, 255]) {
|
||||
return Err("image does not contain the original analytic fixture".into());
|
||||
}
|
||||
fs::write(out.join(format!("cpu-{case}.png")), frame.png())?;
|
||||
let frame_info = serde_json::to_value(&frame.info)?;
|
||||
drop(frame);
|
||||
drop(handle);
|
||||
// Native cleanup is observed through reservations; no capacity is claimed merely
|
||||
// from a dimensions constant or a downscaled display texture.
|
||||
for _ in 0..100 {
|
||||
if host.admitted_bytes() == 0 {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
if host.admitted_bytes() != 0 {
|
||||
return Err("completed CPU frame reservation was not released".into());
|
||||
}
|
||||
|
||||
// Synthetic cardinality probe only, not a heavy-assembly render benchmark.
|
||||
let admission_scene = scene()?;
|
||||
let template = admission_scene.meshes.first().ok_or("missing original plate")?;
|
||||
let mut bodies = Vec::new();
|
||||
bodies.try_reserve_exact(20_000)?;
|
||||
for i in 0..20_000 {
|
||||
let mut body = template.clone();
|
||||
body.name = format!("Admission body {i}");
|
||||
bodies.push(body);
|
||||
}
|
||||
let many = ProductScene { bounds: admission_scene.bounds, meshes: bodies };
|
||||
if host.admit(&many, &request(16, 16, CpuBudget::Compact), JobOptions::default()).is_ok() {
|
||||
return Err("Compact accepted too many bodies".into());
|
||||
}
|
||||
let bodies_admission = host.admit(&many, &request(16, 16, CpuBudget::Studio), JobOptions::default())?;
|
||||
let record = json!({"status":"PASS","scope":"native CPU selected-case execution plus separate bounded synthetic body admission","case":case,"rendered_bodies":source.meshes.len(),"rendered_triangles":admission.triangles,
|
||||
"not_a_performance_benchmark":true,"application_ui_tested":false,"frame":frame_info,
|
||||
"image_admission":admission,"twenty_thousand_bodies_admission":bodies_admission,
|
||||
"retained_pool_bytes_after_drop":host.admitted_bytes(),"compact_refused_both_explicit_large_requests":true});
|
||||
fs::write(out.join("receipt.json"), serde_json::to_vec_pretty(&record)?)?;
|
||||
println!("{}", serde_json::to_string_pretty(&record)?);
|
||||
Ok(())
|
||||
}
|
||||
+2999
File diff suppressed because it is too large.
Load diff
+176
@@ -0,0 +1,176 @@
|
||||
use super::super::{PngTask, linear_exr::ExrTask, presentation::Presentation};
|
||||
use super::*;
|
||||
use std::sync::atomic::AtomicUsize;
|
||||
|
||||
struct FixtureExecutor(Arc<AtomicUsize>);
|
||||
struct FixtureWork {
|
||||
png: PngTask,
|
||||
exr: Option<Vec<u8>>,
|
||||
}
|
||||
impl ImageWork for FixtureWork {
|
||||
fn take_linear_exr(&mut self) -> Option<Vec<u8>> {
|
||||
self.exr.take()
|
||||
}
|
||||
fn step(&mut self, units: usize) -> Result<TaskPoll> {
|
||||
self.png.step(units)
|
||||
}
|
||||
}
|
||||
impl ImageExecutor for FixtureExecutor {
|
||||
fn supports_linear_exr(&self) -> bool {
|
||||
true
|
||||
}
|
||||
fn descriptor(&self) -> Result<ExecutorDescriptor> {
|
||||
CpuExecutor.descriptor()
|
||||
}
|
||||
fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
|
||||
let mut a = admit(scene, request)?;
|
||||
a.estimated_total_bytes += 1_048_576;
|
||||
Ok(a)
|
||||
}
|
||||
fn begin(&self, _: ProductScene, request: ImageRequest, options: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
|
||||
self.0.fetch_add(1, Ordering::Relaxed);
|
||||
let pixels: Vec<_> = (0..request.width * request.height).map(|i| if i % 3 == 0 { [4.0, 0.5, 0.125, 0.5] } else { [0.0; 4] }).collect();
|
||||
let settings = Presentation { background: request.background, ..Default::default() };
|
||||
let mut rgba = vec![0; pixels.len() * 4];
|
||||
settings.display(request.width, request.height)?.encode(&pixels, &mut rgba, &cancel)?;
|
||||
let exr = if options.linear_exr {
|
||||
let mut task = ExrTask::new(request.width, request.height, pixels, cancel.clone())?;
|
||||
while !task.step(4)? {}
|
||||
Some(task.finish()?.0)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
Ok(Box::new(FixtureWork { png: PngTask::new(&request, rgba, cancel)?, exr }))
|
||||
}
|
||||
}
|
||||
fn fixture(raw: bool) -> (ImageHost, JobHandle, Arc<AtomicUsize>, Presentation) {
|
||||
let begins = Arc::new(AtomicUsize::new(0));
|
||||
let host = ImageHost::cooperative_with(Arc::new(FixtureExecutor(begins.clone())));
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
width: 16,
|
||||
height: 16,
|
||||
background: [40, 80, 120],
|
||||
transparent_background: false,
|
||||
camera: Default::default(),
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
textures: None,
|
||||
environment: None,
|
||||
};
|
||||
let settings = Presentation { background: request.background, ..Default::default() };
|
||||
let source = host
|
||||
.submit_with_options(
|
||||
identity(1),
|
||||
42,
|
||||
ProductScene { meshes: Vec::new(), bounds: solidcraft_geom::Aabb3::EMPTY },
|
||||
request,
|
||||
JobOptions { linear_exr: raw, ..Default::default() },
|
||||
)
|
||||
.unwrap();
|
||||
finish(&host, &source);
|
||||
(host, source, begins, settings)
|
||||
}
|
||||
fn identity(serial: u64) -> JobId {
|
||||
JobId { session: 1817, serial, generation: serial }
|
||||
}
|
||||
fn finish(host: &ImageHost, handle: &JobHandle) {
|
||||
for _ in 0..4096 {
|
||||
if !host.pump(4096).unwrap() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let status = handle.status().unwrap();
|
||||
assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_empty_pixel_shows_the_background_code_unchanged() {
|
||||
let display = Presentation { background: [40, 80, 120], ..Default::default() }.display(1, 1).unwrap();
|
||||
let mut rgba = [0; 4];
|
||||
display.encode(&[[0.0; 4]], &mut rgba, &CancelToken::default()).unwrap();
|
||||
assert_eq!(rgba, [40, 80, 120, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regrade_is_exact_nondestructive_geometry_free_and_flattens_repeated_master_ownership() {
|
||||
let (host, source, begins, settings) = fixture(true);
|
||||
let original = source.frame().unwrap().unwrap();
|
||||
let raw = original.linear_exr().unwrap().as_ptr();
|
||||
let identity = host.submit_regrade(identity(2), &source, settings).unwrap();
|
||||
finish(&host, &identity);
|
||||
let neutral = identity.frame().unwrap().unwrap();
|
||||
assert_eq!(neutral.png(), original.png());
|
||||
assert_eq!(neutral.linear_exr().unwrap().as_ptr(), raw);
|
||||
assert_eq!(neutral.info.scene_generation, 42);
|
||||
assert_eq!(neutral.info.executor.as_str(), "linear-master");
|
||||
let origin = identity.status().unwrap().presentation.unwrap();
|
||||
assert_eq!(origin.source_job, source.id());
|
||||
assert_eq!(origin.master_job, source.id());
|
||||
assert_eq!(origin.master_sha256, original.linear_master_info().unwrap().sha256);
|
||||
assert!(!origin.denoise_applied);
|
||||
let changed = Presentation {
|
||||
exposure_ev: -2.0,
|
||||
finishing: super::super::finishing::Finishing {
|
||||
saturation: 0.2,
|
||||
bloom: Some(super::super::bloom::Bloom { strength: 0.4, radius: 2, threshold: 1.0 }),
|
||||
..Default::default()
|
||||
},
|
||||
backdrop: Some(Default::default()),
|
||||
..settings
|
||||
};
|
||||
let derivative = host.submit_regrade(super::regrade_tests::identity(3), &identity, changed).unwrap();
|
||||
finish(&host, &derivative);
|
||||
let frame = derivative.frame().unwrap().unwrap();
|
||||
assert_ne!(frame.png(), original.png());
|
||||
assert_eq!(frame.linear_exr().unwrap().as_ptr(), raw);
|
||||
assert!(Arc::ptr_eq(&frame.master_source().unwrap(), &original));
|
||||
assert_eq!(frame.presentation().unwrap().source_job, identity.id());
|
||||
assert_eq!(begins.load(Ordering::Relaxed), 1, "post-hoc presentation may never launch an executor");
|
||||
drop(source);
|
||||
drop(identity);
|
||||
drop(derivative);
|
||||
drop(neutral);
|
||||
drop(original);
|
||||
assert!(host.admitted_bytes() > frame.png().len() as u64, "raw source and origin metadata leases remain live");
|
||||
drop(frame);
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regrade_rejects_foreign_missing_or_invalid_masters_and_cancellation_never_publishes() {
|
||||
let (host, no_raw, _, settings) = fixture(false);
|
||||
let before = host.admitted_bytes();
|
||||
assert!(host.submit_regrade(identity(2), &no_raw, settings).is_err());
|
||||
assert_eq!(host.admitted_bytes(), before);
|
||||
let (host, source, begins, settings) = fixture(true);
|
||||
let before = host.admitted_bytes();
|
||||
assert!(host.submit_regrade(JobId { session: 7, ..identity(2) }, &source, settings).is_err());
|
||||
assert!(host.submit_regrade(source.id(), &source, settings).is_err());
|
||||
assert!(host.submit_regrade(identity(2), &source, Presentation { exposure_ev: f64::NAN, ..settings }).is_err());
|
||||
assert_eq!(host.admitted_bytes(), before);
|
||||
for (serial, begin_work) in [(3, false), (4, true)] {
|
||||
let job = host.submit_regrade(identity(serial), &source, settings).unwrap();
|
||||
if begin_work {
|
||||
assert!(host.pump(1).unwrap());
|
||||
}
|
||||
job.cancel().unwrap();
|
||||
for _ in 0..64 {
|
||||
if !host.pump(1).unwrap() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
|
||||
assert!(job.frame().unwrap().is_none());
|
||||
drop(job);
|
||||
assert_eq!(host.admitted_bytes(), before);
|
||||
}
|
||||
assert_eq!(begins.load(Ordering::Relaxed), 1);
|
||||
drop(source);
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
}
|
||||
+2622
File diff suppressed because it is too large.
Load diff
+915
@@ -0,0 +1,915 @@
|
||||
use super::*;
|
||||
use crate::{Camera, ProductMesh, StandardView};
|
||||
use solidcraft_geom::{Aabb3, Mesh};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn raster_ev_scales_lambert_radiance_before_the_existing_single_tone_map() {
|
||||
let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO);
|
||||
part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap());
|
||||
let mut alpha = None;
|
||||
for (ev, expected) in [(-1.0, [69, 77, 77, 255]), (0.0, [94, 104, 104, 255]), (1.0, [124, 135, 135, 255])] {
|
||||
let mut input = request();
|
||||
input.raster_exposure_ev = ev;
|
||||
input.raster_lights =
|
||||
Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]);
|
||||
let png = finish(ImageTask::new(scene(vec![part.clone()]), input, CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Original analytic oracle: [.4,.5,.5]/pi *2^EV -> Reinhard -> sRGB.
|
||||
assert_eq!(image.get_pixel(32, 32).0, expected);
|
||||
assert_eq!(image.get_pixel(0, 0).0, [0; 4]);
|
||||
let coverage: Vec<u8> = image.pixels().map(|pixel| pixel[3]).collect();
|
||||
if let Some(expected_alpha) = &alpha { assert_eq!(&coverage, expected_alpha) } else { alpha = Some(coverage) }
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_ev_covers_implicit_pbr_and_the_weighted_scalar_surrogate_with_original_oracles() {
|
||||
for (ev, implicit_rgb, weighted_gray) in [(-1.0, [90, 73, 52], 6), (0.0, [120, 99, 73], 12), (1.0, [152, 130, 99], 20)] {
|
||||
let mut input = request();
|
||||
input.raster_exposure_ev = ev;
|
||||
let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO);
|
||||
part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap());
|
||||
let png = finish(ImageTask::new(scene(vec![part]), input.clone(), CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Front normal sees only studio Rim:1.5*.6=.9, so rho*.9/pi.
|
||||
assert_eq!(image.get_pixel(32, 32).0, [implicit_rgb[0], implicit_rgb[1], implicit_rgb[2], 255]);
|
||||
input.studio_weights = Some([0.0, 0.0, 1.0]);
|
||||
let png = finish(ImageTask::new(scene(vec![square("scalar", [0; 3], 1.0, Vec3::ZERO)]), input, CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Black roughness1/IOR1.5 surrogate: .28125*F/pi, where the authored
|
||||
// Schlick approximation F=.04+.96*(1-sqrt(.8))^5. Then2^EV/Reinhard/sRGB.
|
||||
assert_eq!(image.get_pixel(32, 32).0, [weighted_gray, weighted_gray, weighted_gray, 255]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_ev_legacy_linear_surrogate_preserves_straight_alpha_and_background() {
|
||||
for (ev, gray) in [(-1.0, 11), (0.0, 19), (1.0, 30)] {
|
||||
let mut input = request();
|
||||
input.raster_exposure_ev = ev;
|
||||
let part = square("legacy", [0; 3], 0.5, Vec3::ZERO);
|
||||
let png = finish(ImageTask::new(scene(vec![part.clone()]), input.clone(), CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Front-view scalar shade: spec=.25*(5/6)^20 on already decoded black;
|
||||
// multiply by2^EV then piecewise sRGB. No Reinhard on this old branch.
|
||||
assert_eq!(image.get_pixel(32, 32).0, [gray, gray, gray, 128]);
|
||||
assert_eq!(image.get_pixel(0, 0).0, [0; 4]);
|
||||
input.transparent_background = false;
|
||||
let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap());
|
||||
assert_eq!(image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_ev_zero_wire_is_exact_and_nonfinite_bounds_or_wrong_integrator_refuse() {
|
||||
let part = scene(vec![square("legacy", [160, 120, 80], 0.5, Vec3::ZERO)]);
|
||||
let mut input = request();
|
||||
let wire = serde_json::to_value(&input).unwrap();
|
||||
assert!(wire.get("raster_exposure_ev").is_none());
|
||||
let decoded: ImageRequest = serde_json::from_value(wire).unwrap();
|
||||
assert_eq!(decoded.raster_exposure_ev, 0.0);
|
||||
let old = finish(ImageTask::new(part.clone(), input.clone(), CancelToken::default()).unwrap());
|
||||
assert_eq!(finish(ImageTask::new(part.clone(), decoded, CancelToken::default()).unwrap()), old);
|
||||
for zero in [0.0, -0.0] {
|
||||
input.raster_exposure_ev = zero;
|
||||
assert_eq!(finish(ImageTask::new(part.clone(), input.clone(), CancelToken::default()).unwrap()), old);
|
||||
}
|
||||
for value in [-32.0, 32.0] {
|
||||
input.raster_exposure_ev = value;
|
||||
assert!(admit(&part, &input).is_ok());
|
||||
}
|
||||
for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -33.0, 33.0] {
|
||||
input.raster_exposure_ev = value;
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
}
|
||||
input.raster_exposure_ev = 1.0;
|
||||
input.integrator = crate::job::Integrator::Raytrace;
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
assert!(crate::job::interactive::cpu_request(&input).is_err());
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
{
|
||||
input.integrator = crate::job::Integrator::Raster;
|
||||
assert!(crate::raytrace::image::admit(&part, &input, &crate::job::RaytraceOptions::default()).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
fn request() -> ImageRequest {
|
||||
let mut camera = Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Front);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
camera,
|
||||
width: 64,
|
||||
height: 64,
|
||||
background: [20, 40, 60],
|
||||
transparent_background: true,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn render_lights_raster_mute_is_captured_in_request_and_darkens_only_the_product() {
|
||||
let part = scene(vec![square("part", [200, 180, 160], 1.0, Vec3::ZERO)]);
|
||||
let mut input = request();
|
||||
input.transparent_background = false;
|
||||
let normal = finish(ImageTask::new(part.clone(), input.clone(), super::CancelToken::default()).unwrap());
|
||||
input.studio_weights = Some([0.0; 3]);
|
||||
let dark = finish(ImageTask::new(part, input, super::CancelToken::default()).unwrap());
|
||||
assert_ne!(normal, dark);
|
||||
let image = image::load_from_memory(&dark).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]);
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
}
|
||||
|
||||
fn square(name: &str, colour: [u8; 3], opacity: f64, offset: Vec3) -> ProductMesh {
|
||||
let mesh = Mesh {
|
||||
positions: vec![
|
||||
Vec3::new(-10.0, 0.0, -10.0) + offset,
|
||||
Vec3::new(10.0, 0.0, -10.0) + offset,
|
||||
Vec3::new(10.0, 0.0, 10.0) + offset,
|
||||
Vec3::new(-10.0, 0.0, 10.0) + offset,
|
||||
],
|
||||
normals: vec![Vec3::new(0.0, -1.0, 0.0); 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 1],
|
||||
..Default::default()
|
||||
};
|
||||
ProductMesh { name: name.into(), mesh: Arc::new(mesh), color: colour, opacity, surface: None, transmission: None, faces: Vec::new() }
|
||||
}
|
||||
|
||||
fn scene(meshes: Vec<ProductMesh>) -> ProductScene {
|
||||
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
ProductScene { meshes, bounds }
|
||||
}
|
||||
|
||||
fn finish(mut task: ImageTask) -> Vec<u8> {
|
||||
for _ in 0..100_000 {
|
||||
match task.step(4096).unwrap() {
|
||||
TaskPoll::Complete(png) => return png,
|
||||
TaskPoll::Pending(p) => assert!(p.done <= p.total, "{p:?}"),
|
||||
}
|
||||
}
|
||||
panic!("bounded fixture did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transparent_png_has_straight_srgb_colour_without_a_shared_edge_seam() {
|
||||
let scene = scene(vec![square("Glass", [220, 40, 20], 0.5, Vec3::ZERO)]);
|
||||
let png = finish(ImageTask::new(scene, request(), CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [0; 4]);
|
||||
for (x, y) in [(32, 32), (31, 31), (30, 32), (32, 30)] {
|
||||
let p = image.get_pixel(x, y).0;
|
||||
assert!((i16::from(p[3]) - 128).abs() <= 1, "a shared diagonal must not double-blend: {p:?}");
|
||||
assert!(p[0] > 180 && p[0] > p[1] + 60, "RGB is straight, not multiplied by 0.5: {p:?}");
|
||||
}
|
||||
let reader = png::Decoder::new(std::io::Cursor::new(png)).read_info().unwrap();
|
||||
assert_eq!(reader.info().srgb, Some(png::SrgbRenderingIntent::Perceptual));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn glass_is_sorted_back_to_front_independently_of_body_order() {
|
||||
let request = request();
|
||||
let far = square("Far", [240, 20, 20], 0.5, request.camera.back() * -5.0);
|
||||
let near = square("Near", [20, 20, 240], 0.5, request.camera.back() * 5.0);
|
||||
let a = finish(ImageTask::new(scene(vec![far.clone(), near.clone()]), request.clone(), CancelToken::default()).unwrap());
|
||||
let b = finish(ImageTask::new(scene(vec![near, far]), request, CancelToken::default()).unwrap());
|
||||
assert_eq!(a, b);
|
||||
let image = image::load_from_memory(&a).unwrap().to_rgba8();
|
||||
let p = image.get_pixel(32, 32).0;
|
||||
assert!((i16::from(p[3]) - 192).abs() <= 1, "two half-transparent layers: {p:?}");
|
||||
assert!(p[2] > p[0] + 30, "the near blue layer contributes more: {p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn physical_transmission_keeps_the_exact_scalar_cpu_preview() {
|
||||
let original = square("Glass", [80, 180, 140], 0.25, Vec3::ZERO);
|
||||
let mut glass = original.clone();
|
||||
glass.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.2, 0.4, 0.3), 0.0, 0.1, 1.5).unwrap());
|
||||
glass.transmission = Some(crate::transmission::Transmission::new(Vec3::new(-0.7_f64.ln(), -0.9_f64.ln(), 0.0) / 10.0, None).unwrap());
|
||||
let expected = finish(ImageTask::new(scene(vec![original]), request(), CancelToken::default()).unwrap());
|
||||
let actual = finish(ImageTask::new(scene(vec![glass]), request(), CancelToken::default()).unwrap());
|
||||
assert_eq!(actual, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cpu_raytrace_refuses_physical_transmission_before_preparation() {
|
||||
let mut glass = square("Glass", [200; 3], 1.0, Vec3::ZERO);
|
||||
glass.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, Some(1.0)).unwrap());
|
||||
let mut input = request();
|
||||
input.integrator = super::super::Integrator::Raytrace;
|
||||
input.transparent_background = false;
|
||||
let error = admit(&scene(vec![glass]), &input).unwrap_err();
|
||||
assert_eq!(error.code, ErrorCode::InvalidRequest);
|
||||
assert!(error.message.contains("physical transmission"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancellation_is_observed_during_preparation_sort_pixels_and_encoding() {
|
||||
for stage in [Stage::Looks, Stage::Prepare, Stage::Sort, Stage::Clear, Stage::Glass, Stage::Downsample, Stage::Encode] {
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(vec![square("Glass", [40, 180, 100], 0.4, Vec3::ZERO)]), request(), cancel.clone()).unwrap();
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
if task.stage == stage {
|
||||
reached = true;
|
||||
break;
|
||||
}
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
assert!(reached);
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(4096).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encoding_yields_between_rows_and_completed_result_is_consumed_once() {
|
||||
let mut task = ImageTask::new(scene(Vec::new()), request(), CancelToken::default()).unwrap();
|
||||
while task.stage != Stage::Encode {
|
||||
assert!(matches!(task.step(64).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
let before = task.encoder.as_ref().unwrap().row();
|
||||
assert!(matches!(task.step(usize::MAX).unwrap(), TaskPoll::Pending(_)));
|
||||
assert!(task.encoder.as_ref().unwrap().row() - before <= 4);
|
||||
loop {
|
||||
if let TaskPoll::Complete(bytes) = task.step(4096).unwrap() {
|
||||
assert_eq!(image::load_from_memory(&bytes).unwrap().width(), 64);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::NotCompleted);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_sizes_indices_opacity_and_large_work_lists_fail_without_a_frame() {
|
||||
let body = square("Product", [100, 120, 140], 1.0, Vec3::ZERO);
|
||||
let mut bad_request = request();
|
||||
bad_request.width = u32::MAX;
|
||||
assert!(ImageTask::new(scene(vec![body.clone()]), bad_request, CancelToken::default()).is_err());
|
||||
for bad in [0, 1] {
|
||||
let mut body = body.clone();
|
||||
if bad == 0 {
|
||||
Arc::make_mut(&mut body.mesh).triangles[0][0] = u32::MAX;
|
||||
} else {
|
||||
body.faces.push(FaceAppearance { face: 0, color: [0; 3], opacity: f64::NAN, surface: None, transmission: None });
|
||||
}
|
||||
let mut task = ImageTask::new(scene(vec![body]), request(), CancelToken::default()).unwrap();
|
||||
let error = loop {
|
||||
if let Err(error) = task.step(64) {
|
||||
break error;
|
||||
}
|
||||
};
|
||||
assert_eq!(error.code, ErrorCode::InvalidScene);
|
||||
}
|
||||
let mut body = body;
|
||||
Arc::make_mut(&mut body.mesh).triangles.resize(MAX_TRIANGLES as usize + 1, [0, 1, 2]);
|
||||
assert_eq!(ImageTask::new(scene(vec![body]), request(), CancelToken::default()).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
assert_eq!(std::mem::size_of::<Draw>(), 16, "admission accounts for each of the three lists");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registered_executor_geometry_admission_excludes_the_cpu_raster_estimate() {
|
||||
// A library-bounded source: about 100 MiB of face appearances on a small mesh at the
|
||||
// largest image. Its CPU raster estimate is above 384 MiB at a registered executor's cap.
|
||||
let count = (100 * 1024 * 1024 / std::mem::size_of::<FaceAppearance>()).min(1_000_000);
|
||||
let mut body = square("appearances", [200; 3], 1.0, Vec3::ZERO);
|
||||
body.faces = vec![FaceAppearance { transmission: None, face: 0, color: [200; 3], opacity: 1.0, surface: None }; count];
|
||||
let source = scene(vec![body]);
|
||||
let mut r = request();
|
||||
r.width = 2048;
|
||||
r.height = 2048;
|
||||
let cpu = admit_raster(admit_source(&source, &r, 1_048_576).unwrap(), &r).unwrap_err();
|
||||
assert_eq!(cpu.code, ErrorCode::LimitExceeded);
|
||||
assert!(cpu.message.contains("384 MiB"), "{}", cpu.message);
|
||||
let geometry = admit_geometry(&source, &r, 1_048_576).unwrap();
|
||||
assert_eq!((geometry.pixel_scratch_bytes, geometry.preparation_bytes), (0, 0));
|
||||
assert_eq!(geometry.estimated_total_bytes, geometry.geometry_bytes);
|
||||
assert_eq!(geometry.face_appearances, count as u64);
|
||||
// The CPU host itself keeps rejecting the source.
|
||||
assert_eq!(admit(&source, &r).unwrap_err().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
// Original fixture: a plane at x=40, with exact +X normals. The perspective
|
||||
// camera looks diagonally from (50/sqrt(2), -50/sqrt(2), 0). Its actual eye is
|
||||
// on the -X side of this plane, although camera.back has a positive X component.
|
||||
// The wide field of view keeps the off-axis plane in the image.
|
||||
fn weighted_matte_view_scene(explicit: bool) -> ProductScene {
|
||||
let color = [96, 160, 220];
|
||||
let mut part = square("weighted matte plane", color, 1.0, Vec3::ZERO);
|
||||
let mesh = Arc::make_mut(&mut part.mesh);
|
||||
for p in &mut mesh.positions {
|
||||
*p = Vec3::new(40.0, p.x + 10.0, p.z);
|
||||
}
|
||||
mesh.normals = vec![Vec3::X; 4];
|
||||
if explicit {
|
||||
let [r, g, b] = color.map(decode);
|
||||
part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(r, g, b), 0.0, 1.0, 1.5).unwrap());
|
||||
}
|
||||
scene(vec![part])
|
||||
}
|
||||
|
||||
fn weighted_matte_view_request(perspective: bool) -> ImageRequest {
|
||||
let mut input = request();
|
||||
input.camera.yaw = -std::f64::consts::FRAC_PI_4;
|
||||
input.camera.distance = if perspective { 50.0 } else { 100.0 };
|
||||
input.camera.fov = if perspective { 2.4 } else { 0.0 };
|
||||
input.transparent_background = false;
|
||||
// Deliberately not equal: accidentally using light weights instead of
|
||||
// perspective barycentric weights must not be an equivalent calculation.
|
||||
input.studio_weights = Some([1.0, 0.35, 0.8]);
|
||||
input
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weighted_scalar_matte_uses_the_same_perspective_view_as_its_explicit_surface() {
|
||||
let input = weighted_matte_view_request(true);
|
||||
assert!(input.camera.back().x > 0.0 && input.camera.eye().x < 40.0);
|
||||
let scalar = finish(ImageTask::new(weighted_matte_view_scene(false), input.clone(), CancelToken::default()).unwrap());
|
||||
let explicit = finish(ImageTask::new(weighted_matte_view_scene(true), input, CancelToken::default()).unwrap());
|
||||
// Same admitted geometry, exact unit-axis normals, colour decoder, matte
|
||||
// response, lights, camera, buffers and encoder. No tolerance or golden.
|
||||
assert_eq!(scalar, explicit);
|
||||
let image = image::load_from_memory(&scalar).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
// Actual view is behind +X everywhere on the plane, so the existing
|
||||
// one-sided BRDF returns zero. This also proves visible product coverage.
|
||||
assert!(image.pixels().any(|pixel| pixel.0 == [0, 0, 0, 255]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weighted_scalar_matte_keeps_exact_orthographic_surface_equivalence() {
|
||||
let input = weighted_matte_view_request(false);
|
||||
let scalar = finish(ImageTask::new(weighted_matte_view_scene(false), input.clone(), CancelToken::default()).unwrap());
|
||||
let explicit = finish(ImageTask::new(weighted_matte_view_scene(true), input, CancelToken::default()).unwrap());
|
||||
assert_eq!(scalar, explicit);
|
||||
let image = image::load_from_memory(&scalar).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
assert!(image.pixels().any(|pixel| pixel.0 != [20, 40, 60, 255] && pixel.0 != [0, 0, 0, 255]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weighted_scalar_matte_mute_still_removes_only_product_light() {
|
||||
let mut input = weighted_matte_view_request(false);
|
||||
let lit = finish(ImageTask::new(weighted_matte_view_scene(false), input.clone(), CancelToken::default()).unwrap());
|
||||
input.studio_weights = Some([0.0; 3]);
|
||||
let muted = finish(ImageTask::new(weighted_matte_view_scene(false), input, CancelToken::default()).unwrap());
|
||||
assert_ne!(lit, muted);
|
||||
for bytes in [&lit, &muted] {
|
||||
let image = image::load_from_memory(bytes).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
}
|
||||
let image = image::load_from_memory(&muted).unwrap().to_rgba8();
|
||||
assert!(image.pixels().any(|pixel| pixel.0 == [0, 0, 0, 255]));
|
||||
}
|
||||
|
||||
// Original analytic reciprocal-w oracle: the expected surface point is found
|
||||
// by intersecting a closed-form camera ray with a plane, not by asking either
|
||||
// raster shading branch to interpolate world coordinates for the other.
|
||||
#[test]
|
||||
fn weighted_scalar_perspective_uses_closed_form_ray_plane_world_with_unequal_clip_w() {
|
||||
let vertices = [Vec3::new(-7.0 / 4.0, -8.0, 7.0 / 4.0), Vec3::new(1.0 / 2.0, -6.0, 7.0 / 2.0), Vec3::new(-3.0, -2.0, -1.0)];
|
||||
// The reversed winding faces the eye. This smooth normal is in the
|
||||
// geometric hemisphere and deliberately separates the three view oracles.
|
||||
let normal = Vec3::new(3.0, 1.0, 0.0) / 10.0_f64.sqrt();
|
||||
let part = ProductMesh {
|
||||
name: "analytic reciprocal-w matte".into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions: vertices.to_vec(),
|
||||
normals: vec![normal; 3],
|
||||
triangles: vec![[0, 2, 1]],
|
||||
tri_face: vec![0],
|
||||
..Default::default()
|
||||
}),
|
||||
color: [0; 3],
|
||||
opacity: 1.0,
|
||||
surface: None,
|
||||
transmission: None,
|
||||
faces: Vec::new(),
|
||||
};
|
||||
let mut input = request();
|
||||
input.width = 4;
|
||||
input.height = 4;
|
||||
input.camera =
|
||||
Camera { target: Vec3::ZERO, yaw: 0.0, pitch: 0.0, roll: 0.0, distance: 10.0, fov: std::f64::consts::FRAC_PI_2, up: crate::UpAxis::Z };
|
||||
input.transparent_background = false;
|
||||
let light_weights = [1.0, 0.35, 0.8];
|
||||
input.studio_weights = Some(light_weights);
|
||||
let mut task = ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap();
|
||||
assert_eq!((task.sw, task.sh), (8, 8));
|
||||
let eye = Vec3::new(0.0, -10.0, 0.0);
|
||||
let back = Vec3::new(0.0, -1.0, 0.0);
|
||||
assert_eq!(task.request.camera.eye(), eye);
|
||||
assert_eq!(task.back, back);
|
||||
|
||||
// Actual production projection of [A,C,B], not a hand-filled Triangle.
|
||||
// With tan(fov/2)=1, clip w is depth from the eye: [2,8,4].
|
||||
let projected = task.project(Draw::default()).unwrap().unwrap();
|
||||
assert!(projected.surface.is_none());
|
||||
let expected_points = [[0.5, 0.5], [2.5, 4.5], [4.5, 0.5]];
|
||||
for ((actual, expected), (actual_inv_w, expected_inv_w)) in
|
||||
projected.points.iter().zip(expected_points).zip(projected.inv_w.iter().zip([0.5, 0.125, 0.25]))
|
||||
{
|
||||
assert!((actual[0] - expected[0]).abs() < 1e-12);
|
||||
assert!((actual[1] - expected[1]).abs() < 1e-12);
|
||||
assert!((*actual_inv_w - expected_inv_w).abs() < 1e-12);
|
||||
}
|
||||
assert_eq!(projected.world, [vertices[0], vertices[2], vertices[1]]);
|
||||
|
||||
// Pixel sample (2.5,2.5) gives the analytic forward ray
|
||||
// E + t*(-3/8,1,3/8). The triangle plane is 4x-y-4z=-6:
|
||||
// plane(E)=10 and plane(ray)=-4, hence t=4 exactly.
|
||||
let plane = Vec3::new(4.0, -1.0, -4.0);
|
||||
assert_eq!((vertices[2] - vertices[0]).cross(vertices[1] - vertices[0]), plane * 4.0);
|
||||
assert!(normal.dot(plane) > 0.0);
|
||||
for vertex in vertices {
|
||||
assert_eq!(plane.dot(vertex), -6.0);
|
||||
}
|
||||
let ray = Vec3::new(-3.0 / 8.0, 1.0, 3.0 / 8.0);
|
||||
assert_eq!(plane.dot(eye), 10.0);
|
||||
assert_eq!(plane.dot(ray), -4.0);
|
||||
let expected_world = Vec3::new(-3.0 / 2.0, -6.0, 3.0 / 2.0);
|
||||
assert_eq!(eye + ray * 4.0, expected_world);
|
||||
let expected_view = Vec3::new(3.0 / 2.0, -4.0, -3.0 / 2.0);
|
||||
assert_eq!(eye - expected_world, expected_view);
|
||||
// Screen barycentrics [1/4,1/2,1/4] and clip w [2,8,4]
|
||||
// imply world barycentrics [1/2,1/4,1/4]. An AFFINE world
|
||||
// would instead be (-29/16,-9/2,13/16), a different camera ray.
|
||||
let affine_world = Vec3::new(-29.0 / 16.0, -9.0 / 2.0, 13.0 / 16.0);
|
||||
let affine_view = eye - affine_world;
|
||||
assert!((normal.dot(expected_view) - 1.0 / (2.0 * 10.0_f64.sqrt())).abs() < 1e-14);
|
||||
assert!((normal.dot(affine_view) + 1.0 / (16.0 * 10.0_f64.sqrt())).abs() < 1e-14);
|
||||
assert!(normal.dot(back) < 0.0);
|
||||
|
||||
// Black base removes diffuse but retains dielectric Fresnel. Only the
|
||||
// key light is above this normal. For roughness=1, D=1/pi and Smith
|
||||
// visibility reduces to 1/((1+nv)*(1+nl)). F0=(1/5)^2.
|
||||
let nv = 1.0 / 820.0_f64.sqrt();
|
||||
let nl = 9.0 / (5.0 * 10.0_f64.sqrt());
|
||||
let vh = ((1.0 - 3.0 / (5.0 * 82.0_f64.sqrt())) / 2.0).sqrt();
|
||||
let fresnel = 1.0 / 25.0 + (24.0 / 25.0) * (1.0 - vh).powi(5);
|
||||
let expected_radiance = 3.0 * nl * fresnel / (std::f64::consts::PI * (1.0 + nv) * (1.0 + nl));
|
||||
let matte = crate::surface::OpaqueSurface::new(Vec3::ZERO, 0.0, 1.0, 1.5).unwrap();
|
||||
let reference = crate::studio::shade_weighted(matte, normal, expected_view, light_weights).unwrap();
|
||||
assert!((reference - Vec3::new(expected_radiance, expected_radiance, expected_radiance)).len() < 1e-14);
|
||||
assert_eq!(crate::studio::shade_weighted(matte, normal, affine_view, light_weights).unwrap(), Vec3::ZERO);
|
||||
assert_eq!(crate::studio::shade_weighted(matte, normal, back, light_weights).unwrap(), Vec3::ZERO);
|
||||
|
||||
// The original radical expression gives radiance0.0144120124528...
|
||||
// Reinhard then sRGB yields31.6843707068... on the8-bit scale, hence32.
|
||||
// Inspect the real production supersample before downsampling; no fake
|
||||
// renderer, injected pixel, shared-branch PNG equality or golden is used.
|
||||
for _ in 0..2048 {
|
||||
if task.stage == Stage::Downsample {
|
||||
break;
|
||||
}
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
assert!(task.stage == Stage::Downsample);
|
||||
let sample = 2 * task.sw + 2;
|
||||
assert!(task.depth[sample].is_finite(), "the analytic sample must be covered");
|
||||
assert_eq!(task.pixels[sample], [32, 32, 32, 255]);
|
||||
// Finish through the ordinary encoder as well; the unoccupied corner
|
||||
// remains the original opaque background.
|
||||
let png = finish(task);
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
assert_eq!((image.width(), image.height()), (4, 4));
|
||||
assert_eq!(image.get_pixel(3, 3).0, [20, 40, 60, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_raster_linear_rgb_reaches_png_with_one_display_transfer() {
|
||||
let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO);
|
||||
part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap());
|
||||
let mut input = request();
|
||||
// Orthographic Front is exactly normal to the square, so no perspective-view approximation.
|
||||
assert_eq!(input.camera.fov, 0.0);
|
||||
input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]);
|
||||
let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Independently derived: [.4,.5,.5]/pi -> Reinhard -> piecewise sRGB -> nearest byte.
|
||||
for (x, y) in [(32, 32), (31, 32), (32, 31)] {
|
||||
assert_eq!(image.get_pixel(x, y).0, [94, 104, 104, 255]);
|
||||
}
|
||||
assert_eq!(image.get_pixel(0, 0).0, [0; 4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_raster_three_four_five_cosine_reaches_png() {
|
||||
let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO);
|
||||
part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap());
|
||||
let mut input = request();
|
||||
input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [3.0, -4.0, 0.0], color: [1.0; 3], intensity: 2.0 }]);
|
||||
let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Independently derived: [1.28,.8,.4]/pi -> Reinhard -> sRGB.
|
||||
assert_eq!(image.get_pixel(32, 32).0, [146, 124, 94, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_empty_raster_rig_is_dark_while_absence_keeps_legacy() {
|
||||
let part = scene(vec![square("part", [200, 180, 160], 1.0, Vec3::ZERO)]);
|
||||
let mut input = request();
|
||||
input.transparent_background = false;
|
||||
let absent = finish(ImageTask::new(part.clone(), input.clone(), CancelToken::default()).unwrap());
|
||||
let wire = serde_json::to_value(&input).unwrap();
|
||||
assert!(wire.get("raster_lights").is_none());
|
||||
let mut null = wire.clone();
|
||||
null["raster_lights"] = serde_json::Value::Null;
|
||||
let legacy: ImageRequest = serde_json::from_value(null).unwrap();
|
||||
assert_eq!(finish(ImageTask::new(part.clone(), legacy, CancelToken::default()).unwrap()), absent);
|
||||
input.raster_lights = Some(Vec::new());
|
||||
let dark = finish(ImageTask::new(part, input, CancelToken::default()).unwrap());
|
||||
assert_ne!(dark, absent);
|
||||
let image = image::load_from_memory(&dark).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]);
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_raster_request_rejects_capacity_conflicts_and_foreign_integrators() {
|
||||
let part = scene(vec![square("part", [200; 3], 1.0, Vec3::ZERO)]);
|
||||
let light = crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 };
|
||||
let mut input = request();
|
||||
let mut oversized = Vec::with_capacity(9);
|
||||
oversized.push(light);
|
||||
input.raster_lights = Some(oversized);
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
input.raster_lights = Some(Vec::new());
|
||||
input.studio_weights = Some([1.0; 3]);
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
input.studio_weights = None;
|
||||
input.raytrace = Some(Default::default());
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
input.raytrace = None;
|
||||
input.integrator = crate::job::Integrator::Raytrace;
|
||||
assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_raster_scalar_surrogate_preserves_straight_alpha_without_claiming_glass() {
|
||||
let part = square("scalar", [0; 3], 0.5, Vec3::ZERO);
|
||||
let mut input = request();
|
||||
input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 2.0 }]);
|
||||
let png = finish(ImageTask::new(scene(vec![part.clone()]), input.clone(), CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Scalar surrogate rho=0, IOR=1.5, roughness=1: F0/4pi=.01/pi.
|
||||
// Intensity2 gives .02/pi; Reinhard + sRGB independently rounds to19.
|
||||
assert_eq!(image.get_pixel(32, 32).0, [19, 19, 19, 128]);
|
||||
let mut physical = part;
|
||||
physical.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, None).unwrap());
|
||||
assert_eq!(admit(&scene(vec![physical]), &input).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
}
|
||||
#[test]
|
||||
fn direct_raster_task_accounts_empty_rig_capacity_without_changing_dark_or_legacy_paths() {
|
||||
let part = scene(vec![square("part", [200; 3], 1.0, Vec3::ZERO)]);
|
||||
let legacy = request();
|
||||
let legacy_bytes = admit(&part, &legacy).unwrap().estimated_total_bytes;
|
||||
assert!(ImageTask::new(part.clone(), legacy, CancelToken::default()).unwrap().request.raster_lights.is_none());
|
||||
let fee = (8 * std::mem::size_of::<crate::job::DirectionalLightOptions>()) as u64;
|
||||
let mut dark_png = None;
|
||||
for capacity in [0, 8] {
|
||||
let mut input = request();
|
||||
input.raster_lights = Some(Vec::with_capacity(capacity));
|
||||
let retained_capacity = input.raster_lights.as_ref().unwrap().capacity();
|
||||
assert!(retained_capacity >= capacity && retained_capacity <= 8);
|
||||
let actual_bytes = (retained_capacity * std::mem::size_of::<crate::job::DirectionalLightOptions>()) as u64;
|
||||
let admitted = admit(&part, &input).unwrap();
|
||||
assert_eq!(admitted.estimated_total_bytes, legacy_bytes + fee);
|
||||
assert!(admitted.estimated_total_bytes - legacy_bytes >= actual_bytes);
|
||||
// This is the public direct constructor, not host try_copy/Record fees.
|
||||
let task = ImageTask::new(part.clone(), input, CancelToken::default()).unwrap();
|
||||
assert_eq!(task.request.raster_lights.as_ref().unwrap().capacity(), retained_capacity);
|
||||
assert_eq!(task.admission.estimated_total_bytes, legacy_bytes + fee);
|
||||
let png = finish(task);
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]);
|
||||
if let Some(expected) = &dark_png {
|
||||
assert_eq!(&png, expected);
|
||||
} else {
|
||||
dark_png = Some(png);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn raster_local_triangle() -> Triangle {
|
||||
let surface = crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap();
|
||||
Triangle {
|
||||
points: [[-1.0, -1.0, 0.5], [3.0, -1.0, 0.5], [-1.0, 3.0, 0.5]],
|
||||
world: [Vec3::new(-1.0, 0.0, 1.0), Vec3::new(3.0, 0.0, 1.0), Vec3::new(-1.0, 0.0, -3.0)],
|
||||
normals: [-Vec3::Y; 3],
|
||||
inv_w: [1.0; 3],
|
||||
colour: [0.0; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(surface),
|
||||
centre_depth: 0.0,
|
||||
area: 16.0,
|
||||
bounds: [0, 0, 0, 0],
|
||||
x: 0,
|
||||
y: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn raster_local_point() -> crate::job::PunctualLightOptions {
|
||||
crate::job::PunctualLightOptions {
|
||||
position_mm: [0.5, -10.0, -0.5],
|
||||
color: [0.25, 0.5, 1.0],
|
||||
intensity: 2.0,
|
||||
reference_distance_mm: 10.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn raster_local_area() -> crate::job::RectangleLightOptions {
|
||||
crate::job::RectangleLightOptions {
|
||||
center_mm: [0.5, -10.0, -0.5],
|
||||
edge_u_mm: [2.0, 0.0, 0.0],
|
||||
edge_v_mm: [0.0, 0.0, -2.0],
|
||||
color: [0.25, 0.5, 1.0],
|
||||
intensity: 2.0,
|
||||
}
|
||||
}
|
||||
|
||||
fn raster_local_pixel(triangle: &Triangle, input: &ImageRequest) -> [u8; 4] {
|
||||
let mut pixels = [[0; 4]];
|
||||
let mut depth = [f32::INFINITY];
|
||||
raster_pixel(triangle, 1, -Vec3::Y, None, input, &mut pixels, &mut depth).unwrap();
|
||||
pixels[0]
|
||||
}
|
||||
|
||||
fn raster_local_expected(numerators: [f64; 3]) -> [u8; 4] {
|
||||
let rgb = numerators.map(|n| {
|
||||
let linear = n / std::f64::consts::PI;
|
||||
solidcraft_geom::srgb::encode8(linear / (1.0 + linear))
|
||||
});
|
||||
[rgb[0], rgb[1], rgb[2], 255]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_point_pixel_matches_independent_lambert_and_single_exposure_oracles() {
|
||||
// Affine barycentrics (1/4,3/8,3/8) put this sample at(.5,0,-.5).
|
||||
// Point is10mm along the normal, at its10mm reference: RGB*rho*I/pi.
|
||||
let mut input = request();
|
||||
input.raster_punctual_lights = Some(vec![raster_local_point()]);
|
||||
for (ev, expected) in [(-1.0, [69, 77, 77, 255]), (0.0, [94, 104, 104, 255]), (1.0, [124, 135, 135, 255])] {
|
||||
input.raster_exposure_ev = ev;
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), expected);
|
||||
}
|
||||
input.raster_exposure_ev = 0.0;
|
||||
input.raster_punctual_lights.as_mut().unwrap()[0].position_mm[1] = -20.0;
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), raster_local_expected([0.1, 0.125, 0.125]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_spot_area_and_mixed_pixels_have_original_closed_form_contributions() {
|
||||
let mut point = raster_local_point();
|
||||
point.cone = Some(crate::job::SpotConeOptions {
|
||||
emitted_axis: [3.0_f64.sqrt(), 1.0, 0.0],
|
||||
inner_half_angle_radians: 0.8_f64.acos(),
|
||||
outer_half_angle_radians: 0.2_f64.acos(),
|
||||
});
|
||||
let mut input = request();
|
||||
input.raster_punctual_lights = Some(vec![point]);
|
||||
// Axis cosine1/2 lies halfway between(4/5,1/5), so smoothstep=1/2.
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), raster_local_expected([0.2, 0.25, 0.25]));
|
||||
input.raster_punctual_lights = None;
|
||||
input.raster_area_lights = Some(vec![raster_local_area()]);
|
||||
// Area4 * I2 / r^2(100) =.08 before rho*colour/pi.
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), raster_local_expected([0.016, 0.02, 0.02]));
|
||||
input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }]);
|
||||
input.raster_punctual_lights = Some(vec![raster_local_point()]);
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), raster_local_expected([1.216, 1.02, 0.77]));
|
||||
input.raster_lights = None;
|
||||
input.raster_punctual_lights = None;
|
||||
input.raster_area_lights.as_mut().unwrap()[0].edge_v_mm = [0.0, 0.0, 2.0];
|
||||
assert_eq!(raster_local_pixel(&raster_local_triangle(), &input), [0, 0, 0, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_pixel_uses_reciprocal_w_world_position_and_zero_coincidence_policy() {
|
||||
let mut triangle = raster_local_triangle();
|
||||
triangle.inv_w = [1.0, 2.0, 8.0];
|
||||
// Weighted world=(-1/4,0,-2), not the affine(.5,0,-.5).
|
||||
let mut point = raster_local_point();
|
||||
point.position_mm = [-0.25, -1.0, -2.0];
|
||||
point.reference_distance_mm = 1.0;
|
||||
point.color = [1.0; 3];
|
||||
let mut input = request();
|
||||
input.raster_punctual_lights = Some(vec![point]);
|
||||
assert_eq!(raster_local_pixel(&triangle, &input), raster_local_expected([1.6, 1.0, 0.5]));
|
||||
input.raster_punctual_lights.as_mut().unwrap()[0].position_mm = [-0.25, 0.0, -2.0];
|
||||
assert_eq!(raster_local_pixel(&triangle, &input), [0, 0, 0, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_real_task_empty_rig_is_dark_and_null_keeps_exact_legacy_png() {
|
||||
let part = scene(vec![square("opaque", [200, 180, 160], 1.0, Vec3::ZERO)]);
|
||||
let mut input = request();
|
||||
input.transparent_background = false;
|
||||
let legacy = finish(ImageTask::new(part.clone(), input.clone(), CancelToken::default()).unwrap());
|
||||
let mut wire = serde_json::to_value(&input).unwrap();
|
||||
wire["raster_punctual_lights"] = serde_json::Value::Null;
|
||||
wire["raster_area_lights"] = serde_json::Value::Null;
|
||||
let decoded: ImageRequest = serde_json::from_value(wire).unwrap();
|
||||
assert_eq!(finish(ImageTask::new(part.clone(), decoded, CancelToken::default()).unwrap()), legacy);
|
||||
for family in [0, 1] {
|
||||
let mut explicit = input.clone();
|
||||
if family == 0 {
|
||||
explicit.raster_punctual_lights = Some(Vec::new());
|
||||
} else {
|
||||
explicit.raster_area_lights = Some(Vec::new());
|
||||
}
|
||||
let png = finish(ImageTask::new(part.clone(), explicit, CancelToken::default()).unwrap());
|
||||
let image = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]);
|
||||
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
|
||||
assert_ne!(png, legacy);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_real_task_admits_spare_capacity_and_refuses_physical_transmission() {
|
||||
let part = scene(vec![square("opaque", [200; 3], 1.0, Vec3::ZERO)]);
|
||||
let mut input = request();
|
||||
let legacy_bytes = admit(&part, &input).unwrap().estimated_total_bytes;
|
||||
input.raster_punctual_lights = Some(Vec::with_capacity(8));
|
||||
input.raster_area_lights = Some(Vec::with_capacity(4));
|
||||
let fee = (8 * std::mem::size_of::<crate::job::PunctualLightOptions>() + 4 * std::mem::size_of::<crate::job::RectangleLightOptions>()) as u64;
|
||||
assert_eq!(admit(&part, &input).unwrap().estimated_total_bytes, legacy_bytes + fee);
|
||||
let capacities = (input.raster_punctual_lights.as_ref().unwrap().capacity(), input.raster_area_lights.as_ref().unwrap().capacity());
|
||||
let task = ImageTask::new(part, input, CancelToken::default()).unwrap();
|
||||
assert_eq!(task.request.raster_punctual_lights.as_ref().unwrap().capacity(), capacities.0);
|
||||
assert_eq!(task.request.raster_area_lights.as_ref().unwrap().capacity(), capacities.1);
|
||||
assert_eq!(task.admission.estimated_total_bytes, legacy_bytes + fee);
|
||||
let mut physical = square("physical", [200; 3], 1.0, Vec3::ZERO);
|
||||
physical.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, None).unwrap());
|
||||
assert_eq!(admit(&scene(vec![physical]), &task.request).unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_light_work_remains_inside_original_cap_and_step_cancellation() {
|
||||
let part = scene(vec![square("opaque", [200; 3], 1.0, Vec3::ZERO)]);
|
||||
let mut legacy = request();
|
||||
legacy.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }]);
|
||||
let mut local = legacy.clone();
|
||||
local.raster_punctual_lights = Some(vec![raster_local_point()]);
|
||||
local.raster_area_lights = Some(vec![raster_local_area()]);
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(part.clone(), local, cancel.clone()).unwrap();
|
||||
let triangle = task.project(Draw { body: 0, triangle: 0, depth: 0.0 }).unwrap().unwrap();
|
||||
let [x0, x1, y0, y1] = triangle.bounds;
|
||||
let pixels = ((x1 - x0 + 1) * (y1 - y0 + 1)) as u64;
|
||||
task.pixel_tests = MAX_PIXEL_TESTS - pixels * 3 + 1;
|
||||
assert_eq!(task.prepare_step().unwrap_err().code, ErrorCode::LimitExceeded);
|
||||
let mut old_task = ImageTask::new(part, legacy, CancelToken::default()).unwrap();
|
||||
old_task.pixel_tests = MAX_PIXEL_TESTS - pixels * 3 + 1;
|
||||
old_task.prepare_step().unwrap();
|
||||
assert_eq!(old_task.pixel_tests, MAX_PIXEL_TESTS - pixels * 2 + 1, "directional-only budget is unchanged");
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raster_local_running_progress_counts_pixel_visits_and_reaches_total_before_encoding() {
|
||||
// Cost is1 for unchanged implicit/directional-only routes,3 for the minimal
|
||||
// mixed rig and20 for8D+8 shared point/spot+4area. Progress counts actual
|
||||
// clear/draw/downsample visits, never BRDF evaluations or light intensity.
|
||||
for (factor, directional_count, punctual_count, area_count) in [(1u64, 0usize, 0usize, 0usize), (1, 1, 0, 0), (3, 1, 1, 1), (20, 8, 8, 4)] {
|
||||
let mut input = request();
|
||||
input.width = 8;
|
||||
input.height = 8;
|
||||
if directional_count > 0 {
|
||||
input.raster_lights =
|
||||
Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }; directional_count]);
|
||||
}
|
||||
if punctual_count > 0 {
|
||||
let mut points = vec![raster_local_point(); punctual_count];
|
||||
points[punctual_count - 1].cone =
|
||||
Some(crate::job::SpotConeOptions { emitted_axis: [0.0, 1.0, 0.0], inner_half_angle_radians: 0.2, outer_half_angle_radians: 0.5 });
|
||||
input.raster_punctual_lights = Some(points);
|
||||
}
|
||||
if area_count > 0 {
|
||||
input.raster_area_lights = Some(vec![raster_local_area(); area_count]);
|
||||
}
|
||||
let back = input.camera.back();
|
||||
let part = scene(vec![
|
||||
square("opaque", [160; 3], 1.0, Vec3::ZERO),
|
||||
square("alpha far", [160; 3], 0.5, back * -5.0),
|
||||
square("alpha nearer", [160; 3], 0.5, back * -3.0),
|
||||
]);
|
||||
let mut task = ImageTask::new(part, input, CancelToken::default()).unwrap();
|
||||
for _ in 0..100_000 {
|
||||
if task.stage == Stage::Clear {
|
||||
break;
|
||||
}
|
||||
assert!(matches!(task.stage, Stage::Looks | Stage::Prepare | Stage::Sort));
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
assert!(task.stage == Stage::Clear, "bounded fixture must finish preparation");
|
||||
let mut bbox_visits = 0u64;
|
||||
for draw in task.opaque.iter().chain(&task.glass) {
|
||||
let triangle = task.project(*draw).unwrap().unwrap();
|
||||
let [x0, x1, y0, y1] = triangle.bounds;
|
||||
bbox_visits += ((x1 - x0 + 1) * (y1 - y0 + 1)) as u64;
|
||||
}
|
||||
assert!(bbox_visits > 0);
|
||||
assert_eq!(task.pixel_tests, bbox_visits * factor, "weighted128M work guard remains authoritative");
|
||||
let clear_visits = (task.sw * task.sh) as u64;
|
||||
let output_visits = u64::from(task.request.width) * u64::from(task.request.height);
|
||||
let expected_total = clear_visits + bbox_visits + output_visits;
|
||||
let mut last_done = 0;
|
||||
let mut saw_opaque = false;
|
||||
let mut saw_downsample = false;
|
||||
let mut saw_running_complete = false;
|
||||
for _ in 0..100_000 {
|
||||
if task.stage == Stage::Encode {
|
||||
break;
|
||||
}
|
||||
let progress = task.progress();
|
||||
assert_eq!(progress.phase, Phase::Running);
|
||||
assert_eq!(progress.total, expected_total, "total must not scale with {factor} lights");
|
||||
assert!(progress.done >= last_done && progress.done <= progress.total);
|
||||
if !saw_opaque && task.stage == Stage::Opaque {
|
||||
assert_eq!(progress.done, clear_visits, "clear units unchanged");
|
||||
saw_opaque = true;
|
||||
}
|
||||
if !saw_downsample && task.stage == Stage::Downsample {
|
||||
assert_eq!(progress.done, clear_visits + bbox_visits, "every projected visit completed before downsample");
|
||||
saw_downsample = true;
|
||||
}
|
||||
if progress.done == progress.total {
|
||||
saw_running_complete = true;
|
||||
}
|
||||
last_done = progress.done;
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
assert!(task.stage == Stage::Encode);
|
||||
assert!(saw_opaque && saw_downsample && saw_running_complete, "Running must reach its boundary before Encoding");
|
||||
assert_eq!(last_done, expected_total);
|
||||
assert_eq!(task.pixel_done, expected_total);
|
||||
assert_eq!(task.progress().phase, Phase::Encoding);
|
||||
let png = finish(task);
|
||||
assert_eq!(image::load_from_memory(&png).unwrap().to_rgba8().dimensions(), (8, 8));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_cpu_preview_cadence_roundtrips_without_saved_sampling_or_nested_aliases() {
|
||||
let mut input = request();
|
||||
input.integrator = super::super::Integrator::Raytrace;
|
||||
input.transparent_background = false;
|
||||
input.raytrace = Some(super::super::RaytraceOptions {
|
||||
progressive: Some(super::super::CpuProgressiveOptions { samples_per_pixel: 5, seed: 13 }),
|
||||
..Default::default()
|
||||
});
|
||||
for every_pass in [true, false] {
|
||||
input.cpu_progressive_every_pass = every_pass;
|
||||
let wire = serde_json::to_value(&input).unwrap();
|
||||
assert_eq!(wire.get("cpu_progressive_every_pass"), (!every_pass).then_some(&serde_json::Value::Bool(false)));
|
||||
assert!(wire["raytrace"].get("cpu_progressive_every_pass").is_none());
|
||||
let decoded: ImageRequest = serde_json::from_value(wire).unwrap();
|
||||
assert_eq!(decoded.cpu_progressive_every_pass, every_pass);
|
||||
assert_eq!(decoded.raytrace.as_ref().unwrap().progressive, input.raytrace.as_ref().unwrap().progressive);
|
||||
assert_eq!(decoded.try_clone_for_host().unwrap().cpu_progressive_every_pass, every_pass);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
#[test]
|
||||
fn legacy_protected_feedback_restores_the_original_global_distribution_and_sixty_four_cap() {
|
||||
use super::super::{CpuBudget, ProtectedPreviewPlan};
|
||||
let tiny = ProtectedPreviewPlan::with_cadence(2, 1, 5, CpuBudget::Compact, false).unwrap();
|
||||
assert_eq!(tiny.quota_limit(), 9);
|
||||
assert_eq!((0..9).map(|index| tiny.milestone(index).unwrap()).collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||
let plan = ProtectedPreviewPlan::with_cadence(65, 1, 3, CpuBudget::Compact, false).unwrap();
|
||||
plan.validate().unwrap();
|
||||
assert_eq!(plan.quota_limit(), 64);
|
||||
assert_eq!([0, 1, 31, 32, 63].map(|index| plan.milestone(index).unwrap()), [1, 4, 95, 99, 194]);
|
||||
let milestones: Vec<_> = (0..64).map(|index| plan.milestone(index).unwrap()).collect();
|
||||
for committed in 0..=195 {
|
||||
let expected = milestones.iter().filter(|&&milestone| milestone <= committed).count() as u32;
|
||||
assert_eq!(plan.reached_milestones(committed).unwrap(), expected);
|
||||
}
|
||||
assert!(plan.reached_milestones(196).is_err());
|
||||
assert!(plan.milestone(64).is_err());
|
||||
assert_eq!(plan.presentation_limit().unwrap(), 64 * plan.snapshot_work().unwrap());
|
||||
assert_eq!(plan.ordinary_limit(), CpuBudget::Compact.limits().max_work_units);
|
||||
let single = ProtectedPreviewPlan::with_cadence(1, 1, 1, CpuBudget::Compact, false).unwrap();
|
||||
assert_eq!((single.quota_limit(), single.reached_milestones(1).unwrap()), (0, 0));
|
||||
let one = ProtectedPreviewPlan::with_cadence(1, 1, 2, CpuBudget::Compact, false).unwrap();
|
||||
assert_eq!((one.quota_limit(), one.milestone(0).unwrap(), one.reached_milestones(1).unwrap()), (1, 1, 1));
|
||||
let high = ProtectedPreviewPlan::with_cadence(1, 1, 1_048_576, CpuBudget::Workstation, false).unwrap();
|
||||
assert_eq!((high.quota_limit(), high.milestone(63).unwrap()), (64, 1_048_575));
|
||||
assert_eq!(high.reached_milestones(1_048_576).unwrap(), 64);
|
||||
let current = ProtectedPreviewPlan::new(65, 1, 3, CpuBudget::Compact).unwrap();
|
||||
assert_eq!(current.quota_limit(), 66);
|
||||
}
|
||||
+259
@@ -0,0 +1,259 @@
|
||||
use super::*;
|
||||
|
||||
fn strip() -> LedStripOptions {
|
||||
LedStripOptions {
|
||||
center_mm: [0.0, 0.0, 10.0],
|
||||
length_mm: 8.0,
|
||||
width_mm: 0.5,
|
||||
length_axis: [1.0, 0.0, 0.0],
|
||||
width_axis: [0.0, -1.0, 0.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 2.0,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimensions_and_orientation_lower_without_power_multiplier() {
|
||||
let rectangle = strip().rectangle().unwrap();
|
||||
assert_eq!(rectangle.edge_u_mm, [8.0, 0.0, 0.0]);
|
||||
assert_eq!(rectangle.edge_v_mm, [0.0, -0.5, 0.0]);
|
||||
assert_eq!(rectangle.intensity, 2.0);
|
||||
assert_eq!(rectangle.color, [1.0, 0.5, 0.25]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_hostile_geometry_radiance_and_unsupported_pitch() {
|
||||
for bad in [f64::NAN, f64::INFINITY, -1.0, 0.0, 1e-7, 1e6 + 1.0] {
|
||||
assert!(LedStripOptions { length_mm: bad, ..strip() }.rectangle().is_err());
|
||||
assert!(LedStripOptions { width_mm: bad, ..strip() }.rectangle().is_err());
|
||||
}
|
||||
for axis in [[0.0; 3], [2.0, 0.0, 0.0], [f64::NAN, 0.0, 0.0], [0.0, -1.0, 0.0]] {
|
||||
assert!(LedStripOptions { length_axis: axis, ..strip() }.rectangle().is_err());
|
||||
}
|
||||
assert!(LedStripOptions { center_mm: [1e12, 0.0, 0.0], ..strip() }.rectangle().is_err());
|
||||
assert!(LedStripOptions { color: [1.01, 0.0, 0.0], ..strip() }.rectangle().is_err());
|
||||
assert!(LedStripOptions { intensity: 65.0, ..strip() }.rectangle().is_err());
|
||||
let mut wire = serde_json::to_value(strip()).unwrap();
|
||||
wire["pitch_mm"] = serde_json::json!(10);
|
||||
assert!(serde_json::from_value::<LedStripOptions>(wire).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_slot_per_strip_and_original_capacity_accounted() {
|
||||
let mut options = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
for count in 1..=4 {
|
||||
strip().append_to(&mut options, 64).unwrap();
|
||||
assert_eq!(options.area_lights.as_ref().unwrap().len(), count);
|
||||
assert_eq!(options.area_samples, Some(64));
|
||||
assert_eq!(
|
||||
options.retained_bytes().unwrap(),
|
||||
(options.area_lights.as_ref().unwrap().capacity() * std::mem::size_of::<RectangleLightOptions>()) as u64
|
||||
);
|
||||
options.validate().unwrap();
|
||||
}
|
||||
let original = options.clone();
|
||||
assert!(strip().append_to(&mut options, 64).is_err());
|
||||
assert_eq!(options, original);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejection_is_atomic_including_capacity_and_conflicting_sample_count() {
|
||||
let mut options = RaytraceOptions::default();
|
||||
strip().append_to(&mut options, 16).unwrap();
|
||||
for (input, samples) in [(strip(), 4), (strip(), 3), (LedStripOptions { width_mm: 0.0, ..strip() }, 16)] {
|
||||
let before = options.clone();
|
||||
let capacity = options.area_lights.as_ref().unwrap().capacity();
|
||||
assert!(input.append_to(&mut options, samples).is_err());
|
||||
assert_eq!(options, before);
|
||||
assert_eq!(options.area_lights.as_ref().unwrap().capacity(), capacity);
|
||||
}
|
||||
let mut over = RaytraceOptions { area_lights: Some(Vec::with_capacity(5)), ..Default::default() };
|
||||
assert!(strip().append_to(&mut over, 1).is_err());
|
||||
assert_eq!(over.area_lights.as_ref().unwrap().capacity(), 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn final_edge_cosine_rejection_preserves_request_and_capacity() {
|
||||
let a = 1.0 - 5e-13;
|
||||
let input = LedStripOptions { length_axis: [a, 0.0, 0.0], width_axis: [1e-10, a, 0.0], ..strip() };
|
||||
assert!(input.rectangle().is_err());
|
||||
let mut options = RaytraceOptions::default();
|
||||
strip().append_to(&mut options, 16).unwrap();
|
||||
let before = options.clone();
|
||||
let capacity = options.area_lights.as_ref().unwrap().capacity();
|
||||
assert!(input.append_to(&mut options, 16).is_err());
|
||||
assert_eq!(options, before);
|
||||
assert_eq!(options.area_lights.as_ref().unwrap().capacity(), capacity);
|
||||
options.validate().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounded_dimension_endpoints_never_return_rt3_invalid_edges() {
|
||||
let k = 0.5_f64.sqrt();
|
||||
for dimension in [1e-6_f64.next_down(), 1e-6, 1e-6_f64.next_up(), 1e6_f64.next_down(), 1e6, 1e6_f64.next_up()] {
|
||||
for (u, v) in [([1.0, 0.0, 0.0], [0.0, -1.0, 0.0]), ([k, k, 0.0], [k, -k, 0.0])] {
|
||||
let input = LedStripOptions { length_mm: dimension, width_mm: dimension, length_axis: u, width_axis: v, ..strip() };
|
||||
let mut options = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
if let Ok(rectangle) = input.rectangle() {
|
||||
options.area_lights = Some(vec![rectangle]);
|
||||
options.validate().unwrap();
|
||||
let mut lowered = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
input.append_to(&mut lowered, 1).unwrap();
|
||||
lowered.validate().unwrap();
|
||||
} else {
|
||||
let before = options.clone();
|
||||
assert!(input.append_to(&mut options, 1).is_err());
|
||||
assert_eq!(options, before);
|
||||
}
|
||||
}
|
||||
}
|
||||
for dimension in [1e-6, 1e6] {
|
||||
LedStripOptions { length_mm: dimension, width_mm: dimension, ..strip() }.rectangle().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recipe_roundtrip_and_tints_are_explicit_linear_values() {
|
||||
assert_eq!(serde_json::from_value::<LedStripOptions>(serde_json::to_value(strip()).unwrap()).unwrap(), strip());
|
||||
assert_eq!(StripTint::Red.linear_rgb(), [1.0, 0.0, 0.0]);
|
||||
assert_eq!(StripTint::Green.linear_rgb(), [0.0, 1.0, 0.0]);
|
||||
assert_eq!(StripTint::Blue.linear_rgb(), [0.0, 0.0, 1.0]);
|
||||
assert!(StripTint::Warm.linear_rgb()[0] > StripTint::Warm.linear_rgb()[2]);
|
||||
assert!(StripTint::Cool.linear_rgb()[2] > StripTint::Cool.linear_rgb()[0]);
|
||||
}
|
||||
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
mod consumer {
|
||||
use super::*;
|
||||
use crate::job::{CancelToken, ImageRequest, Integrator, TaskPoll};
|
||||
use crate::raytrace::{area::RectangleLight, image::ImageTask};
|
||||
use crate::{Camera, ProductMesh, ProductScene, StandardView, surface::OpaqueSurface};
|
||||
use solidcraft_geom::{Aabb3, Mesh};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn light(input: LedStripOptions) -> RectangleLight {
|
||||
let r = input.rectangle().unwrap();
|
||||
let vec = |[x, y, z]: [f64; 3]| Vec3::new(x, y, z);
|
||||
RectangleLight::new(vec(r.center_mm), vec(r.edge_u_mm), vec(r.edge_v_mm), vec(r.color), r.intensity).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytic_area_weight_inverse_square_and_orientation() {
|
||||
let source = light(strip());
|
||||
assert_eq!(source.area_mm2(), 4.0);
|
||||
assert_eq!(source.normal(), -Vec3::Z);
|
||||
let sample = source.sample(Vec3::ZERO, 0, 0, 0, 1, 0).unwrap().unwrap();
|
||||
assert!((sample.incident() - Vec3::new(0.08, 0.04, 0.02)).len() < 1e-14);
|
||||
let far = light(LedStripOptions { center_mm: [0.0, 0.0, 20.0], ..strip() }).sample(Vec3::ZERO, 0, 0, 0, 1, 0).unwrap().unwrap();
|
||||
assert!((far.incident() - sample.incident() * 0.25).len() < 1e-14);
|
||||
assert!(source.sample(Vec3::new(0.0, 0.0, 20.0), 0, 0, 0, 1, 0).unwrap().is_none());
|
||||
assert!(source.sample(Vec3::new(20.0, 0.0, 10.0), 0, 0, 0, 1, 0).unwrap().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn total_sampling_weight_does_not_grow_with_sample_count() {
|
||||
let source = light(strip());
|
||||
// Undo each sample's geometric factor: sum incident*r²/cos must be Le*A,
|
||||
// for EVERY N, rather than Le*A*N or Le*A/N.
|
||||
for n in [1, 4, 16, 64] {
|
||||
let mut sum = Vec3::ZERO;
|
||||
for index in 0..n {
|
||||
let sample = source.sample(Vec3::ZERO, 7, 0, index, n, 19).unwrap().unwrap();
|
||||
let cosine = (-source.normal()).dot(sample.direction());
|
||||
sum += sample.incident() * (sample.distance_mm().powi(2) / cosine);
|
||||
}
|
||||
assert!((sum - Vec3::new(8.0, 4.0, 2.0)).len() < 1e-12);
|
||||
}
|
||||
}
|
||||
|
||||
fn scene() -> ProductScene {
|
||||
let mesh = Mesh {
|
||||
positions: vec![Vec3::new(-20.0, -20.0, 0.0), Vec3::new(20.0, -20.0, 0.0), Vec3::new(20.0, 20.0, 0.0), Vec3::new(-20.0, 20.0, 0.0)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
};
|
||||
let bounds = mesh.bounds();
|
||||
ProductScene {
|
||||
bounds,
|
||||
meshes: vec![ProductMesh {
|
||||
transmission: None,
|
||||
name: "original LED receiver".into(),
|
||||
mesh: Arc::new(mesh),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.0, 1.0, 1.0).unwrap()),
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
}
|
||||
}
|
||||
fn request(options: RaytraceOptions) -> ImageRequest {
|
||||
let mut camera = Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: Integrator::Raytrace,
|
||||
raytrace: Some(options),
|
||||
camera,
|
||||
width: 1,
|
||||
height: 1,
|
||||
background: [0; 3],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn render(input: LedStripOptions, units: usize) -> Vec<u8> {
|
||||
let mut options = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
input.append_to(&mut options, 1).unwrap();
|
||||
let mut task = ImageTask::new(scene(), request(options.clone()), CancelToken::default(), options).unwrap();
|
||||
for _ in 0..10000 {
|
||||
if let TaskPoll::Complete(png) = task.step(units).unwrap() {
|
||||
return png;
|
||||
}
|
||||
}
|
||||
panic!("bounded LED fixture did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real_consumer_png_matches_analytic_lambert_pixel_and_partition() {
|
||||
let png = render(LedStripOptions { color: [1.0; 3], ..strip() }, 1);
|
||||
assert_eq!(png, render(LedStripOptions { color: [1.0; 3], ..strip() }, 128));
|
||||
let actual = ::image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
// Center ray, area4, Le2, r10, Lambert1/pi; one shared tone-map.
|
||||
let linear = 0.08 / std::f64::consts::PI;
|
||||
let mapped = linear / (1.0 + linear);
|
||||
let expected = ((1.055 * mapped.powf(1.0 / 2.4) - 0.055) * 255.0).round() as u8;
|
||||
assert_eq!(actual.get_pixel(0, 0).0, [expected, expected, expected, 255]);
|
||||
let dark = ::image::load_from_memory(&render(LedStripOptions { width_axis: [0.0, 1.0, 0.0], ..strip() }, 1)).unwrap().to_rgba8();
|
||||
assert_eq!(dark.get_pixel(0, 0).0, [0, 0, 0, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn same_task_cancellation_refuses_partial_output() {
|
||||
let mut options = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
strip().append_to(&mut options, 64).unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(), request(options.clone()), cancel.clone(), options).unwrap();
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn admission_accounts_the_existing_rectangle_storage() {
|
||||
let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let baseline = RaytraceOptions { lights: Some(Vec::new()), ..Default::default() };
|
||||
let before = crate::raytrace::image::admit(&empty, &request(baseline.clone()), &baseline).unwrap();
|
||||
let mut options = baseline;
|
||||
strip().append_to(&mut options, 64).unwrap();
|
||||
let after = crate::raytrace::image::admit(&empty, &request(options.clone()), &options).unwrap();
|
||||
assert!(after.estimated_total_bytes > before.estimated_total_bytes);
|
||||
}
|
||||
}
|
||||
+1948
File diff suppressed because it is too large.
Load diff
+164
@@ -0,0 +1,164 @@
|
||||
//! Bounded PNG encoding shared by native image executors.
|
||||
use super::{CancelToken, ErrorCode, ImageRequest, ImageWork, JobError, Phase, Progress, Result, TaskPoll};
|
||||
use std::{
|
||||
io::Write,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
struct Output {
|
||||
bytes: Arc<Mutex<Vec<u8>>>,
|
||||
limit: usize,
|
||||
cancel: CancelToken,
|
||||
}
|
||||
impl Write for Output {
|
||||
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
|
||||
if self.cancel.is_cancelled() {
|
||||
return Err(std::io::Error::other("render cancelled"));
|
||||
}
|
||||
let mut out = self.bytes.lock().map_err(|_| std::io::Error::other("PNG lock poisoned"))?;
|
||||
if out.len().checked_add(bytes.len()).is_none_or(|n| n > self.limit) {
|
||||
return Err(std::io::Error::other("PNG byte limit exceeded"));
|
||||
}
|
||||
out.try_reserve_exact(bytes.len()).map_err(|_| std::io::Error::other("PNG allocation failed"))?;
|
||||
out.extend_from_slice(bytes);
|
||||
Ok(bytes.len())
|
||||
}
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Owns admitted RGBA bytes and yields after at most four scanlines.
|
||||
pub struct PngTask {
|
||||
rgba: Vec<u8>,
|
||||
row: usize,
|
||||
width: usize,
|
||||
height: usize,
|
||||
bytes: Arc<Mutex<Vec<u8>>>,
|
||||
writer: Option<png::StreamWriter<'static, Output>>,
|
||||
cancel: CancelToken,
|
||||
}
|
||||
impl PngTask {
|
||||
pub fn new(request: &ImageRequest, rgba: Vec<u8>, cancel: CancelToken) -> Result<Self> {
|
||||
let pixels = u64::from(request.width) * u64::from(request.height);
|
||||
if request.width == 0
|
||||
|| request.height == 0
|
||||
|| u64::from(request.width) > super::GPU_PATH_LIMITS.max_dimension
|
||||
|| u64::from(request.height) > super::GPU_PATH_LIMITS.max_dimension
|
||||
|| pixels > super::GPU_PATH_LIMITS.max_pixels
|
||||
|| rgba.len() as u64 != pixels * 4
|
||||
{
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "invalid PNG dimensions or RGBA length"));
|
||||
}
|
||||
cancel.check()?;
|
||||
Self::new_with_limits(request, rgba, cancel, super::GPU_PATH_LIMITS)
|
||||
}
|
||||
pub(crate) fn new_with_limits(request: &ImageRequest, rgba: Vec<u8>, cancel: CancelToken, limits: crate::RenderLimits) -> Result<Self> {
|
||||
let pixels = super::linear_exr::output_pixels_with_limits(request.width, request.height, limits)?;
|
||||
let rgba_bytes = super::linear_exr::checked_output_bytes(pixels, 4, 0, limits)?;
|
||||
if rgba.len() != rgba_bytes {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "invalid PNG dimensions or RGBA length"));
|
||||
}
|
||||
let limit = super::linear_exr::checked_output_bytes(pixels, 8, 65_536, limits)?;
|
||||
let retained = super::linear_exr::checked_output_bytes(rgba.capacity() as u64, 1, 0, limits)? as u64;
|
||||
super::linear_exr::checked_stage_bytes(1, retained, limit as u64, limits)?;
|
||||
cancel.check()?;
|
||||
let bytes = Arc::new(Mutex::new(Vec::new()));
|
||||
let output = Output { bytes: bytes.clone(), limit, cancel: cancel.clone() };
|
||||
let mut encoder = png::Encoder::new(output, request.width, request.height);
|
||||
encoder.set_color(png::ColorType::Rgba);
|
||||
encoder.set_depth(png::BitDepth::Eight);
|
||||
encoder.set_source_srgb(png::SrgbRenderingIntent::Perceptual);
|
||||
let writer = encoder.write_header().and_then(|w| w.into_stream_writer()).map_err(encoding)?;
|
||||
Ok(Self { rgba, row: 0, width: request.width as usize, height: request.height as usize, bytes, writer: Some(writer), cancel })
|
||||
}
|
||||
}
|
||||
fn encoding(e: impl std::fmt::Display) -> JobError {
|
||||
JobError::new(ErrorCode::EncodingFailed, e.to_string())
|
||||
}
|
||||
impl ImageWork for PngTask {
|
||||
fn step(&mut self, _units: usize) -> Result<TaskPoll> {
|
||||
self.cancel.check()?;
|
||||
for _ in 0..4 {
|
||||
if self.row == self.height {
|
||||
break;
|
||||
}
|
||||
let start = self.row * self.width * 4;
|
||||
let row = self.rgba.get(start..start + self.width * 4).ok_or_else(|| encoding("missing PNG row"))?;
|
||||
self.writer.as_mut().ok_or_else(|| encoding("PNG already completed"))?.write_all(row).map_err(encoding)?;
|
||||
self.row += 1;
|
||||
}
|
||||
if self.row != self.height {
|
||||
return Ok(TaskPoll::Pending(Progress { phase: Phase::Encoding, done: self.row as u64, total: self.height as u64 }));
|
||||
}
|
||||
self.writer.take().ok_or_else(|| encoding("PNG already completed"))?.finish().map_err(encoding)?;
|
||||
self.cancel.check()?;
|
||||
let mut bytes = self.bytes.lock().map_err(|_| encoding("PNG lock poisoned"))?;
|
||||
Ok(TaskPoll::Complete(std::mem::take(&mut *bytes)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn request(width: u32, height: u32) -> ImageRequest {
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
width,
|
||||
height,
|
||||
camera: Default::default(),
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
studio_weights: None,
|
||||
background: [0; 3],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn finish(mut task: PngTask) -> Vec<u8> {
|
||||
loop {
|
||||
if let TaskPoll::Complete(bytes) = task.step(1).unwrap() {
|
||||
return bytes;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_png_keeps_default_bytes_and_roundtrips_a_narrow_wide_image() {
|
||||
let small = request(3, 2);
|
||||
let rgba = [20, 40, 60, 255].repeat(6);
|
||||
let legacy = finish(PngTask::new(&small, rgba.clone(), CancelToken::default()).unwrap());
|
||||
let explicit = finish(PngTask::new_with_limits(&small, rgba, CancelToken::default(), super::super::GPU_PATH_LIMITS).unwrap());
|
||||
assert_eq!(explicit, legacy);
|
||||
let wide = request(8193, 1);
|
||||
let rgba = [20, 40, 60, 255].repeat(8193);
|
||||
assert!(PngTask::new(&wide, vec![], CancelToken::default()).is_err());
|
||||
let png = finish(
|
||||
PngTask::new_with_limits(&wide, rgba.clone(), CancelToken::default(), super::super::CpuBudget::Workstation.image_limits(false)).unwrap(),
|
||||
);
|
||||
let decoded = image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.dimensions(), (8193, 1));
|
||||
assert_eq!(decoded.as_raw(), &rgba);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn png_dimension_length_and_cancel_precedence_remains_legacy() {
|
||||
let cancel = CancelToken::default();
|
||||
cancel.cancel();
|
||||
assert_eq!(PngTask::new(&request(0, 1), vec![], cancel.clone()).err().unwrap().code, ErrorCode::InvalidRequest);
|
||||
assert_eq!(PngTask::new(&request(1, 1), vec![], cancel.clone()).err().unwrap().code, ErrorCode::InvalidRequest);
|
||||
assert_eq!(PngTask::new(&request(1, 1), vec![0; 4], cancel.clone()).err().unwrap().code, ErrorCode::Cancelled);
|
||||
let bad = crate::RenderLimits { max_scratch_bytes: u64::MAX, ..super::super::GPU_PATH_LIMITS };
|
||||
assert!(PngTask::new_with_limits(&request(1, 1), vec![0; 4], CancelToken::default(), bad).is_err());
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = PngTask::new_with_limits(&request(1, 1), vec![0; 4], cancel.clone(), super::super::GPU_PATH_LIMITS).unwrap();
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
}
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
//! Cancellable, geometry-free presentation of an immutable native linear master.
|
||||
//! A derivative retains the original frame lease instead of copying EXR bytes.
|
||||
use super::{CancelToken, ErrorCode, ImageRequest, ImageWork, JobError, Phase, PngTask, Progress, RenderFrame, Result, TaskPoll};
|
||||
use super::{bloom::BloomTask, linear_exr_decode::Decoder, presentation::Presentation};
|
||||
use std::sync::Arc;
|
||||
|
||||
pub(super) fn required_bytes(source: &RenderFrame, settings: Presentation) -> Result<u64> {
|
||||
settings.validate()?;
|
||||
super::linear_exr::encoded_limit(source.info.width, source.info.height)?;
|
||||
required_bytes_with_limits(source, settings, super::GPU_PATH_LIMITS)
|
||||
}
|
||||
|
||||
pub(crate) fn required_bytes_with_limits(source: &RenderFrame, settings: Presentation, limits: crate::RenderLimits) -> Result<u64> {
|
||||
settings.validate()?;
|
||||
super::linear_exr::encoded_limit_with_limits(source.info.width, source.info.height, limits)?;
|
||||
if source.linear_exr().is_none() {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "this completed frame has no retained raw linear master"));
|
||||
}
|
||||
output_bytes(source.info.width, source.info.height, settings, limits)
|
||||
}
|
||||
|
||||
fn output_bytes(width: u32, height: u32, settings: Presentation, limits: crate::RenderLimits) -> Result<u64> {
|
||||
let pixels = super::linear_exr::output_pixels_with_limits(width, height, limits)?;
|
||||
let photo = settings.finishing.photographic.scratch_bytes_with_limits(width, height, limits)?;
|
||||
let extra = photo.checked_add(1_048_576).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "regrade byte estimate overflow"))?;
|
||||
super::linear_exr::checked_stage_bytes(pixels, 48, extra, limits)
|
||||
}
|
||||
|
||||
pub(super) struct RegradeTask {
|
||||
source: Arc<RenderFrame>,
|
||||
settings: Presentation,
|
||||
limits: crate::RenderLimits,
|
||||
cancel: CancelToken,
|
||||
decoder: Option<Decoder>,
|
||||
bloom: Option<BloomTask>,
|
||||
linear: Option<Vec<[f32; 4]>>,
|
||||
glow: Option<Vec<[f32; 3]>>,
|
||||
rgba: Vec<u8>,
|
||||
encoded: usize,
|
||||
png: Option<PngTask>,
|
||||
photographic: Option<super::photographic::PhotographicTask>,
|
||||
}
|
||||
impl RegradeTask {
|
||||
pub(super) fn new(source: Arc<RenderFrame>, settings: Presentation, cancel: CancelToken) -> Result<Self> {
|
||||
required_bytes(&source, settings)?;
|
||||
Self::new_with_limits(source, settings, cancel, super::GPU_PATH_LIMITS)
|
||||
}
|
||||
pub(crate) fn new_with_limits(
|
||||
source: Arc<RenderFrame>,
|
||||
settings: Presentation,
|
||||
cancel: CancelToken,
|
||||
limits: crate::RenderLimits,
|
||||
) -> Result<Self> {
|
||||
required_bytes_with_limits(&source, settings, limits)?;
|
||||
let raw = source.linear_exr().ok_or_else(|| JobError::new(ErrorCode::InvalidRequest, "linear master disappeared"))?;
|
||||
let decoder = if limits == super::GPU_PATH_LIMITS {
|
||||
Decoder::new(raw, source.info.width, source.info.height, &cancel)?
|
||||
} else {
|
||||
Decoder::new_with_limits(raw, source.info.width, source.info.height, &cancel, limits)?
|
||||
};
|
||||
Ok(Self {
|
||||
source,
|
||||
settings,
|
||||
limits,
|
||||
cancel,
|
||||
decoder: Some(decoder),
|
||||
bloom: None,
|
||||
linear: None,
|
||||
glow: None,
|
||||
rgba: Vec::new(),
|
||||
encoded: 0,
|
||||
png: None,
|
||||
photographic: None,
|
||||
})
|
||||
}
|
||||
pub(super) fn source(&self) -> Arc<RenderFrame> {
|
||||
self.source.clone()
|
||||
}
|
||||
fn pending(&self, done: u64, total: u64) -> Result<TaskPoll> {
|
||||
Ok(TaskPoll::Pending(Progress { phase: Phase::Encoding, done, total }))
|
||||
}
|
||||
}
|
||||
impl ImageWork for RegradeTask {
|
||||
fn step(&mut self, units: usize) -> Result<TaskPoll> {
|
||||
self.cancel.check()?;
|
||||
if let Some(png) = &mut self.png {
|
||||
return png.step(units);
|
||||
}
|
||||
let (width, height) = (self.source.info.width, self.source.info.height);
|
||||
if let Some(mut task) = self.photographic.take() {
|
||||
if !task.step(units)? {
|
||||
let (done, total) = task.progress();
|
||||
self.photographic = Some(task);
|
||||
return self.pending(done, total);
|
||||
}
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
width,
|
||||
height,
|
||||
camera: Default::default(),
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
background: self.settings.background,
|
||||
transparent_background: self.settings.transparent_background,
|
||||
};
|
||||
self.png = Some(PngTask::new_with_limits(&request, task.finish()?, self.cancel.clone(), self.limits)?);
|
||||
return self.pending(0, u64::from(height));
|
||||
}
|
||||
if let Some(mut decoder) = self.decoder.take() {
|
||||
let raw = self.source.linear_exr().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing retained master"))?;
|
||||
if !decoder.step(raw, &self.cancel)? {
|
||||
let done = decoder.rows();
|
||||
self.decoder = Some(decoder);
|
||||
return self.pending(done, u64::from(height));
|
||||
}
|
||||
let pixels = decoder.finish()?;
|
||||
if let Some(bloom) = self.settings.finishing.bloom.filter(|b| b.active()) {
|
||||
self.bloom = Some(BloomTask::new_with_limits(width, height, pixels, bloom, self.cancel.clone(), self.limits)?);
|
||||
return self.pending(0, u64::from(height) * 7);
|
||||
}
|
||||
self.linear = Some(pixels);
|
||||
}
|
||||
if let Some(mut bloom) = self.bloom.take() {
|
||||
if !bloom.step(4)? {
|
||||
let (done, total) = (bloom.completed_lines(), bloom.total_lines());
|
||||
self.bloom = Some(bloom);
|
||||
return self.pending(done, total);
|
||||
}
|
||||
let (pixels, glow) = bloom.finish()?;
|
||||
self.linear = Some(pixels);
|
||||
self.glow = Some(glow);
|
||||
}
|
||||
let count = width as usize * height as usize;
|
||||
if self.rgba.is_empty() {
|
||||
self.rgba.try_reserve_exact(count * 4).map_err(|_| JobError::new(ErrorCode::AllocationFailed, "regrade display allocation failed"))?;
|
||||
if self.rgba.capacity() != count * 4 {
|
||||
return Err(JobError::new(ErrorCode::LimitExceeded, "regrade display exceeds admitted capacity"));
|
||||
}
|
||||
self.rgba.resize(count * 4, 0);
|
||||
}
|
||||
let end = self.encoded.saturating_add(units.clamp(1, 4096)).min(count);
|
||||
let pixels = self
|
||||
.linear
|
||||
.as_deref()
|
||||
.and_then(|p| p.get(self.encoded..end))
|
||||
.ok_or_else(|| JobError::new(ErrorCode::Internal, "missing regrade pixels"))?;
|
||||
let output = self.rgba.get_mut(self.encoded * 4..end * 4).ok_or_else(|| JobError::new(ErrorCode::Internal, "missing regrade output"))?;
|
||||
let glow = self.glow.as_deref().and_then(|g| g.get(self.encoded..end));
|
||||
self.settings.display_with_limits(width, height, self.limits)?.encode_bloom_at_with_limits(
|
||||
pixels,
|
||||
output,
|
||||
&self.cancel,
|
||||
self.encoded,
|
||||
glow,
|
||||
self.limits,
|
||||
)?;
|
||||
self.encoded = end;
|
||||
if end < count {
|
||||
return self.pending(end as u64, count as u64);
|
||||
}
|
||||
self.glow = None;
|
||||
if self.settings.finishing.photographic.active() {
|
||||
let pixels = self.linear.take().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing photographic master pixels"))?;
|
||||
self.photographic = Some(super::photographic::PhotographicTask::new_with_limits(
|
||||
width,
|
||||
height,
|
||||
std::mem::take(&mut self.rgba),
|
||||
pixels,
|
||||
self.settings.finishing.photographic,
|
||||
self.cancel.clone(),
|
||||
self.limits,
|
||||
)?);
|
||||
return self.pending(0, u64::from(width) * u64::from(height));
|
||||
}
|
||||
self.linear = None;
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
width,
|
||||
height,
|
||||
camera: Default::default(),
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
background: self.settings.background,
|
||||
transparent_background: self.settings.transparent_background,
|
||||
};
|
||||
self.png = Some(PngTask::new_with_limits(&request, std::mem::take(&mut self.rgba), self.cancel.clone(), self.limits)?);
|
||||
self.pending(0, u64::from(height))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn regrade_size_estimate_is_explicit_checked_and_does_not_grant_a_lease() {
|
||||
let wide = super::super::CpuBudget::Workstation.image_limits(false);
|
||||
assert_eq!(output_bytes(8193, 1, Presentation::default(), wide).unwrap(), 8193 * 48 + 1_048_576);
|
||||
assert!(output_bytes(8193, 1, Presentation::default(), super::super::GPU_PATH_LIMITS).is_err());
|
||||
assert!(output_bytes(u32::MAX, u32::MAX, Presentation::default(), wide).is_err());
|
||||
assert!(output_bytes(1, 1, Presentation::default(), crate::RenderLimits { max_scratch_bytes: u64::MAX, ..wide }).is_err());
|
||||
assert!(output_bytes(1, 1, Presentation::default(), crate::RenderLimits { max_scratch_bytes: 1_048_576, ..wide }).is_err());
|
||||
}
|
||||
}
|
||||
+269
@@ -0,0 +1,269 @@
|
||||
//! Runtime-option and admission regressions; no render timing assumptions.
|
||||
|
||||
use super::*;
|
||||
use crate::ProductScene;
|
||||
use solidcraft_geom::Aabb3;
|
||||
|
||||
fn request(integrator: Integrator) -> ImageRequest {
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator,
|
||||
raytrace: None,
|
||||
camera: Default::default(),
|
||||
width: 16,
|
||||
height: 16,
|
||||
background: [0; 3],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn options_reject_retained_capacity_even_when_no_lights_are_active() {
|
||||
let options = RaytraceOptions { lights: Some(Vec::with_capacity(64)), ..Default::default() };
|
||||
assert_eq!(options.validate().unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
let serialized = serde_json::to_value(&options).unwrap();
|
||||
let decoded: RaytraceOptions = serde_json::from_value(serialized).unwrap();
|
||||
assert!(decoded.validate().is_ok(), "wire input retains no oversized source allocation");
|
||||
}
|
||||
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
#[test]
|
||||
fn raytrace_admission_validates_retained_options_before_cloning() {
|
||||
let scene = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let mut request = request(Integrator::Raytrace);
|
||||
request.raytrace = Some(RaytraceOptions { lights: Some(Vec::with_capacity(64)), ..Default::default() });
|
||||
let original = request.raytrace.as_ref().unwrap();
|
||||
assert_eq!(original.validate().unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
assert!(original.clone().validate().is_ok(), "cloning an empty Vec discards its retained capacity");
|
||||
let error = admit(&scene, &request).err().unwrap();
|
||||
assert_eq!(error.code, ErrorCode::InvalidRequest);
|
||||
assert_eq!(request.raytrace.as_ref().unwrap().lights.as_ref().unwrap().capacity(), 64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn options_preserve_the_eight_light_boundary_and_refuse_the_ninth() {
|
||||
let light = serde_json::json!({"direction": [0.0, 0.0, -1.0], "color": [1.0, 1.0, 1.0], "intensity": 1.0});
|
||||
let accepted: RaytraceOptions = serde_json::from_value(serde_json::json!({"lights": vec![light.clone(); 8]})).unwrap();
|
||||
assert!(accepted.validate().is_ok());
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(serde_json::json!({"lights": vec![light; 9]})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exposure_refuses_nonfinite_and_out_of_range_values() {
|
||||
for exposure_ev in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -33.0, 33.0, -32.01, 32.01] {
|
||||
let options = RaytraceOptions { exposure_ev, ..Default::default() };
|
||||
assert_eq!(options.validate().unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
}
|
||||
// CPU exposure now shares the saved/UI range; the old +/-16 refusal
|
||||
// is superseded, not a reason to change any transport oracle.
|
||||
assert_eq!(RaytraceOptions::default().exposure_ev, 0.0);
|
||||
for exposure_ev in [-32.0, -17.0, -16.0, 0.0, 16.0, 17.0, 32.0] {
|
||||
assert!(RaytraceOptions { exposure_ev, ..Default::default() }.validate().is_ok());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_raytrace_submission_leaves_existing_raster_reservation_intact() {
|
||||
let host = CpuHost::cooperative();
|
||||
let scene = || ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let raster = host.submit(JobId { session: 1, serial: 1, generation: 1 }, 1, scene(), request(Integrator::Raster)).unwrap();
|
||||
let before = host.admitted_bytes();
|
||||
assert!(before > 0);
|
||||
let error = host.submit(JobId { session: 1, serial: 2, generation: 2 }, 1, scene(), request(Integrator::Raytrace)).err().unwrap();
|
||||
assert_eq!(error.code, ErrorCode::HostUnavailable);
|
||||
assert_eq!(host.admitted_bytes(), before);
|
||||
assert_eq!(raster.status().unwrap().progress.phase, Phase::Queued);
|
||||
assert!(raster.frame().unwrap().is_none());
|
||||
assert_eq!(raster.cancel().unwrap().progress.phase, Phase::Cancelled);
|
||||
// Pump only to discard cancelled queued input; it must not produce a frame.
|
||||
assert!(!host.pump(1).unwrap());
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
assert!(raster.frame().unwrap().is_none());
|
||||
}
|
||||
|
||||
#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
|
||||
#[test]
|
||||
fn native_integrators_share_one_host_and_retained_frame_budget() {
|
||||
let mut host = CpuHost::for_platform().unwrap();
|
||||
let scene = || ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let raster_id = JobId { session: 10, serial: 1, generation: 1 };
|
||||
let raytrace_id = JobId { session: 20, serial: 1, generation: 1 };
|
||||
let raster = host.submit(raster_id, 100, scene(), request(Integrator::Raster)).unwrap();
|
||||
let raytrace = host.submit(raytrace_id, 200, scene(), request(Integrator::Raytrace)).unwrap();
|
||||
// Deadlock watchdog only; there is no rendering-speed assertion.
|
||||
for job in [&raster, &raytrace] {
|
||||
assert_eq!(job.wait_timeout(std::time::Duration::from_secs(60)).unwrap().progress.phase, Phase::Completed);
|
||||
}
|
||||
host.join_worker_for_test().unwrap();
|
||||
let raster_frame = raster.frame().unwrap().unwrap();
|
||||
let raytrace_frame = raytrace.frame().unwrap().unwrap();
|
||||
assert_eq!(raster_frame.info.job, raster_id);
|
||||
assert_eq!(raytrace_frame.info.job, raytrace_id);
|
||||
assert_eq!(raster_frame.info.scene_generation, 100);
|
||||
assert_eq!(raytrace_frame.info.scene_generation, 200);
|
||||
assert_eq!(raster_frame.info.executor.as_str(), "cpu-product");
|
||||
assert_eq!(raytrace_frame.info.executor.as_str(), "cpu-raytrace");
|
||||
let both = host.admitted_bytes();
|
||||
assert!(both > 0);
|
||||
drop(raster);
|
||||
drop(raytrace);
|
||||
assert_eq!(host.admitted_bytes(), both, "external frames retain both leases");
|
||||
drop(raster_frame);
|
||||
assert!(host.admitted_bytes() > 0 && host.admitted_bytes() < both);
|
||||
drop(raytrace_frame);
|
||||
assert_eq!(host.admitted_bytes(), 0);
|
||||
}
|
||||
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
#[test]
|
||||
fn cancelled_raytrace_task_never_returns_a_frame() {
|
||||
let cancel = CancelToken::default();
|
||||
let scene = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let mut task = crate::raytrace::image::ImageTask::new(scene, request(Integrator::Raytrace), cancel.clone(), RaytraceOptions::default()).unwrap();
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
|
||||
#[cfg(feature = "raytrace-cpu")]
|
||||
#[test]
|
||||
fn completed_raytrace_task_releases_captured_mesh_before_returning_png() {
|
||||
let mesh = Arc::new(solidcraft_geom::Mesh::default());
|
||||
let captured = Arc::downgrade(&mesh);
|
||||
let scene = ProductScene {
|
||||
meshes: vec![crate::ProductMesh {
|
||||
transmission: None,
|
||||
name: "Lease probe".into(),
|
||||
mesh,
|
||||
color: [0; 3],
|
||||
opacity: 1.0,
|
||||
surface: None,
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
bounds: Aabb3::EMPTY,
|
||||
};
|
||||
let mut task =
|
||||
crate::raytrace::image::ImageTask::new(scene, request(Integrator::Raytrace), CancelToken::default(), RaytraceOptions::default()).unwrap();
|
||||
assert!(captured.upgrade().is_some());
|
||||
let mut completed = false;
|
||||
for _ in 0..10_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(4).unwrap() {
|
||||
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
|
||||
completed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(completed, "bounded empty-scene fixture must complete");
|
||||
assert!(captured.upgrade().is_none(), "the host may shrink the lease as soon as Complete is returned, even while the task remains alive");
|
||||
assert_eq!(task.progress().phase, Phase::Completed);
|
||||
}
|
||||
#[test]
|
||||
fn emission_runtime_json_is_bounded_explicit_and_roundtrips() {
|
||||
use super::{EmissionSides, RaytraceOptions, SurfaceEmission};
|
||||
let emitter = SurfaceEmission { body_index: 0, body: "fixture".into(), color: [1.0, 0.5, 0.0], strength: 2.0, sides: EmissionSides::Front };
|
||||
let options = RaytraceOptions { emissions: Some(vec![emitter.clone()]), ..Default::default() };
|
||||
let encoded = serde_json::to_value(&options).unwrap();
|
||||
assert_eq!(serde_json::from_value::<RaytraceOptions>(encoded).unwrap(), options);
|
||||
assert!(serde_json::from_str::<RaytraceOptions>("{\"emissions\":null}").is_err());
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(serde_json::json!({"emissions": vec![emitter; 33]})).is_err());
|
||||
assert!(
|
||||
serde_json::from_value::<RaytraceOptions>(
|
||||
serde_json::json!({"emissions":[{"body_index":0,"body":"x".repeat(257),"color":[1,1,1],"strength":1}]})
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(serde_json::from_str::<RaytraceOptions>("{}").unwrap().emissions, None);
|
||||
assert_eq!(serde_json::from_str::<RaytraceOptions>("{\"emissions\":[]}").unwrap().emissions, Some(Vec::new()));
|
||||
}
|
||||
|
||||
fn directional_options() -> RaytraceOptions {
|
||||
RaytraceOptions {
|
||||
directional_shadow_transmission: true,
|
||||
dielectrics: vec![DielectricOptions {
|
||||
body_index: 0,
|
||||
body_name: "directional glass".into(),
|
||||
boundary: DielectricBoundary::ThinSheet,
|
||||
ior: 1.0,
|
||||
absorption_per_mm: [0.0; 3],
|
||||
thickness_mm: 1.0,
|
||||
}],
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directional_mode_is_explicit_false_omitted_and_true_roundtrips() {
|
||||
let old_default = serde_json::json!({"reflections":null,"anisotropic_faces":[null,null],"preset":null,"exposure_ev":0.0,"shadows":true});
|
||||
let decoded: RaytraceOptions = serde_json::from_value(old_default.clone()).unwrap();
|
||||
assert!(!decoded.directional_shadow_transmission);
|
||||
assert_eq!(serde_json::to_value(&decoded).unwrap(), old_default);
|
||||
let mut explicit = old_default.clone();
|
||||
explicit["directional_shadow_transmission"] = serde_json::json!(false);
|
||||
assert_eq!(serde_json::to_value(serde_json::from_value::<RaytraceOptions>(explicit).unwrap()).unwrap(), old_default);
|
||||
let enabled = directional_options();
|
||||
enabled.validate().unwrap();
|
||||
let wire = serde_json::to_value(&enabled).unwrap();
|
||||
assert_eq!(wire["directional_shadow_transmission"], serde_json::json!(true));
|
||||
assert_eq!(serde_json::from_value::<RaytraceOptions>(wire).unwrap(), enabled);
|
||||
for bad in [serde_json::json!(null), serde_json::json!(1), serde_json::json!("true")] {
|
||||
let mut wire = old_default.clone();
|
||||
wire["directional_shadow_transmission"] = bad;
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(wire).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directional_mode_refuses_incompatible_inputs_without_rewriting_legacy() {
|
||||
for case in 0..7 {
|
||||
let mut options = directional_options();
|
||||
match case {
|
||||
0 => options.shadows = false,
|
||||
1 => options.dielectrics = Vec::new(),
|
||||
2 => options.reflections = Some(ReflectionOptions { bodies: Vec::new(), max_bounces: 1, samples: 1 }),
|
||||
3 => {
|
||||
options.anisotropic_faces[0] = Some(AnisotropicFaceOptions {
|
||||
body_index: 0,
|
||||
body_name: "directional glass".into(),
|
||||
face: 0,
|
||||
tangent: [1.0, 0.0, 0.0],
|
||||
orientation: AnisotropicOrientation::QuarterTurn,
|
||||
roughness_x: 0.2,
|
||||
roughness_y: 0.5,
|
||||
})
|
||||
}
|
||||
4 => options.environment = Some(RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 }),
|
||||
5 => {
|
||||
options.punctual_lights = Some(vec![PunctualLightOptions {
|
||||
position_mm: [0.0, 0.0, 10.0],
|
||||
color: [1.0; 3],
|
||||
intensity: 1.0,
|
||||
reference_distance_mm: 10.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
}])
|
||||
}
|
||||
_ => {
|
||||
options.area_lights = Some(vec![RectangleLightOptions {
|
||||
center_mm: [0.0, 0.0, 10.0],
|
||||
edge_u_mm: [1.0, 0.0, 0.0],
|
||||
edge_v_mm: [0.0, -1.0, 0.0],
|
||||
color: [1.0; 3],
|
||||
intensity: 1.0,
|
||||
}])
|
||||
}
|
||||
}
|
||||
assert_eq!(options.validate().unwrap_err().code, ErrorCode::InvalidRequest);
|
||||
options.directional_shadow_transmission = false;
|
||||
options.validate().unwrap();
|
||||
}
|
||||
let mut empty_locals = directional_options();
|
||||
empty_locals.punctual_lights = Some(Vec::new());
|
||||
empty_locals.area_lights = Some(Vec::new());
|
||||
empty_locals.validate().unwrap();
|
||||
}
|
||||
+251
@@ -0,0 +1,251 @@
|
||||
use super::*;
|
||||
use crate::job::{AnisotropicFaceOptions, CancelToken, ImageRequest, Integrator, TaskPoll};
|
||||
use crate::{Camera, ProductMesh, StandardView};
|
||||
use solidcraft_geom::Mesh;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn body(name: &str, x: f64) -> ProductMesh {
|
||||
ProductMesh {
|
||||
transmission: None,
|
||||
name: name.into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(x - 2.0, -2.0, 0.0), Vec3::new(x + 2.0, -2.0, 0.0), Vec3::new(x + 2.0, 2.0, 0.0), Vec3::new(x - 2.0, 2.0, 0.0)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![7, 7],
|
||||
..Default::default()
|
||||
}),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(0.8, 0.8, 0.8), 1.0, 0.5, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn scene() -> ProductScene {
|
||||
let meshes = vec![body("left@occurrence", -5.0), body("right@occurrence", 0.0), body("scalar control@occurrence", 5.0)];
|
||||
let bounds = meshes.iter().map(|b| b.mesh.bounds()).reduce(|a, b| a.union(&b)).unwrap();
|
||||
ProductScene { meshes, bounds }
|
||||
}
|
||||
|
||||
fn options() -> RaytraceOptions {
|
||||
let target = |body_index, name: &str, orientation| {
|
||||
Some(AnisotropicFaceOptions {
|
||||
body_index,
|
||||
body_name: name.into(),
|
||||
face: 7,
|
||||
tangent: [1.0, 0.0, 0.0],
|
||||
orientation,
|
||||
roughness_x: 0.25,
|
||||
roughness_y: 0.8,
|
||||
})
|
||||
};
|
||||
RaytraceOptions {
|
||||
anisotropic_faces: [
|
||||
target(0, "left@occurrence", AnisotropicOrientation::Zero),
|
||||
target(1, "right@occurrence", AnisotropicOrientation::QuarterTurn),
|
||||
],
|
||||
lights: Some(vec![job::DirectionalLightOptions { direction: [0.6, 0.0, 0.8], color: [1.0; 3], intensity: 1.0 }]),
|
||||
shadows: false,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_capture_identity_face_and_frame_are_required() {
|
||||
let scene = scene();
|
||||
let baseline = options();
|
||||
assert!(prepare(&scene, &baseline, || Ok(())).is_ok());
|
||||
for change in 0..4 {
|
||||
let mut options = baseline.clone();
|
||||
let target = options.anisotropic_faces[0].as_mut().unwrap();
|
||||
match change {
|
||||
0 => target.body_name = "wrong occurrence".into(),
|
||||
1 => target.body_index = 50,
|
||||
2 => target.face = 99,
|
||||
_ => target.tangent = [0.0, 0.0, 1.0],
|
||||
}
|
||||
assert!(prepare(&scene, &options, || Ok(())).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curved_inconsistent_missing_and_excessive_target_meshes_refuse() {
|
||||
for change in 0..4 {
|
||||
let mut scene = scene();
|
||||
let mesh = Arc::make_mut(&mut scene.meshes[0].mesh);
|
||||
match change {
|
||||
0 => mesh.positions[3].z = 0.1,
|
||||
1 => mesh.triangles[1].swap(1, 2),
|
||||
2 => mesh.tri_face.clear(),
|
||||
_ => {
|
||||
mesh.triangles = vec![[0, 1, 2]; MAX_TARGET_BODY_TRIANGLES + 1];
|
||||
mesh.tri_face = vec![7; MAX_TARGET_BODY_TRIANGLES + 1];
|
||||
}
|
||||
}
|
||||
assert!(prepare(&scene, &options(), || Ok(())).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bounded_dto_roundtrip_duplicates_and_original_capacity() {
|
||||
let options = options();
|
||||
assert!(options.validate().is_ok());
|
||||
let encoded = serde_json::to_value(&options).unwrap();
|
||||
assert_eq!(serde_json::from_value::<RaytraceOptions>(encoded.clone()).unwrap(), options);
|
||||
let expected = options.anisotropic_faces.iter().flatten().map(|t| t.body_name.capacity() as u64).sum::<u64>()
|
||||
+ options.lights.as_ref().unwrap().capacity() as u64 * std::mem::size_of::<job::DirectionalLightOptions>() as u64;
|
||||
assert_eq!(options.retained_bytes().unwrap(), expected);
|
||||
let mut duplicate = options.clone();
|
||||
duplicate.anisotropic_faces[1] = duplicate.anisotropic_faces[0].clone();
|
||||
assert!(duplicate.validate().is_err());
|
||||
let mut excessive_capacity = options.clone();
|
||||
let target = excessive_capacity.anisotropic_faces[0].as_mut().unwrap();
|
||||
let mut name = String::with_capacity(2048);
|
||||
name.push_str(&target.body_name);
|
||||
target.body_name = name;
|
||||
assert!(excessive_capacity.retained_bytes().is_err());
|
||||
let mut excessive_array = encoded;
|
||||
excessive_array["anisotropic_faces"] = serde_json::json!([null, null, null]);
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(excessive_array).is_err());
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(serde_json::json!({"anisotropic_faces":[{"body_index":0,"body_name":"x".repeat(1025),"face":7,"tangent":[1,0,0],"orientation":"zero","roughness_x":0.25,"roughness_y":0.8},null]})).is_err());
|
||||
assert!(serde_json::from_value::<RaytraceOptions>(serde_json::json!({"environment":{}})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_certification_uses_caller_work_and_cancellation() {
|
||||
let mut charged = 0;
|
||||
prepare(&scene(), &options(), || {
|
||||
charged += 1;
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(charged, 4);
|
||||
let error = prepare(&scene(), &options(), || Err(JobError::new(ErrorCode::Cancelled, "cancelled"))).err().unwrap();
|
||||
assert_eq!(error.code, ErrorCode::Cancelled);
|
||||
let error = prepare(&scene(), &options(), || Err(JobError::new(ErrorCode::LimitExceeded, "same work budget"))).err().unwrap();
|
||||
assert_eq!(error.code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_response_respects_geometry_visibility_and_quarter_turn() {
|
||||
let scene = scene();
|
||||
let options = options();
|
||||
let targets = prepare(&scene, &options, || Ok(())).unwrap();
|
||||
let lights =
|
||||
Lighting::new(vec![super::super::lighting::DirectionalLight::new(Vec3::new(0.6, 0.0, 0.8), Vec3::new(1.0, 1.0, 1.0), 1.0).unwrap()]).unwrap();
|
||||
let surface = scene.meshes[0].surface.unwrap();
|
||||
let first = targets[0].unwrap().shade(&lights, surface, Vec3::Z, Vec3::Z, |_, _| Ok(true)).unwrap();
|
||||
let turned = targets[1].unwrap().shade(&lights, surface, Vec3::Z, Vec3::Z, |_, _| Ok(true)).unwrap();
|
||||
assert!(turned.x > first.x + 0.1);
|
||||
assert_eq!(targets[0].unwrap().shade(&lights, surface, Vec3::Z, Vec3::Z, |_, _| Ok(false)).unwrap(), Vec3::ZERO);
|
||||
assert_eq!(targets[0].unwrap().shade(&lights, surface, Vec3::Z, -Vec3::Z, |_, _| Ok(true)).unwrap(), Vec3::ZERO);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decoded_cpu_png_rotates_only_the_two_explicit_planar_targets() {
|
||||
fn render(scene: ProductScene, camera: Camera, options: RaytraceOptions) -> ::image::RgbaImage {
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: Integrator::Raytrace,
|
||||
raytrace: Some(options.clone()),
|
||||
camera,
|
||||
width: 64,
|
||||
height: 32,
|
||||
background: [10, 20, 30],
|
||||
transparent_background: false,
|
||||
};
|
||||
let mut task = super::super::image::ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
|
||||
for _ in 0..100_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
|
||||
return ::image::load_from_memory(&png).unwrap().to_rgba8();
|
||||
}
|
||||
}
|
||||
panic!("bounded planar anisotropic PNG fixture failed to finish");
|
||||
}
|
||||
let scene = scene();
|
||||
let original = scene.meshes.iter().map(|b| b.mesh.positions.clone()).collect::<Vec<_>>();
|
||||
let mut camera = Camera::default();
|
||||
camera.set_view(StandardView::Top);
|
||||
camera.fit(&scene.bounds);
|
||||
let first = render(scene.clone(), camera, options());
|
||||
let mut rotated = options();
|
||||
rotated.anisotropic_faces[0].as_mut().unwrap().orientation = AnisotropicOrientation::QuarterTurn;
|
||||
rotated.anisotropic_faces[1].as_mut().unwrap().orientation = AnisotropicOrientation::Zero;
|
||||
let second = render(scene.clone(), camera, rotated);
|
||||
let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(camera.target);
|
||||
for (index, x) in [-5.0, 0.0, 5.0].into_iter().enumerate() {
|
||||
let (sx, sy, _) = camera.to_screen(Vec3::new(x, 0.0, 0.0), 64.0, 32.0, radius).unwrap();
|
||||
let a = first.get_pixel(sx.floor() as u32, sy.floor() as u32).0;
|
||||
let b = second.get_pixel(sx.floor() as u32, sy.floor() as u32).0;
|
||||
assert_ne!(a, [10, 20, 30, 255], "target centre missed fixture geometry");
|
||||
if index < 2 {
|
||||
assert!(i16::from(a[0]).abs_diff(i16::from(b[0])) > 20, "selected face failed to rotate: {a:?} {b:?}");
|
||||
} else {
|
||||
assert_eq!(a, b, "unselected scalar control changed");
|
||||
}
|
||||
}
|
||||
assert_eq!(first.get_pixel(0, 0).0, [10, 20, 30, 255]);
|
||||
assert_eq!(first.get_pixel(0, 0), second.get_pixel(0, 0));
|
||||
assert_eq!(original, scene.meshes.iter().map(|b| b.mesh.positions.clone()).collect::<Vec<_>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reflection_bridge_preserves_anisotropic_pdf_weight_and_visual_rotation() {
|
||||
let targets = prepare(&scene(), &options(), || Ok(())).unwrap();
|
||||
let surface = scene().meshes[0].surface.unwrap();
|
||||
let a = targets[0].unwrap().sample(surface, Vec3::Z, Vec3::Z, [0.4, 0.2]).unwrap().unwrap();
|
||||
let b = targets[1].unwrap().sample(surface, Vec3::Z, Vec3::Z, [0.4, 0.2]).unwrap().unwrap();
|
||||
let core = AnisotropicSurface::new(surface.base_color(), surface.metallic(), 0.25, 0.8, surface.dielectric_ior()).unwrap();
|
||||
// Production now proposes visible normals. Keep the exact bridge equality
|
||||
// checks; the legacy NDF has separate unchanged numerical controls.
|
||||
let reference = core.sample_visible_reflection(VisualFrame::new(Vec3::Z, Vec3::X).unwrap(), Vec3::Z, Vec3::Z, [0.4, 0.2]).unwrap().unwrap();
|
||||
assert_eq!(a.direction, reference.direction);
|
||||
assert_eq!(a.pdf, reference.pdf);
|
||||
assert_eq!(a.weight, reference.weight);
|
||||
assert!((b.direction - Vec3::new(-a.direction.y, a.direction.x, a.direction.z)).len() < 1e-13);
|
||||
assert!((b.pdf - a.pdf).abs() < 1e-13);
|
||||
assert!(
|
||||
(core.brdf(VisualFrame::new(Vec3::Z, Vec3::X).unwrap(), Vec3::Z, Vec3::Z, a.direction).unwrap()
|
||||
- core.brdf(VisualFrame::new(Vec3::Z, Vec3::X).unwrap(), Vec3::Z, a.direction, Vec3::Z).unwrap())
|
||||
.len()
|
||||
< 1e-13
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn equal_axes_use_the_existing_isotropic_samples_and_null_mass() {
|
||||
let mut options = options();
|
||||
for input in options.anisotropic_faces.iter_mut().flatten() {
|
||||
input.roughness_x = 1.0;
|
||||
input.roughness_y = 1.0;
|
||||
}
|
||||
let targets = prepare(&scene(), &options, || Ok(())).unwrap();
|
||||
let surface = scene().meshes[0].surface.unwrap();
|
||||
let isotropic = OpaqueSurface::new(surface.base_color(), surface.metallic(), 1.0, surface.dielectric_ior()).unwrap();
|
||||
let mut accepted = 0;
|
||||
for i in 0..1024 {
|
||||
let u = [(i as f64 + 0.5) / 1024.0, 0.3];
|
||||
let a = targets[0].unwrap().sample(surface, Vec3::Z, Vec3::Z, u).unwrap();
|
||||
let b = super::super::reflection::rough_specular(isotropic, Vec3::Z, Vec3::Z, u).unwrap();
|
||||
match (a, b) {
|
||||
(Some(a), Some(b)) => {
|
||||
accepted += 1;
|
||||
assert_eq!(a.direction, b.direction);
|
||||
assert_eq!(a.pdf, b.pdf);
|
||||
assert_eq!(a.weight, b.weight);
|
||||
assert!((a.pdf - 1.0 / (4.0 * std::f64::consts::PI)).abs() < 1e-13);
|
||||
}
|
||||
(None, None) => {}
|
||||
_ => panic!("isotropic sample/null mismatch"),
|
||||
}
|
||||
}
|
||||
assert_eq!(accepted, 512); // Remaining half is null, never renormalized.
|
||||
}
|
||||
+322
@@ -0,0 +1,322 @@
|
||||
use super::*;
|
||||
use crate::job::{AnisotropicFaceOptions, AnisotropicOrientation, ReflectionBody, ReflectionMode, ReflectionOptions};
|
||||
use crate::{ProductMesh, StandardView};
|
||||
use solidcraft_geom::Mesh;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn scene() -> ProductScene {
|
||||
let reflector = ProductMesh {
|
||||
transmission: None,
|
||||
name: "explicit planar reflector".into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(-20.0, -20.0, -20.0), Vec3::new(20.0, -20.0, -20.0), Vec3::new(20.0, 20.0, 20.0), Vec3::new(-20.0, 20.0, 20.0)],
|
||||
normals: vec![super::super::unit(Vec3::new(0.0, -1.0, 1.0)).unwrap(); 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![7, 7],
|
||||
..Default::default()
|
||||
}),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(0.8, 0.8, 0.8), 1.0, 0.4, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
};
|
||||
let object = ProductMesh {
|
||||
transmission: None,
|
||||
name: "off-axis orange object".into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(-3.0, -12.0, 10.0), Vec3::new(-3.0, 12.0, 10.0), Vec3::new(3.0, 12.0, 10.0), Vec3::new(3.0, -12.0, 10.0)],
|
||||
normals: vec![-Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
}),
|
||||
color: [240, 80, 20],
|
||||
opacity: 1.0,
|
||||
surface: None,
|
||||
faces: Vec::new(),
|
||||
};
|
||||
let meshes = vec![reflector, object];
|
||||
let bounds = meshes.iter().map(|b| b.mesh.bounds()).reduce(|a, b| a.union(&b)).unwrap();
|
||||
ProductScene { meshes, bounds }
|
||||
}
|
||||
|
||||
fn request(orientation: AnisotropicOrientation, reflect: bool) -> ImageRequest {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Front);
|
||||
let target = AnisotropicFaceOptions {
|
||||
body_index: 0,
|
||||
body_name: "explicit planar reflector".into(),
|
||||
face: 7,
|
||||
tangent: [1.0, 0.0, 0.0],
|
||||
orientation,
|
||||
roughness_x: 0.2,
|
||||
roughness_y: 0.55,
|
||||
};
|
||||
let options = RaytraceOptions {
|
||||
anisotropic_faces: [Some(target), None],
|
||||
reflections: reflect.then(|| ReflectionOptions {
|
||||
bodies: vec![ReflectionBody { body: "explicit planar reflector".into(), mode: ReflectionMode::RoughSpecular }],
|
||||
max_bounces: 1,
|
||||
samples: 64,
|
||||
}),
|
||||
lights: Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, -1.0], color: [1.0; 3], intensity: 2.0 }]),
|
||||
shadows: false,
|
||||
..Default::default()
|
||||
};
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(options),
|
||||
camera,
|
||||
width: 1,
|
||||
height: 1,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn render(request: ImageRequest) -> [u8; 4] {
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new(scene(), request, CancelToken::default(), options).unwrap();
|
||||
for _ in 0..200_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
|
||||
return ::image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0;
|
||||
}
|
||||
}
|
||||
panic!("bounded reflected scene PNG did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_reflected_object_changes_with_the_selected_planar_orientation() {
|
||||
let baseline = render(request(AnisotropicOrientation::Zero, false));
|
||||
assert_eq!(baseline, [0, 0, 0, 255]); // Light is below the reflector; no direct term.
|
||||
let a = render(request(AnisotropicOrientation::Zero, true));
|
||||
let b = render(request(AnisotropicOrientation::QuarterTurn, true));
|
||||
assert!(a[0] > a[1] && a[1] > a[2], "actual orange object must contribute via a secondary hit: {a:?}");
|
||||
assert_ne!(a, b, "rotation must affect actual reflected scene transport");
|
||||
assert_eq!(a, render(request(AnisotropicOrientation::Zero, true)));
|
||||
}
|
||||
|
||||
fn union_environment() -> crate::lighting::environment_input::EnvironmentInput {
|
||||
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec();
|
||||
for _ in 0..8 {
|
||||
bytes.extend_from_slice(&[128, 64, 32, 129]);
|
||||
}
|
||||
crate::lighting::environment_input::EnvironmentInput::new(crate::lighting::HdrSource::new(bytes).unwrap(), 0.0, 1.0, 4).unwrap()
|
||||
}
|
||||
|
||||
fn secondary_union(orientation: AnisotropicOrientation, intensity: f64) -> ImageTask {
|
||||
let mut req = request(orientation, true);
|
||||
let options = req.raytrace.as_mut().unwrap();
|
||||
options.lights = Some(Vec::new());
|
||||
options.punctual_lights = Some(vec![job::PunctualLightOptions {
|
||||
position_mm: [0.0, 0.0, -10.0],
|
||||
color: [1.0; 3],
|
||||
intensity,
|
||||
reference_distance_mm: 20.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
}]);
|
||||
job::led_strip::LedStripOptions {
|
||||
center_mm: [0.0, 0.0, -10.0],
|
||||
length_mm: 8.0,
|
||||
width_mm: 0.5,
|
||||
length_axis: [1.0, 0.0, 0.0],
|
||||
width_axis: [0.0, 1.0, 0.0],
|
||||
color: [1.0; 3],
|
||||
intensity,
|
||||
}
|
||||
.append_to(options, 4)
|
||||
.unwrap();
|
||||
ImageTask::new_with_environment(scene(), req.clone(), CancelToken::default(), req.raytrace.unwrap(), Some(union_environment())).unwrap()
|
||||
}
|
||||
|
||||
fn render_secondary_union(mut task: ImageTask, units: usize) -> (Vec<u8>, bool, bool, bool) {
|
||||
let mut reset = false;
|
||||
let mut point = false;
|
||||
let mut area = false;
|
||||
for _ in 0..500_000 {
|
||||
if let Some(p) = task.pending.as_ref().filter(|p| p.bounce == 1) {
|
||||
if p.hit.is_none() {
|
||||
assert_eq!(p.punctual_index, 0);
|
||||
assert_eq!(p.area_light, 0);
|
||||
assert_eq!(p.area_index, 0);
|
||||
assert!(!p.punctual_shadow && !p.punctual_ready && !p.area_shadow && !p.area_ready);
|
||||
assert_eq!(p.punctual_value, Vec3::ZERO);
|
||||
assert_eq!(p.area_value, Vec3::ZERO);
|
||||
reset = true;
|
||||
} else {
|
||||
point |= p.punctual_value.len2() > 0.0;
|
||||
area |= p.area_value.len2() > 0.0;
|
||||
}
|
||||
}
|
||||
if let TaskPoll::Complete(png) = task.step(units).unwrap() {
|
||||
return (png, reset, point, area);
|
||||
}
|
||||
}
|
||||
panic!("bounded HDR/anisotropic secondary union did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hdr_anisotropic_secondary_point_led_reset_and_partition_are_real_consumer_events() {
|
||||
let (lit, reset, point, area) = render_secondary_union(secondary_union(AnisotropicOrientation::Zero, 4.0), 1);
|
||||
assert!(reset && point && area, "secondary light state was not reset and consumed");
|
||||
let (dark, _, _, _) = render_secondary_union(secondary_union(AnisotropicOrientation::Zero, 0.0), 1);
|
||||
let rgb = |png: &[u8]| ::image::load_from_memory(png).unwrap().to_rgba8().get_pixel(0, 0).0;
|
||||
let a = rgb(&lit);
|
||||
let b = rgb(&dark);
|
||||
assert!(a[0] > b[0] && a[0] > a[1] && a[1] > a[2], "secondary direct lights must add orange response: {a:?} vs {b:?}");
|
||||
let (partitioned, _, _, _) = render_secondary_union(secondary_union(AnisotropicOrientation::Zero, 4.0), 128);
|
||||
assert_eq!(lit, partitioned);
|
||||
let (rotated, _, _, _) = render_secondary_union(secondary_union(AnisotropicOrientation::QuarterTurn, 4.0), 1);
|
||||
assert_ne!(lit, rotated);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn equal_axes_in_the_image_consumer_match_isotropic_reflection_bytes() {
|
||||
let mut isotropic = request(AnisotropicOrientation::Zero, true);
|
||||
isotropic.raytrace.as_mut().unwrap().anisotropic_faces = [None, None];
|
||||
let expected = render(isotropic);
|
||||
for orientation in [AnisotropicOrientation::Zero, AnisotropicOrientation::QuarterTurn] {
|
||||
let mut explicit = request(orientation, true);
|
||||
let target = explicit.raytrace.as_mut().unwrap().anisotropic_faces[0].as_mut().unwrap();
|
||||
target.roughness_x = 0.4;
|
||||
target.roughness_y = 0.4;
|
||||
assert_eq!(render(explicit), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mirrors_missing_or_ambiguous_reflection_targets_refuse_before_pixels() {
|
||||
for kind in 0..3 {
|
||||
let mut scene = scene();
|
||||
let mut request = request(AnisotropicOrientation::Zero, true);
|
||||
let reflection = &mut request.raytrace.as_mut().unwrap().reflections.as_mut().unwrap().bodies[0];
|
||||
match kind {
|
||||
0 => reflection.mode = ReflectionMode::Mirror,
|
||||
1 => reflection.body = "missing".into(),
|
||||
_ => scene.meshes[1].name = "explicit planar reflector".into(),
|
||||
}
|
||||
assert!(admit(&scene, &request, request.raytrace.as_ref().unwrap()).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secondary_anisotropic_traversal_shares_job_work_and_cancellation() {
|
||||
for cancel_now in [true, false] {
|
||||
let request = request(AnisotropicOrientation::Zero, true);
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
|
||||
reached = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(reached, "actual consumer never continued the sampled anisotropic ray");
|
||||
if cancel_now {
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn primary_last_shadow_and_reflected_continuations_each_charge_at_most_one_unit() {
|
||||
for shadows in [false, true] {
|
||||
let mut request = request(AnisotropicOrientation::Zero, true);
|
||||
request.raytrace.as_mut().unwrap().shadows = shadows;
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new(scene(), request, CancelToken::default(), options).unwrap();
|
||||
for _ in 0..10_000 {
|
||||
if task.bvh.is_some() {
|
||||
break;
|
||||
}
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
assert!(task.bvh.is_some());
|
||||
let mut primary = false;
|
||||
let mut last_shadow = false;
|
||||
let mut secondary = false;
|
||||
let mut secondary_hit = false;
|
||||
let mut secondary_terminal = false;
|
||||
for _ in 0..200_000 {
|
||||
if task.pixel == 1 {
|
||||
break;
|
||||
}
|
||||
let before_work = task.work.used();
|
||||
let before_sample = task.sample;
|
||||
let before = task.pending.as_ref().map(|p| (p.bounce, p.hit.is_some(), p.light));
|
||||
task.pixel_one().unwrap();
|
||||
assert!(task.work.used() - before_work <= 1, "one pixel continuation consumed traversal and shading work together");
|
||||
let after = task.pending.as_ref().map(|p| (p.bounce, p.hit.is_some(), p.light));
|
||||
primary |= matches!(before, Some((0, false, _))) && matches!(after, Some((0, true, _)));
|
||||
last_shadow |= shadows && matches!(before, Some((_, true, 0))) && matches!(after, Some((_, true, 1)));
|
||||
secondary |= after.is_some_and(|(bounce, _, _)| bounce > 0);
|
||||
secondary_hit |= before.is_some_and(|(bounce, hit, _)| bounce > 0 && !hit) && after.is_some_and(|(bounce, hit, _)| bounce > 0 && hit);
|
||||
secondary_terminal |= before.is_some_and(|(bounce, _, _)| bounce > 0) && (task.sample != before_sample || task.pixel == 1);
|
||||
}
|
||||
assert_eq!(task.pixel, 1);
|
||||
assert!(primary && secondary && secondary_hit && secondary_terminal);
|
||||
assert!(!shadows || last_shadow);
|
||||
}
|
||||
// The public poll groups at most four of those continuations.
|
||||
let request = request(AnisotropicOrientation::Zero, true);
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new(scene(), request, CancelToken::default(), options).unwrap();
|
||||
for _ in 0..10_000 {
|
||||
if task.bvh.is_some() {
|
||||
break;
|
||||
}
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
let mut completed = false;
|
||||
for _ in 0..200_000 {
|
||||
let before = task.work.used();
|
||||
let poll = task.step(4).unwrap();
|
||||
assert!(task.work.used() - before <= 4);
|
||||
if matches!(poll, TaskPoll::Complete(_)) {
|
||||
completed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(completed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancellation_after_last_shadow_is_seen_before_shading_or_sampling() {
|
||||
for secondary in [false, true] {
|
||||
let mut request = request(AnisotropicOrientation::Zero, true);
|
||||
request.raytrace.as_mut().unwrap().shadows = true;
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.light == task.lights.lights().len() && (p.bounce > 0) == secondary) {
|
||||
reached = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(reached && task.pixels.is_empty());
|
||||
let before_sample = task.sample;
|
||||
cancel.cancel();
|
||||
assert_eq!(task.pixel_one().err().unwrap().code, ErrorCode::Cancelled);
|
||||
assert_eq!(task.sample, before_sample);
|
||||
assert!(task.pixels.is_empty());
|
||||
}
|
||||
}
|
||||
+626
@@ -0,0 +1,626 @@
|
||||
use super::*;
|
||||
use crate::job::{ReflectionBody, ReflectionMode, ReflectionOptions};
|
||||
use crate::lighting::{HdrSource, environment_input::EnvironmentInput};
|
||||
use solidcraft_geom::{Aabb3, Mesh};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn environment() -> EnvironmentInput {
|
||||
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec();
|
||||
for _ in 0..8 {
|
||||
bytes.extend_from_slice(&[128, 64, 32, 129]);
|
||||
}
|
||||
EnvironmentInput::new(HdrSource::new(bytes).unwrap(), 0.0, 1.0, 4).unwrap()
|
||||
}
|
||||
|
||||
fn scene(face_override: bool) -> ProductScene {
|
||||
let mut meshes = Vec::new();
|
||||
for (name, x) in [("Visible", 0.0), ("Hidden", 1000.0)] {
|
||||
let mesh = Mesh {
|
||||
positions: vec![
|
||||
Vec3::new(x - 20.0, -20.0, 0.0),
|
||||
Vec3::new(x + 20.0, -20.0, 0.0),
|
||||
Vec3::new(x + 20.0, 20.0, 0.0),
|
||||
Vec3::new(x - 20.0, 20.0, 0.0),
|
||||
],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
};
|
||||
meshes.push(crate::ProductMesh {
|
||||
transmission: None,
|
||||
name: name.into(),
|
||||
mesh: Arc::new(mesh),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
});
|
||||
}
|
||||
if face_override {
|
||||
meshes[0].faces.push(crate::FaceAppearance {
|
||||
transmission: None,
|
||||
face: 0,
|
||||
color: [0; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::ZERO, 1.0, 1.0, 1.5).unwrap()),
|
||||
});
|
||||
}
|
||||
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
ProductScene { meshes, bounds }
|
||||
}
|
||||
|
||||
fn task(samples: u8, selected: bool, face_override: bool, shadows: bool) -> ImageTask {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
let options = RaytraceOptions {
|
||||
lights: Some(Vec::new()),
|
||||
shadows,
|
||||
reflections: Some(ReflectionOptions {
|
||||
bodies: vec![ReflectionBody { body: if selected { "Visible" } else { "Hidden" }.into(), mode: ReflectionMode::RoughSpecular }],
|
||||
max_bounces: 2,
|
||||
samples,
|
||||
}),
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(options.clone()),
|
||||
camera,
|
||||
width: 1,
|
||||
height: 1,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
};
|
||||
ImageTask::new_with_environment(scene(face_override), request, CancelToken::default(), options, Some(environment())).unwrap()
|
||||
}
|
||||
|
||||
fn render(mut task: ImageTask, revoke_fixed_primary_proof: bool) -> (Vec<u8>, u64, usize) {
|
||||
let mut primaries = 0;
|
||||
for _ in 0..200_000 {
|
||||
// Test-only reference: revoking the generator proof keeps the original R
|
||||
// path/accumulation. No product switch, sampler, work limit or input changes.
|
||||
if revoke_fixed_primary_proof && let Some(p) = task.pending.as_mut() {
|
||||
p.repeatable_primary = false;
|
||||
}
|
||||
let absent = task.pending.is_none();
|
||||
match task.step(1).unwrap() {
|
||||
TaskPoll::Complete(png) => return (png, task.work.used(), primaries),
|
||||
TaskPoll::Pending(_) => {
|
||||
if absent && task.pending.is_some() {
|
||||
primaries += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
panic!("bounded single-pixel fixture did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nonselected_fixed_primary_matches_analytic_color_and_legacy_r_with_less_work() {
|
||||
for samples in [1, 4, 16, 64] {
|
||||
for shadows in [false, true] {
|
||||
let (fast, work, primaries) = render(task(samples, false, false, shadows), false);
|
||||
let (legacy, legacy_work, legacy_primaries) = render(task(samples, false, false, shadows), true);
|
||||
assert_eq!(fast, legacy, "same radiance without repeated identical primary samples");
|
||||
assert_eq!(primaries, 1);
|
||||
assert_eq!(legacy_primaries, usize::from(samples));
|
||||
if samples == 1 {
|
||||
assert_eq!(work, legacy_work);
|
||||
} else {
|
||||
assert!(work < legacy_work);
|
||||
}
|
||||
if !shadows {
|
||||
// White roughness-one conductor, constant RGB(1,.5,.25), fixed
|
||||
// 2x2 solid-angle strata: two z=.5 contributions average to1/3.
|
||||
let expected = [1.0 / 3.0, 1.0 / 6.0, 1.0 / 12.0].map(|v| encode8(v / (1.0 + v)));
|
||||
let image = ::image::load_from_memory(&fast).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [expected[0], expected[1], expected[2], 255]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_rough_primary_retains_every_sample_including_null_attempts() {
|
||||
for samples in [4, 16, 64] {
|
||||
let (actual, work, primaries) = render(task(samples, true, false, false), false);
|
||||
let (reference, reference_work, reference_primaries) = render(task(samples, true, false, false), true);
|
||||
assert_eq!(actual, reference);
|
||||
assert_eq!(work, reference_work);
|
||||
assert_eq!(primaries, usize::from(samples));
|
||||
assert_eq!(primaries, reference_primaries);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn captured_face_override_is_resolved_before_nonselected_fast_path_finishes() {
|
||||
let (png, work, count) = render(task(64, false, true, false), false);
|
||||
let (reference, reference_work, reference_count) = render(task(64, false, true, false), true);
|
||||
assert_eq!(png, reference);
|
||||
assert_eq!(::image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0, [0, 0, 0, 255]);
|
||||
assert!(work < reference_work);
|
||||
assert_eq!(count, 1);
|
||||
assert_eq!(reference_count, 64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nonselected_visibility_keeps_shared_cancel_and_work_limit_refusal() {
|
||||
for cancel_now in [false, true] {
|
||||
let mut task = task(64, false, false, true);
|
||||
for _ in 0..10000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()));
|
||||
if cancel_now {
|
||||
task.cancel.cancel();
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, if cancel_now { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
|
||||
assert!(!task.done);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_sampling_cancellation_does_not_turn_partial_samples_into_png() {
|
||||
let mut task = task(64, true, false, false);
|
||||
for _ in 0..10000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.sample >= 1 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.sample >= 1 && task.sample < 64);
|
||||
task.cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
assert!(!task.done);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reused_shading_preserves_original_per_add_radiance_bound() {
|
||||
let mut task = task(64, false, false, false);
|
||||
for _ in 0..10000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.repeatable_primary) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.repeatable_primary));
|
||||
let error = task.finish_sample(Vec3::new(1e12 / 32.0, 0.0, 0.0)).unwrap_err();
|
||||
assert_eq!(error.code, ErrorCode::InvalidScene);
|
||||
assert_eq!(task.sample, 32);
|
||||
assert!(!task.done);
|
||||
assert!(task.pixels.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_admission_and_task_slot_caps_are_not_expanded() {
|
||||
let fast = task(64, false, false, false);
|
||||
let legacy = task(64, false, false, false);
|
||||
assert_eq!(*fast.visibility_owner.options(), *legacy.visibility_owner.options());
|
||||
assert_eq!(fast.admission.estimated_total_bytes, legacy.admission.estimated_total_bytes);
|
||||
assert_eq!(fast.visibility_owner.options().reflections.as_ref().unwrap().samples, 64);
|
||||
assert!(std::mem::size_of::<ImageTask>() <= 4096);
|
||||
assert_eq!(crate::raytrace::MAX_WORK, 1_000_000_000);
|
||||
assert_eq!(job::image::MAX_JOB_BYTES, 384 * 1024 * 1024);
|
||||
}
|
||||
|
||||
// Fixed spatial-generator reuse regressions. Source written; execution pending.
|
||||
|
||||
fn spatial_reuse_fixture(s: u8, r: u8, selected: bool, face_override: bool, shadows: bool) -> ImageTask {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
let options = RaytraceOptions {
|
||||
primary_samples: s,
|
||||
lights: Some(Vec::new()),
|
||||
shadows,
|
||||
reflections: Some(ReflectionOptions {
|
||||
bodies: vec![ReflectionBody { body: if selected { "Visible" } else { "Hidden" }.into(), mode: ReflectionMode::RoughSpecular }],
|
||||
max_bounces: 2,
|
||||
samples: r,
|
||||
}),
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(options.clone()),
|
||||
camera,
|
||||
width: 1,
|
||||
height: 1,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
};
|
||||
let mut scene = scene(face_override);
|
||||
// Explicit full coverage fixture; hidden selected body remains far off-axis.
|
||||
let visible = Arc::get_mut(&mut scene.meshes[0].mesh).unwrap();
|
||||
for p in &mut visible.positions {
|
||||
p.x *= 5.0;
|
||||
p.y *= 5.0;
|
||||
}
|
||||
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
ImageTask::new_with_environment(scene, request, CancelToken::default(), options, Some(environment())).unwrap()
|
||||
}
|
||||
|
||||
type SpatialBoundary = (u8, u8, u16, [u64; 6]);
|
||||
fn spatial_reference_render(mut task: ImageTask, revoke: bool) -> (Vec<u8>, Vec<SpatialBoundary>) {
|
||||
let mut boundaries = Vec::new();
|
||||
for _ in 0..1_000_000 {
|
||||
// Exactly the established reference technique. Revoke before every step,
|
||||
// including BEFORE the first completed shade could retain a cache entry.
|
||||
if revoke && let Some(p) = task.pending.as_mut() {
|
||||
p.repeatable_primary = false;
|
||||
}
|
||||
let before = task.work.used();
|
||||
let previous = (task.pixel, task.spatial, task.sample);
|
||||
let poll = task.step(1).unwrap();
|
||||
assert!(task.work.used() - before <= 4);
|
||||
if revoke {
|
||||
assert!(
|
||||
task.pending.as_ref().is_none_or(|p| p.light <= task.lights.lights().len()),
|
||||
"revoked-proof reference retained a completed cache entry"
|
||||
);
|
||||
}
|
||||
if (task.pixel, task.spatial) == (previous.0, previous.1) && task.sample > previous.2 {
|
||||
let p = task.pixel_radiance;
|
||||
let s = task.spatial_radiance;
|
||||
boundaries.push((
|
||||
task.spatial,
|
||||
task.sample,
|
||||
task.primary_coverage,
|
||||
[p.x.to_bits(), p.y.to_bits(), p.z.to_bits(), s.x.to_bits(), s.y.to_bits(), s.z.to_bits()],
|
||||
));
|
||||
}
|
||||
if let TaskPoll::Complete(png) = poll {
|
||||
return (png, boundaries);
|
||||
}
|
||||
}
|
||||
panic!("bounded actual-consumer spatial fixture did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intra_spatial_nonselected_reuse_matches_uncached_ordered_sums_coverage_and_png() {
|
||||
for s in [4, 16] {
|
||||
for r in [1, 4, 16, 64] {
|
||||
for shadows in [false, true] {
|
||||
for face_override in [false, true] {
|
||||
let fast = spatial_reference_render(spatial_reuse_fixture(s, r, false, face_override, shadows), false);
|
||||
let reference = spatial_reference_render(spatial_reuse_fixture(s, r, false, face_override, shadows), true);
|
||||
assert_eq!(fast, reference, "exact actual ImageTask PNG and per-S accumulator bits/coverage");
|
||||
assert_eq!(fast.1.len(), usize::from(s) * usize::from(r));
|
||||
for (ordinal, boundary) in fast.1.iter().enumerate() {
|
||||
assert_eq!(boundary.0, (ordinal / usize::from(r)) as u8);
|
||||
assert_eq!(boundary.1, (ordinal % usize::from(r)) as u8 + 1);
|
||||
assert_eq!(boundary.2, ordinal as u16 + 1);
|
||||
}
|
||||
if !face_override {
|
||||
assert!(
|
||||
fast.1.iter().any(|b| b.3[..3].iter().any(|v| f64::from_bits(*v) > 0.0)),
|
||||
"HDR actual-consumer comparison must include positive radiance"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn completed_spatial_reuse_checks_cancel_and_work_limit_before_any_mutation() {
|
||||
for cancel in [false, true] {
|
||||
for ordinal in [1, 2] {
|
||||
let mut task = spatial_reuse_fixture(16, 64, false, false, true);
|
||||
for _ in 0..1_000_000 {
|
||||
if task.sample == ordinal
|
||||
&& task
|
||||
.pending
|
||||
.as_ref()
|
||||
.is_some_and(|p| p.repeatable_primary && p.bounce == 0 && p.hit.is_some() && p.light == task.lights.lights().len() + 1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
task.step(1).unwrap();
|
||||
}
|
||||
assert_eq!(task.sample, ordinal);
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.light == task.lights.lights().len() + 1));
|
||||
let before = (task.work.used(), task.sample, task.primary_coverage, task.pixel_radiance);
|
||||
if cancel {
|
||||
task.cancel.cancel();
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, if cancel { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
|
||||
assert_eq!((task.work.used(), task.sample, task.primary_coverage, task.pixel_radiance), before);
|
||||
assert!(!task.done && task.pixels.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
// Bits: directional, point, spot, rectangle, lowered LED, HDR. Every source can
|
||||
// be isolated, preventing an all-black or one-source-only comparison from
|
||||
// masquerading as combined-consumer coverage. Inputs are original fixtures.
|
||||
fn spatial_lights_fixture(config: (u8, u8, u32, u32, bool), mask: u8, width: u32, partial: bool) -> ImageTask {
|
||||
let (s, r, n, seed, shadows) = config;
|
||||
let previous = spatial_reuse_fixture(s, r, false, false, shadows);
|
||||
let (fixture_scene, mut options) = previous.visibility_owner.into_capture();
|
||||
options.exposure_ev = 1.0;
|
||||
options.lights = Some(if mask & 1 != 0 {
|
||||
vec![job::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]
|
||||
} else {
|
||||
Vec::new()
|
||||
});
|
||||
let point = job::PunctualLightOptions {
|
||||
position_mm: [0.0, 0.0, 40.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 1.0,
|
||||
reference_distance_mm: 40.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
};
|
||||
let mut punctual = Vec::new();
|
||||
if mask & 2 != 0 {
|
||||
punctual.push(point);
|
||||
}
|
||||
if mask & 4 != 0 {
|
||||
punctual.push(job::PunctualLightOptions {
|
||||
color: [0.25, 1.0, 0.5],
|
||||
cone: Some(job::SpotConeOptions { emitted_axis: [0.0, 0.0, -1.0], inner_half_angle_radians: 0.7, outer_half_angle_radians: 1.4 }),
|
||||
..point
|
||||
});
|
||||
}
|
||||
options.punctual_lights = if punctual.is_empty() { None } else { Some(punctual) };
|
||||
if mask & 8 != 0 {
|
||||
options.area_lights = Some(vec![job::RectangleLightOptions {
|
||||
center_mm: [-5.0, 0.0, 50.0],
|
||||
edge_u_mm: [20.0, 0.0, 0.0],
|
||||
edge_v_mm: [0.0, -20.0, 0.0],
|
||||
color: [0.5, 0.25, 1.0],
|
||||
intensity: 3.0,
|
||||
}]);
|
||||
options.area_samples = Some(n);
|
||||
}
|
||||
if mask & 16 != 0 {
|
||||
job::led_strip::LedStripOptions {
|
||||
center_mm: [5.0, 0.0, 50.0],
|
||||
length_mm: 20.0,
|
||||
width_mm: 2.0,
|
||||
length_axis: [1.0, 0.0, 0.0],
|
||||
width_axis: [0.0, -1.0, 0.0],
|
||||
color: [1.0, 0.25, 0.5],
|
||||
intensity: 4.0,
|
||||
}
|
||||
.append_to(&mut options, n)
|
||||
.unwrap();
|
||||
}
|
||||
if options.area_lights.is_some() {
|
||||
options.seed = Some(seed);
|
||||
}
|
||||
let mut scene = fixture_scene;
|
||||
if partial {
|
||||
let mesh = Arc::get_mut(&mut scene.meshes[0].mesh).unwrap();
|
||||
mesh.positions[0].x = 0.0;
|
||||
mesh.positions[3].x = 0.0;
|
||||
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
}
|
||||
let request = ImageRequest { width, raytrace: Some(options.clone()), ..previous.request };
|
||||
ImageTask::new_with_environment(scene, request, previous.cancel, options, if mask & 32 != 0 { Some(environment()) } else { None }).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spatial_reuse_actual_nonzero_light_consumers_and_seeded_union_match_reference() {
|
||||
for mask in [1, 2, 4, 8, 16, 32, 63] {
|
||||
let config = (4, 4, 4, 7, false);
|
||||
let fast = spatial_reference_render(spatial_lights_fixture(config, mask, 1, false), false);
|
||||
let reference = spatial_reference_render(spatial_lights_fixture(config, mask, 1, false), true);
|
||||
assert_eq!(fast, reference, "actual isolated source mask {mask}");
|
||||
assert!(fast.1.iter().any(|b| b.3[..3].iter().any(|v| f64::from_bits(*v) > 0.0)), "source mask {mask} contributed no radiance");
|
||||
}
|
||||
// Finite pairwise matrix, not a timing benchmark. R64 is covered by the HDR
|
||||
// matrix above; every allowed rectangle N and two nonzero seeds are explicit.
|
||||
for (s, r, n) in [(4, 4, 1), (16, 4, 4), (4, 16, 16), (4, 4, 64)] {
|
||||
for seed in [7, 0xfedc_ba98] {
|
||||
for shadows in [false, true] {
|
||||
let config = (s, r, n, seed, shadows);
|
||||
assert_eq!(
|
||||
spatial_reference_render(spatial_lights_fixture(config, 63, 1, false), false),
|
||||
spatial_reference_render(spatial_lights_fixture(config, 63, 1, false), true)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_pixels_spatial_hits_misses_and_independent_jobs_do_not_share_reuse() {
|
||||
for s in [4, 16] {
|
||||
for shadows in [false, true] {
|
||||
let config = (s, 4, 4, 7, shadows);
|
||||
let fast = spatial_reference_render(spatial_lights_fixture(config, 63, 3, true), false);
|
||||
let reference = spatial_reference_render(spatial_lights_fixture(config, 63, 3, true), true);
|
||||
assert_eq!(fast, reference);
|
||||
assert_eq!(fast.1.len(), 3 * usize::from(s) * 4);
|
||||
assert!(fast.1.iter().any(|b| b.2 == 0), "fixture must include primary misses");
|
||||
assert!(fast.1.iter().any(|b| b.2 > 0), "fixture must include primary hits");
|
||||
assert!(fast.1.iter().any(|b| b.0 == s - 1 && b.1 == 4 && b.2 == u16::from(s) * 2), "middle pixel must retain half spatial coverage");
|
||||
// A new captured job with different sources/seed/coverage has its own
|
||||
// actual reference; prior jobs must not contribute state to it.
|
||||
let changed = (s, 4, 16, 0xfedc_ba98, shadows);
|
||||
assert_eq!(
|
||||
spatial_reference_render(spatial_lights_fixture(changed, 16, 2, false), false),
|
||||
spatial_reference_render(spatial_lights_fixture(changed, 16, 2, false), true)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn at_first_completed_spatial_primary() -> ImageTask {
|
||||
let mut task = spatial_reuse_fixture(4, 4, false, false, true);
|
||||
for _ in 0..1_000_000 {
|
||||
if task.sample == 1 && task.pending.as_ref().is_some_and(|p| p.light == task.lights.lights().len() + 1) {
|
||||
return task;
|
||||
}
|
||||
task.step(1).unwrap();
|
||||
}
|
||||
panic!("actual shading did not reach reusable completion");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reused_r_addition_enforces_finite_bound_and_coverage_before_publication() {
|
||||
for corrupt in [0, 1, 2, 3] {
|
||||
let mut task = at_first_completed_spatial_primary();
|
||||
match corrupt {
|
||||
0 => {
|
||||
task.pixel_radiance = Vec3::new(1e12, 0.0, 0.0);
|
||||
task.pending.as_mut().unwrap().radiance = Vec3::new(1.0, 0.0, 0.0);
|
||||
}
|
||||
1 => {
|
||||
task.pending.as_mut().unwrap().radiance = Vec3::new(f64::NAN, 0.0, 0.0);
|
||||
}
|
||||
2 => {
|
||||
task.pending.as_mut().unwrap().radiance = Vec3::new(f64::INFINITY, 0.0, 0.0);
|
||||
}
|
||||
_ => {
|
||||
task.primary_coverage = 1024;
|
||||
}
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::InvalidScene);
|
||||
assert!(!task.done && task.pixels.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn completed_marker_refuses_malformed_proof_sample_bounce_hit_and_shading_state() {
|
||||
for corrupt in 0..19 {
|
||||
let mut task = at_first_completed_spatial_primary();
|
||||
match corrupt {
|
||||
0 => task.pending.as_mut().unwrap().repeatable_primary = false,
|
||||
1 => task.pending.as_mut().unwrap().bounce = 1,
|
||||
2 => task.pending.as_mut().unwrap().hit = None,
|
||||
3 => task.sample = 0,
|
||||
4 => task.sample = task.sample_count(),
|
||||
5 => task.pending.as_mut().unwrap().punctual_shadow = true,
|
||||
6 => task.pending.as_mut().unwrap().area_ready = true,
|
||||
7 => task.pending.as_mut().unwrap().environment_sample = 0,
|
||||
8 => task.pending.as_mut().unwrap().area_light = 1,
|
||||
9 => {
|
||||
let (fixture_scene, mut fixture_options) = task.visibility_owner.into_capture();
|
||||
fixture_options.reflections.as_mut().unwrap().bodies[0].body = "Visible".into();
|
||||
task.visibility_owner = dielectric::DirectVisibilityOwner::new(fixture_scene, fixture_options);
|
||||
}
|
||||
10 => task.sample = task.sample_count() + 1,
|
||||
11 => task.pending.as_mut().unwrap().light = task.lights.lights().len() + 2,
|
||||
12 => task.finish_spatial = true,
|
||||
13 => task.emit_spatial_pixel = true,
|
||||
14 => task.spatial = task.visibility_owner.options().primary_samples,
|
||||
15 => task.pending.as_mut().unwrap().emission_cursor = 1,
|
||||
16 => task.pending.as_mut().unwrap().surface_cursor = 1,
|
||||
17 => task.pending.as_mut().unwrap().surface_ready = false,
|
||||
_ => task.pending.as_mut().unwrap().surface_index = Some(0),
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::InvalidScene);
|
||||
assert!(!task.done && task.pixels.is_empty());
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn spatial_reuse_observes_cancellation_and_limit_at_shading_finalization_and_emission() {
|
||||
for phase in 0..3 {
|
||||
for cancel in [false, true] {
|
||||
let mut task = spatial_reuse_fixture(4, 4, false, false, true);
|
||||
let reached = |task: &ImageTask| match phase {
|
||||
0 => task.sample == 0 && task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.environment_sample == 0),
|
||||
1 => task.finish_spatial,
|
||||
_ => task.emit_spatial_pixel,
|
||||
};
|
||||
for _ in 0..200_000 {
|
||||
if reached(&task) {
|
||||
break;
|
||||
}
|
||||
task.step(1).unwrap();
|
||||
}
|
||||
assert!(reached(&task));
|
||||
let before = task.work.used();
|
||||
if cancel {
|
||||
task.cancel.cancel();
|
||||
} else {
|
||||
task.work.limit = before;
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, if cancel { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
|
||||
assert_eq!(task.work.used(), before);
|
||||
assert!(!task.done && task.pixels.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn spatial_quantum_png(mut task: ImageTask, quantum: usize) -> Vec<u8> {
|
||||
for _ in 0..1_000_000 {
|
||||
let used = task.work.used();
|
||||
let poll = task.step(quantum).unwrap();
|
||||
assert!(task.work.used() - used <= 4, "public work quantum exceeded");
|
||||
if let TaskPoll::Complete(png) = poll {
|
||||
return png;
|
||||
}
|
||||
}
|
||||
panic!("bounded spatial quantum fixture did not finish");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spatial_reuse_quantum_partitions_preserve_complete_png_and_public_work_bound() {
|
||||
for s in [4, 16] {
|
||||
let fixture = || spatial_lights_fixture((s, 4, 4, 7, true), 63, 3, true);
|
||||
let reference = spatial_reference_render(fixture(), true).0;
|
||||
for quantum in [1, 4, 16384] {
|
||||
assert_eq!(spatial_quantum_png(fixture(), quantum), reference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn spatial_surface_fixture(s: u8, r: u8, selected: bool) -> ImageTask {
|
||||
let previous = spatial_lights_fixture((s, r, 4, 7, true), 63, 2, true);
|
||||
let (fixture_scene, mut options) = previous.visibility_owner.into_capture();
|
||||
options.surface_effects = Some(vec![crate::surface_patterns::SurfaceEffect {
|
||||
body: "Visible".into(),
|
||||
frame: Default::default(),
|
||||
repeat_mm: [20.0, 27.0, 31.0],
|
||||
roughness_amplitude: 0.2,
|
||||
bump_amplitude_mm: 0.4,
|
||||
}]);
|
||||
if selected {
|
||||
options.reflections.as_mut().unwrap().bodies[0].body = "Visible".into();
|
||||
}
|
||||
let request = ImageRequest { raytrace: Some(options.clone()), ..previous.request };
|
||||
ImageTask::new_with_environment(fixture_scene, request, previous.cancel, options, Some(environment())).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn surface_shared_hit_preserves_aa_ordered_prefixes_coverage_and_completed_png() {
|
||||
for s in [4, 16] {
|
||||
for r in [1, 4, 16] {
|
||||
for selected in [false, true] {
|
||||
let expected = spatial_reference_render(spatial_surface_fixture(s, r, selected), true);
|
||||
let actual = spatial_reference_render(spatial_surface_fixture(s, r, selected), false);
|
||||
assert_eq!(actual, expected, "S={s}, R={r}, selected={selected}");
|
||||
for quantum in [4, 16384] {
|
||||
assert_eq!(spatial_quantum_png(spatial_surface_fixture(s, r, selected), quantum), expected.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+1203
File diff suppressed because it is too large.
Load diff
+310
@@ -0,0 +1,310 @@
|
||||
use super::*;
|
||||
use crate::lighting::{HdrSource, environment_input::EnvironmentInput};
|
||||
use solidcraft_geom::{Aabb3, Mesh};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn input() -> EnvironmentInput {
|
||||
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec();
|
||||
for _ in 0..8 {
|
||||
bytes.extend_from_slice(&[128, 64, 32, 129]);
|
||||
}
|
||||
EnvironmentInput::new(HdrSource::new(bytes).unwrap(), 0.0, 1.0, 64).unwrap()
|
||||
}
|
||||
fn scene() -> ProductScene {
|
||||
let mesh = Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(-10.0, -10.0, 0.0), Vec3::new(10.0, -10.0, 0.0), Vec3::new(10.0, 10.0, 0.0), Vec3::new(-10.0, 10.0, 0.0)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
ProductScene {
|
||||
bounds: mesh.bounds(),
|
||||
meshes: vec![crate::ProductMesh {
|
||||
transmission: None,
|
||||
name: "Original conductor plate".into(),
|
||||
mesh,
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
}
|
||||
}
|
||||
fn request() -> ImageRequest {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(RaytraceOptions { lights: Some(Vec::new()), ..Default::default() }),
|
||||
camera,
|
||||
width: 9,
|
||||
height: 9,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn png(source: ProductScene, environment: Option<EnvironmentInput>) -> Vec<u8> {
|
||||
let request = request();
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new_with_environment(source, request, CancelToken::default(), options, environment).unwrap();
|
||||
for _ in 0..200_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
|
||||
return png;
|
||||
}
|
||||
}
|
||||
panic!("bounded environment fixture did not complete");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real_cpu_png_conductor_matches_independent_environment_quadrature_once() {
|
||||
let baseline = ::image::load_from_memory(&png(scene(), None)).unwrap().to_rgba8();
|
||||
let rendered = png(scene(), Some(input()));
|
||||
assert_eq!(rendered, png(scene(), Some(input())));
|
||||
let image = ::image::load_from_memory(&rendered).unwrap().to_rgba8();
|
||||
// Independent roughness-one white-conductor f*cos= z/(2*pi*(1+z)).
|
||||
// The fixed 8x8 solid-angle strata integrate 4 positive z rows, each 8 samples.
|
||||
let factor = [0.125, 0.375, 0.625, 0.875].into_iter().map(|z| z / (1.0 + z)).sum::<f64>() / 4.0;
|
||||
let expected = [factor, factor * 0.5, factor * 0.25].map(|r| encode8(r / (1.0 + r)));
|
||||
assert_eq!(image.get_pixel(4, 4).0, [expected[0], expected[1], expected[2], 255]);
|
||||
assert_eq!(baseline.get_pixel(4, 4).0, [0, 0, 0, 255]);
|
||||
let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let background = ::image::load_from_memory(&png(empty, Some(input()))).unwrap().to_rgba8();
|
||||
assert!(background.pixels().all(|p| p.0 == [13, 27, 41, 255]));
|
||||
}
|
||||
|
||||
struct ProgressiveHdrResult {
|
||||
previews: Vec<(u32, Vec<u8>)>,
|
||||
png: Vec<u8>,
|
||||
work: u64,
|
||||
}
|
||||
|
||||
fn progressive_hdr_png(samples_per_pixel: u32, seed: u32, quantum: usize, environment: Option<EnvironmentInput>) -> ProgressiveHdrResult {
|
||||
let mut request = request();
|
||||
let mut options = request.raytrace.clone().unwrap();
|
||||
options.progressive = Some(job::CpuProgressiveOptions { samples_per_pixel, seed });
|
||||
options.reflections = Some(job::ReflectionOptions {
|
||||
bodies: vec![job::ReflectionBody { body: "Original conductor plate".into(), mode: job::ReflectionMode::RoughSpecular }],
|
||||
samples: 1,
|
||||
max_bounces: 2,
|
||||
});
|
||||
request.raytrace = Some(options.clone());
|
||||
let mut task = ImageTask::new_with_environment(scene(), request, CancelToken::default(), options, environment).unwrap();
|
||||
let mut previews = Vec::new();
|
||||
for _ in 0..300_000 {
|
||||
match task.step_with_previews(quantum).unwrap() {
|
||||
ImagePoll::Pending(_) => {}
|
||||
ImagePoll::Preview { png, samples_per_pixel } => previews.push((samples_per_pixel, png)),
|
||||
ImagePoll::Complete(png) => return ProgressiveHdrResult { previews, png, work: task.work.used() },
|
||||
}
|
||||
}
|
||||
panic!("bounded progressive HDR fixture did not finish");
|
||||
}
|
||||
|
||||
fn progressive_hdr_expected(samples: u32, seed: u32) -> [u8; 4] {
|
||||
// Independent normal-view, white-conductor reference at roughness one.
|
||||
// The centre pixel (40) stays inside the plate for every camera jitter.
|
||||
// GGX gives z = 1 - 2*u and weight = 2*z/(1+z) for z > 0; other
|
||||
// attempts are null events, not replacement samples. Only the variate
|
||||
// sequence is shared with production: no BSDF, PDF or film code is used.
|
||||
let sum: f64 = (0..samples)
|
||||
.map(|ordinal| {
|
||||
let z = 1.0 - 2.0 * progressive::variates(seed, 40, ordinal, 0x100)[0];
|
||||
if z > 0.0 { 2.0 * z / (1.0 + z) } else { 0.0 }
|
||||
})
|
||||
.sum();
|
||||
let mean = sum / f64::from(samples);
|
||||
// The original HDR is constant linear RGB (1, 0.5, 0.25). Average in
|
||||
// linear space over ALL attempts, then apply the display response once.
|
||||
let rgb = [mean, mean * 0.5, mean * 0.25].map(|r| encode8(r / (1.0 + r)));
|
||||
[rgb[0], rgb[1], rgb[2], 255]
|
||||
}
|
||||
|
||||
fn centre(png: &[u8]) -> [u8; 4] {
|
||||
::image::load_from_memory(png).unwrap().to_rgba8().get_pixel(4, 4).0
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn progressive_hdr_and_rough_reflections_keep_the_same_absolute_prefix_at_every_quantum() {
|
||||
for (target, checkpoints) in [(3, vec![1, 2]), (7, vec![1, 2, 3, 4, 5, 6])] {
|
||||
let result = progressive_hdr_png(target, 82, 1, Some(input()));
|
||||
assert_eq!(result.previews.iter().map(|(n, _)| *n).collect::<Vec<_>>(), checkpoints);
|
||||
let other = progressive_hdr_png(target, 82, 16384, Some(input()));
|
||||
assert_eq!(result.previews, other.previews);
|
||||
assert_eq!(result.png, other.png);
|
||||
assert_eq!(result.work, other.work);
|
||||
for (samples, checkpoint) in result.previews {
|
||||
assert_eq!(progressive_hdr_png(samples, 82, 3, Some(input())).png, checkpoint);
|
||||
assert_eq!(centre(&checkpoint), progressive_hdr_expected(samples, 82));
|
||||
}
|
||||
assert_eq!(centre(&result.png), progressive_hdr_expected(target, 82));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn progressive_hdr_rough_reflections_count_null_events_in_the_linear_mean() {
|
||||
// Preserve the previously failing seed rather than picking a brighter one:
|
||||
// its first three attempts are all null, and later attempts receive HDR.
|
||||
assert_eq!(progressive_hdr_expected(3, 82), [0, 0, 0, 255]);
|
||||
assert_ne!(progressive_hdr_expected(7, 82), [0, 0, 0, 255]);
|
||||
for seed in [0, 82, u32::MAX] {
|
||||
for samples in [1, 3, 7] {
|
||||
let result = progressive_hdr_png(samples, seed, 37, Some(input()));
|
||||
assert_eq!(centre(&result.png), progressive_hdr_expected(samples, seed), "seed={seed}, samples={samples}");
|
||||
let image = ::image::load_from_memory(&result.png).unwrap().to_rgba8();
|
||||
assert_eq!(image.get_pixel(0, 0).0, [13, 27, 41, 255], "HDR must not replace the display background");
|
||||
let unlit = progressive_hdr_png(samples, seed, 37, None);
|
||||
assert_eq!(centre(&unlit.png), [0, 0, 0, 255], "no direct lights or environment means zero radiance");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn environment_decode_and_secondary_visibility_share_cancellation_and_work_budget() {
|
||||
for during_visibility in [false, true] {
|
||||
let request = request();
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
|
||||
if during_visibility {
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()));
|
||||
}
|
||||
// Cancellation must win before any image publication, including decode preparation.
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
let request = request();
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new_with_environment(scene(), request, CancelToken::default(), options, Some(input())).unwrap();
|
||||
task.work = WorkBudget::new(1).unwrap();
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
#[test]
|
||||
fn native_host_captured_source_completes_and_releases_work_lease() {
|
||||
let host = job::CpuHost::for_platform().unwrap();
|
||||
assert!(host.descriptor_for(job::Integrator::Raytrace).unwrap().profiles[0].features.contains(&crate::RenderFeature::Hdri));
|
||||
assert!(!host.descriptor_for(job::Integrator::Raster).unwrap().profiles[0].features.contains(&crate::RenderFeature::Hdri));
|
||||
let handle = host.submit_with_environment(job::JobId { session: 1693, serial: 1, generation: 1 }, 1, scene(), request(), Some(input())).unwrap();
|
||||
assert_eq!(handle.wait_timeout(std::time::Duration::from_secs(60)).unwrap().progress.phase, Phase::Completed);
|
||||
let frame = handle.frame().unwrap().unwrap();
|
||||
assert!(host.admitted_bytes() >= frame.png().len() as u64 + 1024);
|
||||
drop(host);
|
||||
drop(frame);
|
||||
drop(handle);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn environment_visibility_respects_four_work_units_per_quantum_and_cancel() {
|
||||
let request = request();
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()));
|
||||
for _ in 0..32 {
|
||||
let before = task.work.used();
|
||||
assert!(matches!(task.step(4).unwrap(), TaskPoll::Pending(_)));
|
||||
assert!(task.work.used() - before <= 4, "visibility continuation double-charged shading and traversal");
|
||||
}
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_pixel_traversal_to_shading_transitions_debit_at_most_one_unit() {
|
||||
for (directional, shadows) in [(false, true), (true, true), (true, false)] {
|
||||
let mut request = request();
|
||||
let mut options = request.raytrace.clone().unwrap();
|
||||
options.shadows = shadows;
|
||||
if directional {
|
||||
options.lights = Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }]);
|
||||
}
|
||||
request.raytrace = Some(options.clone());
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
|
||||
while task.bvh.is_none() {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
let mut primary_transitions = 0;
|
||||
let mut directional_transitions = 0;
|
||||
for _ in 0..200_000 {
|
||||
if task.pixel == 81 {
|
||||
break;
|
||||
}
|
||||
let primary = task.pending.as_ref().is_some_and(|p| p.hit.is_none());
|
||||
let light_before = task.pending.as_ref().map(|p| p.light);
|
||||
let before = task.work.used();
|
||||
task.pixel_one().unwrap();
|
||||
assert!(task.work.used() - before <= 1, "traversal completion must yield before shading/sample debit");
|
||||
if primary && task.pending.as_ref().is_some_and(|p| p.hit.is_some()) {
|
||||
primary_transitions += 1;
|
||||
}
|
||||
if light_before == Some(0) && task.pending.as_ref().is_some_and(|p| p.light == 1) {
|
||||
directional_transitions += 1;
|
||||
}
|
||||
}
|
||||
assert_eq!(task.pixel, 81);
|
||||
assert!(primary_transitions > 0);
|
||||
if directional && shadows {
|
||||
assert!(directional_transitions > 0);
|
||||
}
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_cpu_profiles_admit_large_images_without_allocating_a_film() {
|
||||
let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
||||
let mut request = request();
|
||||
request.width = 3840;
|
||||
request.height = 2160;
|
||||
let mut options = request.raytrace.clone().unwrap();
|
||||
options.progressive = Some(job::CpuProgressiveOptions { samples_per_pixel: 128, seed: 9 });
|
||||
request.raytrace = Some(options.clone());
|
||||
assert!(admit(&empty, &request, &options).is_err());
|
||||
if usize::BITS < 64 || cfg!(target_arch = "wasm32") {
|
||||
return;
|
||||
}
|
||||
options.budget = job::CpuBudget::Studio;
|
||||
request.raytrace = Some(options.clone());
|
||||
let studio = admit(&empty, &request, &options).unwrap();
|
||||
assert!(studio.estimated_total_bytes > 384 * 1024 * 1024);
|
||||
assert!(studio.estimated_total_bytes < options.budget.limits().max_job_bytes);
|
||||
request.width = 7680;
|
||||
request.height = 4320;
|
||||
assert!(admit(&empty, &request, &options).is_err());
|
||||
options.budget = job::CpuBudget::Workstation;
|
||||
request.raytrace = Some(options.clone());
|
||||
let workstation = admit(&empty, &request, &options).unwrap();
|
||||
assert!(workstation.estimated_total_bytes > studio.estimated_total_bytes);
|
||||
assert!(workstation.estimated_total_bytes < options.budget.limits().max_job_bytes);
|
||||
for budget in [job::CpuBudget::Studio, job::CpuBudget::Workstation] {
|
||||
let count = budget.limits().max_triangles as usize;
|
||||
let bytes = BvhBuilder::required_bytes(count, count, limits(budget)).unwrap();
|
||||
assert!(bytes < budget.limits().max_job_bytes);
|
||||
}
|
||||
assert!(BvhBuilder::required_bytes(2_000_000, 2_000_000, limits(job::CpuBudget::Compact)).is_err());
|
||||
}
|
||||
+300
@@ -0,0 +1,300 @@
|
||||
use super::*;
|
||||
use crate::job::{ReflectionBody, ReflectionMode, ReflectionOptions};
|
||||
use crate::lighting::{HdrSource, environment_input::EnvironmentInput};
|
||||
use solidcraft_geom::Mesh;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn environment(bright: bool, rotation: f64) -> EnvironmentInput {
|
||||
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec();
|
||||
for i in 0..8 {
|
||||
bytes.extend_from_slice(&if bright { if i == 0 { [128, 64, 16, 133] } else { [0; 4] } } else { [128, 64, 32, 129] });
|
||||
}
|
||||
EnvironmentInput::new(HdrSource::new(bytes).unwrap(), rotation, 1.0, 64).unwrap()
|
||||
}
|
||||
fn scene(normal: Vec3) -> ProductScene {
|
||||
let normal = normal / normal.len();
|
||||
let u = normal.cross(Vec3::X);
|
||||
let u = u / u.len() * 10.0;
|
||||
let v = normal.cross(u);
|
||||
let mesh = Arc::new(Mesh {
|
||||
positions: vec![-u - v, u - v, u + v, -u + v],
|
||||
normals: vec![normal; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
ProductScene {
|
||||
bounds: mesh.bounds(),
|
||||
meshes: vec![crate::ProductMesh {
|
||||
transmission: None,
|
||||
name: "Metal".into(),
|
||||
mesh,
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
}
|
||||
}
|
||||
fn request(mode: ReflectionMode) -> ImageRequest {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(RaytraceOptions {
|
||||
lights: Some(Vec::new()),
|
||||
reflections: Some(ReflectionOptions { bodies: vec![ReflectionBody { body: "Metal".into(), mode }], max_bounces: 1, samples: 64 }),
|
||||
..Default::default()
|
||||
}),
|
||||
camera,
|
||||
width: 9,
|
||||
height: 9,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn render(scene: ProductScene, request: ImageRequest, input: Option<EnvironmentInput>) -> Vec<u8> {
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new_with_environment(scene, request, CancelToken::default(), options, input).unwrap();
|
||||
for _ in 0..200_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
|
||||
return png;
|
||||
}
|
||||
}
|
||||
panic!("bounded environment reflection did not finish");
|
||||
}
|
||||
fn centre(bytes: &[u8]) -> [u8; 4] {
|
||||
::image::load_from_memory(bytes).unwrap().to_rgba8().get_pixel(4, 4).0
|
||||
}
|
||||
fn expected(radiance: [f64; 3]) -> [u8; 4] {
|
||||
let c = radiance.map(|v| encode8(v / (1.0 + v)));
|
||||
[c[0], c[1], c[2], 255]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ideal_metal_mirror_receives_environment_once_and_camera_background_stays_independent() {
|
||||
let req = request(ReflectionMode::Mirror);
|
||||
assert_eq!(centre(&render(scene(Vec3::Z), req.clone(), None)), [0, 0, 0, 255]);
|
||||
assert_eq!(centre(&render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)))), expected([1.0, 0.5, 0.25]));
|
||||
let mut empty = req;
|
||||
empty.raytrace.as_mut().unwrap().reflections = Some(ReflectionOptions::default());
|
||||
let image = ::image::load_from_memory(&render(
|
||||
ProductScene { meshes: Vec::new(), bounds: solidcraft_geom::Aabb3::EMPTY },
|
||||
empty,
|
||||
Some(environment(false, 0.0)),
|
||||
))
|
||||
.unwrap()
|
||||
.to_rgba8();
|
||||
assert!(image.pixels().all(|p| p.0 == [13, 27, 41, 255]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rough_metal_environment_matches_independent_sample_weights_without_extra_nee() {
|
||||
let mut factor = 0.0;
|
||||
// Normal-view white conductor at roughness1: null for z<=0, weight=2z/(1+z).
|
||||
// Only the deterministic variate key is shared; no BRDF/PDF implementation is reused.
|
||||
for sample in 0..64 {
|
||||
let u = reflection::variates(40, sample, 0, 64).unwrap();
|
||||
let z = 1.0 - 2.0 * u[0];
|
||||
if z > 0.0 {
|
||||
factor += 2.0 * z / (1.0 + z) / 64.0;
|
||||
}
|
||||
}
|
||||
let req = request(ReflectionMode::RoughSpecular);
|
||||
let png = render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)));
|
||||
assert_eq!(centre(&png), expected([factor, factor * 0.5, factor * 0.25]));
|
||||
assert_eq!(png, render(scene(Vec3::Z), req, Some(environment(false, 0.0))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combined_hdr_equal_anisotropy_point_and_led_match_independent_radiance_sum() {
|
||||
let mut req = anisotropic_request(ReflectionMode::RoughSpecular, true);
|
||||
let options = req.raytrace.as_mut().unwrap();
|
||||
options.punctual_lights = Some(vec![job::PunctualLightOptions {
|
||||
position_mm: [0.0, 0.0, 10.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 1.0,
|
||||
reference_distance_mm: 10.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
}]);
|
||||
job::led_strip::LedStripOptions {
|
||||
center_mm: [0.0, 0.0, 10.0],
|
||||
length_mm: 8.0,
|
||||
width_mm: 0.5,
|
||||
length_axis: [1.0, 0.0, 0.0],
|
||||
width_axis: [0.0, -1.0, 0.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 2.0,
|
||||
}
|
||||
.append_to(options, 1)
|
||||
.unwrap();
|
||||
let mut reflected = 0.0;
|
||||
for sample in 0..64 {
|
||||
let u = reflection::variates(40, sample, 0, 64).unwrap();
|
||||
let z = 1.0 - 2.0 * u[0];
|
||||
if z > 0.0 {
|
||||
reflected += 2.0 * z / (1.0 + z) / 64.0;
|
||||
}
|
||||
}
|
||||
// Normal-view white conductor, roughness1: f*cos=1/(4*pi).
|
||||
// Point at its reference distance contributes Li=1; LED contributes Le*A/r²=.08.
|
||||
// Selected reflection receives HDR through BSDF misses only, never a second NEE term.
|
||||
let total = reflected + 1.08 / (4.0 * std::f64::consts::PI);
|
||||
let combined = render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)));
|
||||
assert_eq!(centre(&combined), expected([total, total * 0.5, total * 0.25]));
|
||||
req.raytrace.as_mut().unwrap().anisotropic_faces = [None, None];
|
||||
assert_eq!(combined, render(scene(Vec3::Z), req, Some(environment(false, 0.0))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mirror_bright_cell_rotates_in_world_space_without_changing_background() {
|
||||
let reflected = Vec3::new(0.5, 0.5, 0.5_f64.sqrt());
|
||||
let normal = Vec3::Z + reflected;
|
||||
let req = request(ReflectionMode::Mirror);
|
||||
assert_eq!(centre(&render(scene(normal), req.clone(), Some(environment(true, 0.0)))), expected([16.0, 8.0, 2.0]));
|
||||
assert_eq!(centre(&render(scene(normal), req, Some(environment(true, std::f64::consts::FRAC_PI_2)))), [0, 0, 0, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_diffuse_rough_hdr_refuses_and_selector_capacities_remain_accounted() {
|
||||
let req = request(ReflectionMode::RoughSpecular);
|
||||
let options = req.raytrace.clone().unwrap();
|
||||
let mut invalid = scene(Vec3::Z);
|
||||
invalid.meshes[0].surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.5, 1.0, 1.5).unwrap());
|
||||
assert!(ImageTask::new_with_environment(invalid, req.clone(), CancelToken::default(), options.clone(), Some(environment(false, 0.0))).is_err());
|
||||
let mut invalid = scene(Vec3::Z);
|
||||
invalid.meshes[0].faces.push(crate::FaceAppearance { transmission: None, face: 0, color: [255; 3], opacity: 1.0, surface: None });
|
||||
assert!(options.validate_environment_reflections(&invalid).is_err());
|
||||
let selectors = options.reflections.as_ref().unwrap();
|
||||
assert_eq!(
|
||||
options.retained_bytes().unwrap(),
|
||||
(selectors.bodies.capacity() * std::mem::size_of::<ReflectionBody>() + selectors.bodies[0].body.capacity()) as u64
|
||||
);
|
||||
assert!(std::mem::size_of::<ImageTask>() <= 4096, "combined task state must fit the host's admitted slot");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secondary_environment_miss_obeys_shared_work_limit_and_cancel() {
|
||||
for cancel_now in [false, true] {
|
||||
let req = request(ReflectionMode::Mirror);
|
||||
let options = req.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new_with_environment(scene(Vec3::Z), req, cancel.clone(), options, Some(environment(false, 0.0))).unwrap();
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(task.pending.as_ref().is_some_and(|p| p.bounce > 0));
|
||||
if cancel_now {
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn anisotropic_request(mode: ReflectionMode, equal_axes: bool) -> ImageRequest {
|
||||
let mut request = request(mode);
|
||||
request.raytrace.as_mut().unwrap().anisotropic_faces = [
|
||||
Some(job::AnisotropicFaceOptions {
|
||||
body_index: 0,
|
||||
body_name: "Metal".into(),
|
||||
face: 0,
|
||||
tangent: [1.0, 0.0, 0.0],
|
||||
orientation: job::AnisotropicOrientation::Zero,
|
||||
roughness_x: if equal_axes { 1.0 } else { 0.2 },
|
||||
roughness_y: if equal_axes { 1.0 } else { 0.6 },
|
||||
}),
|
||||
None,
|
||||
];
|
||||
request
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hdr_equal_anisotropic_axes_match_isotropic_reflected_environment_bytes() {
|
||||
let plain = render(scene(Vec3::Z), request(ReflectionMode::RoughSpecular), Some(environment(false, 0.0)));
|
||||
let request = anisotropic_request(ReflectionMode::RoughSpecular, true);
|
||||
assert_eq!(plain, render(scene(Vec3::Z), request, Some(environment(false, 0.0))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hdr_anisotropic_direct_and_mirror_combinations_refuse_before_pixels() {
|
||||
for kind in 0..2 {
|
||||
let mut request = anisotropic_request(ReflectionMode::RoughSpecular, false);
|
||||
if kind == 0 {
|
||||
request.raytrace.as_mut().unwrap().reflections = None;
|
||||
} else {
|
||||
request.raytrace.as_mut().unwrap().reflections.as_mut().unwrap().bodies[0].mode = ReflectionMode::Mirror;
|
||||
}
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
assert!(ImageTask::new_with_environment(scene(Vec3::Z), request, CancelToken::default(), options, Some(environment(false, 0.0))).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hdr_anisotropic_secondary_hit_yields_before_another_debit_and_observes_cancel() {
|
||||
let mut source = scene(Vec3::new(0.0, -1.0, 1.0));
|
||||
// Original planar reflector z=y, with a broad separate horizontal receiver.
|
||||
let mesh = Arc::new(Mesh {
|
||||
positions: vec![
|
||||
Vec3::new(-100.0, -100.0, 10.0),
|
||||
Vec3::new(-100.0, 100.0, 10.0),
|
||||
Vec3::new(100.0, 100.0, 10.0),
|
||||
Vec3::new(100.0, -100.0, 10.0),
|
||||
],
|
||||
normals: vec![-Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
source.bounds = source.bounds.union(&mesh.bounds());
|
||||
source.meshes.push(crate::ProductMesh {
|
||||
transmission: None,
|
||||
name: "Receiver".into(),
|
||||
mesh,
|
||||
color: [240, 80, 20],
|
||||
opacity: 1.0,
|
||||
surface: None,
|
||||
faces: Vec::new(),
|
||||
});
|
||||
let mut request = anisotropic_request(ReflectionMode::RoughSpecular, false);
|
||||
request.camera.set_view(crate::StandardView::Front);
|
||||
request.width = 1;
|
||||
request.height = 1;
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new_with_environment(source, request, cancel.clone(), options, Some(environment(false, 0.0))).unwrap();
|
||||
while task.bvh.is_none() {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
}
|
||||
let mut secondary_hit = false;
|
||||
for _ in 0..200_000 {
|
||||
let tracing_secondary = task.pending.as_ref().is_some_and(|p| p.bounce > 0 && p.hit.is_none());
|
||||
let before = task.work.used();
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
assert!(task.work.used() - before <= 1, "secondary hit completion fell through into shading");
|
||||
if tracing_secondary && task.pending.as_ref().is_some_and(|p| p.hit.is_some()) {
|
||||
secondary_hit = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(secondary_hit);
|
||||
let before = task.work.used();
|
||||
assert!(matches!(task.step(4).unwrap(), TaskPoll::Pending(_)));
|
||||
assert!(task.work.used() - before <= 4);
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
|
||||
}
|
||||
+2573
File diff suppressed because it is too large.
Load diff
+3581
File diff suppressed because it is too large.
Load diff
+2031
File diff suppressed because it is too large.
Load diff
+281
@@ -0,0 +1,281 @@
|
||||
use super::*;
|
||||
use crate::{ProductMesh, StandardView, job::PunctualLightOptions};
|
||||
use solidcraft_geom::{Aabb3, Mesh};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn plane(name: &str, x: f64, z: f64, half: f64) -> ProductMesh {
|
||||
ProductMesh {
|
||||
transmission: None,
|
||||
name: name.into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions: vec![Vec3::new(x - half, -half, z), Vec3::new(x + half, -half, z), Vec3::new(x + half, half, z), Vec3::new(x - half, half, z)],
|
||||
normals: vec![Vec3::Z; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
}),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap()),
|
||||
faces: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn task(blocker: Option<(f64, f64)>, shadows: bool) -> ImageTask {
|
||||
let mut meshes = vec![plane("receiver", 0.0, 0.0, 30.0)];
|
||||
if let Some((x, z)) = blocker {
|
||||
meshes.push(plane("blocker", x, z, 2.0));
|
||||
}
|
||||
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
let scene = ProductScene { meshes, bounds };
|
||||
let mut camera = crate::Camera { distance: 80.0, fov: 0.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
let options = RaytraceOptions {
|
||||
lights: Some(Vec::new()),
|
||||
punctual_lights: Some(vec![PunctualLightOptions {
|
||||
position_mm: [20.0, 0.0, 10.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 1.0,
|
||||
reference_distance_mm: 10.0,
|
||||
minimum_distance_mm: 0.001,
|
||||
cone: None,
|
||||
}]),
|
||||
shadows,
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(options.clone()),
|
||||
camera,
|
||||
width: 1,
|
||||
height: 1,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
};
|
||||
ImageTask::new(scene, request, CancelToken::default(), options).unwrap()
|
||||
}
|
||||
|
||||
fn render(mut task: ImageTask) -> [u8; 4] {
|
||||
for _ in 0..100_000 {
|
||||
let before = task.work.used();
|
||||
let poll = task.step(1).unwrap();
|
||||
assert!(task.work.used() - before <= 1);
|
||||
if let TaskPoll::Complete(png) = poll {
|
||||
return ::image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0;
|
||||
}
|
||||
}
|
||||
panic!("bounded punctual PNG never completed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_consumer_matches_analytic_rgb_and_finite_source_occlusion() {
|
||||
let lit = render(task(None, true));
|
||||
// White rough conductor, normal view: f*cos=cos/[2*pi*(1+cos)].
|
||||
let cosine = 1.0 / 5.0_f64.sqrt();
|
||||
let l = 0.2 * cosine / (2.0 * std::f64::consts::PI * (1.0 + cosine));
|
||||
for (actual, factor) in lit.into_iter().take(3).zip([1.0, 0.5, 0.25]) {
|
||||
let expected = encode8(l * factor / (1.0 + l * factor));
|
||||
assert!(actual.abs_diff(expected) <= 1, "actual={actual}, expected={expected}");
|
||||
}
|
||||
assert_eq!(render(task(Some((10.0, 5.0)), true)), [0, 0, 0, 255]);
|
||||
assert_eq!(render(task(Some((40.0, 20.0)), true)), lit, "geometry behind source cast a shadow");
|
||||
assert_eq!(render(task(Some((10.0, 5.0)), false)), lit);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_spot_consumer_uses_emitted_world_axis_and_cone() {
|
||||
let point = render(task(None, true));
|
||||
for (axis, expected) in [([-20.0, 0.0, -10.0], point), ([20.0, 0.0, 10.0], [0, 0, 0, 255])] {
|
||||
let previous = task(None, true);
|
||||
let mut options = previous.visibility_owner.options().clone();
|
||||
options.punctual_lights.as_mut().unwrap()[0].cone =
|
||||
Some(job::SpotConeOptions { emitted_axis: axis, inner_half_angle_radians: 0.2, outer_half_angle_radians: 0.5 });
|
||||
let mut request = previous.request.clone();
|
||||
request.raytrace = Some(options.clone());
|
||||
let actual = ImageTask::new(previous.visibility_owner.source().clone(), request, CancelToken::default(), options).unwrap();
|
||||
assert_eq!(render(actual), expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancellation_between_final_shadow_and_sum_prevents_publication() {
|
||||
let mut task = task(None, true);
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.punctual_ready) {
|
||||
assert!(task.pixels.is_empty());
|
||||
let before = task.work.used();
|
||||
task.cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
assert_eq!(task.work.used(), before);
|
||||
assert!(task.pixels.is_empty());
|
||||
return;
|
||||
}
|
||||
}
|
||||
panic!("final punctual shadow continuation was not reached");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn punctual_work_exhaustion_is_shared_and_task_metadata_remains_bounded() {
|
||||
assert!(std::mem::size_of::<ImageTask>() <= 4096);
|
||||
let mut task = task(None, true);
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.punctual_shadow) {
|
||||
task.work.limit = task.work.used();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
assert!(task.pixels.is_empty());
|
||||
return;
|
||||
}
|
||||
}
|
||||
panic!("punctual shadow traversal was not reached");
|
||||
}
|
||||
|
||||
fn mixed(n: u32, shadows: bool) -> ImageTask {
|
||||
let previous = task(None, shadows);
|
||||
let mut options = previous.visibility_owner.options().clone();
|
||||
options.lights = Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }; 8]);
|
||||
options.punctual_lights = Some(vec![options.punctual_lights.as_ref().unwrap()[0]; 8]);
|
||||
options.area_lights = Some(vec![
|
||||
job::RectangleLightOptions {
|
||||
center_mm: [0.0, 0.0, 10.0],
|
||||
edge_u_mm: [8.0, 0.0, 0.0],
|
||||
edge_v_mm: [0.0, -0.5, 0.0],
|
||||
color: [1.0, 0.5, 0.25],
|
||||
intensity: 2.0
|
||||
};
|
||||
4
|
||||
]);
|
||||
options.area_samples = Some(n);
|
||||
let mut request = previous.request.clone();
|
||||
request.raytrace = Some(options.clone());
|
||||
ImageTask::new(previous.visibility_owner.source().clone(), request, CancelToken::default(), options).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn max_union_observes_272_direct_attempts_in_one_budget_and_partition_independent_png() {
|
||||
for n in [1, 4, 16, 64] {
|
||||
let mut task = mixed(n, false);
|
||||
let mut point_attempts = 0;
|
||||
let mut area_attempts = 0;
|
||||
let mut actual = None;
|
||||
for _ in 0..100_000 {
|
||||
if let Some(p) = task.pending.as_ref().filter(|p| p.hit.is_some() && p.light == 8) {
|
||||
if p.punctual_index < 8 && !p.punctual_ready && !p.punctual_shadow {
|
||||
point_attempts += 1;
|
||||
}
|
||||
if p.punctual_index == 8 && p.area_light < 4 && p.area_index < n && !p.area_ready && !p.area_shadow {
|
||||
area_attempts += 1;
|
||||
}
|
||||
}
|
||||
let before = task.work.used();
|
||||
let poll = task.step(1).unwrap();
|
||||
assert!(task.work.used() - before <= 1);
|
||||
if let TaskPoll::Complete(png) = poll {
|
||||
actual = Some(png);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let actual = actual.unwrap();
|
||||
assert_eq!(point_attempts, 8);
|
||||
assert_eq!(area_attempts, 4 * n);
|
||||
assert_eq!(8 + point_attempts + area_attempts, 16 + 4 * n);
|
||||
if n == 64 {
|
||||
assert_eq!(8 + point_attempts + area_attempts, 272);
|
||||
}
|
||||
let mut other = mixed(n, false);
|
||||
let mut complete = None;
|
||||
for _ in 0..100_000 {
|
||||
if let TaskPoll::Complete(png) = other.step(128).unwrap() {
|
||||
complete = Some(png);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(actual, complete.unwrap());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_area_final_shadow_cancellation_and_shared_exhaustion_prevent_publication() {
|
||||
for cancel in [false, true] {
|
||||
let mut task = mixed(64, true);
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.area_light == 3 && p.area_index == 63 && p.area_ready) {
|
||||
reached = true;
|
||||
assert!(task.pixels.is_empty());
|
||||
let before = task.work.used();
|
||||
if cancel {
|
||||
task.cancel.cancel();
|
||||
} else {
|
||||
task.work.limit = before;
|
||||
}
|
||||
assert_eq!(task.step(1).err().unwrap().code, if cancel { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
|
||||
assert_eq!(task.work.used(), before);
|
||||
assert!(task.pixels.is_empty());
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(reached, "last rectangle sample continuation was not reached");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_normal_incidence_radiance_is_summed_before_single_display_transform() {
|
||||
let mut task = mixed(1, false);
|
||||
let (fixture_scene, mut options) = task.visibility_owner.into_capture();
|
||||
for point in options.punctual_lights.as_mut().unwrap() {
|
||||
point.position_mm = [0.0, 0.0, 10.0];
|
||||
point.color = [1.0; 3];
|
||||
point.reference_distance_mm = 10.0;
|
||||
}
|
||||
for area in options.area_lights.as_mut().unwrap() {
|
||||
area.color = [1.0; 3];
|
||||
}
|
||||
task.request.raytrace = Some(options.clone());
|
||||
task.visibility_owner = dielectric::DirectVisibilityOwner::new(fixture_scene, options);
|
||||
// White rough conductor at normal incidence: f*cos=1/(4*pi).
|
||||
// Eight unit directionals + eight unit point sources + four Le*A/r²=.08 rectangles.
|
||||
let linear = (8.0 + 8.0 + 4.0 * 0.08) / (4.0 * std::f64::consts::PI);
|
||||
let expected = encode8(linear / (1.0 + linear));
|
||||
assert_eq!(render(task), [expected, expected, expected, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scene_dependent_punctual_singularities_complete_and_keep_diagnostic_counts() {
|
||||
for (height, reference, near_source) in [(0.0, 10.0, true), (0.0009, 10.0, true), (0.001, 1e6, false)] {
|
||||
let previous = task(None, true);
|
||||
let mut options = previous.visibility_owner.options().clone();
|
||||
let light = &mut options.punctual_lights.as_mut().unwrap()[0];
|
||||
light.position_mm = [0.0, 0.0, height];
|
||||
light.reference_distance_mm = reference;
|
||||
light.intensity = 64.0;
|
||||
let mut request = previous.request.clone();
|
||||
request.raytrace = Some(options.clone());
|
||||
let mut work = ImageTask::new(previous.visibility_owner.source().clone(), request, CancelToken::default(), options).unwrap();
|
||||
let mut completed = false;
|
||||
for _ in 0..100_000 {
|
||||
if let TaskPoll::Complete(png) = work.step(1).unwrap() {
|
||||
assert_eq!(::image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0, [0, 0, 0, 255]);
|
||||
let report = work.punctual_diagnostics().unwrap();
|
||||
if near_source {
|
||||
assert!(report.near_source > 0);
|
||||
} else {
|
||||
assert!(report.radiance_limit > 0);
|
||||
}
|
||||
completed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(completed, "singular sample must not fail or stall the image");
|
||||
}
|
||||
}
|
||||
+329
@@ -0,0 +1,329 @@
|
||||
use super::*;
|
||||
use crate::ProductMesh;
|
||||
use crate::job::{ReflectionBody, ReflectionMode, ReflectionOptions};
|
||||
use solidcraft_geom::Mesh;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn visible_second_body_fixture(spatial: u8, samples: u8) -> ImageTask {
|
||||
let mut source = scene();
|
||||
source.meshes[0].surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap());
|
||||
source.meshes[0].mesh = Arc::new(Mesh {
|
||||
positions: vec![
|
||||
Vec3::new(-100.0, -100.0, -100.0),
|
||||
Vec3::new(100.0, -100.0, -100.0),
|
||||
Vec3::new(100.0, 100.0, 100.0),
|
||||
Vec3::new(-100.0, 100.0, 100.0),
|
||||
],
|
||||
normals: vec![Vec3::new(0.0, -1.0, 1.0); 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
});
|
||||
// Camera and reflector lie INSIDE this separate inward-facing box. A
|
||||
// primary hits the nearer reflector first; every valid secondary leaving
|
||||
// it eventually intersects body1. No emitter or test-only transport hook.
|
||||
let mut target = Mesh::default();
|
||||
for normal in [Vec3::X, -Vec3::X, Vec3::Y, -Vec3::Y, Vec3::Z, -Vec3::Z] {
|
||||
let tangent = if normal.x == 0.0 { Vec3::X } else { Vec3::Y };
|
||||
let bitangent = normal.cross(tangent);
|
||||
let center = -normal * 10_000.0;
|
||||
let first = target.positions.len() as u32;
|
||||
for (x, y) in [(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)] {
|
||||
target.positions.push(center + tangent * (x * 10_000.0) + bitangent * (y * 10_000.0));
|
||||
target.normals.push(normal);
|
||||
}
|
||||
target.triangles.extend([[first, first + 1, first + 2], [first, first + 2, first + 3]]);
|
||||
target.tri_face.extend([0, 0]);
|
||||
}
|
||||
source.meshes[1].mesh = Arc::new(target);
|
||||
source.bounds = source.meshes.iter().fold(solidcraft_geom::Aabb3::EMPTY, |bounds, body| bounds.union(&body.mesh.bounds()));
|
||||
let mut req = request(Some(reflection_options(ReflectionMode::RoughSpecular)));
|
||||
req.width = 1;
|
||||
req.height = 1;
|
||||
// Perspective near clipping starts inside the box. Orthographic near
|
||||
// clipping includes geometry behind the eye and starts outside this box.
|
||||
// tan(0.25) < 1/3: the whole film hits |x|, |y|=|z| < 25, within
|
||||
// the reflector extent100 and before any target box wall10000.
|
||||
req.camera.fov = 0.5;
|
||||
let options = req.raytrace.as_mut().unwrap();
|
||||
options.primary_samples = spatial;
|
||||
options.reflections.as_mut().unwrap().samples = samples;
|
||||
options.reflections.as_mut().unwrap().max_bounces = 1;
|
||||
let options = options.clone();
|
||||
ImageTask::new(source, req, CancelToken::default(), options).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn visible_transport_hits_a_real_second_body_and_completes_all_spatial_reflection_attempts() {
|
||||
for spatial in [1_u8, 4, 16] {
|
||||
for samples in [1_u8, 4, 16, 64] {
|
||||
let mut task = visible_second_body_fixture(spatial, samples);
|
||||
let mut primary_attempts = std::collections::BTreeSet::new();
|
||||
let mut secondary_spawns = std::collections::BTreeSet::new();
|
||||
let mut second_body_hits = std::collections::BTreeSet::new();
|
||||
let expected = usize::from(spatial) * usize::from(samples);
|
||||
let mut completed = None;
|
||||
for _ in 0..200_000 {
|
||||
let absent = task.pending.is_none();
|
||||
let work = task.work.used();
|
||||
let poll = task.step(1).unwrap();
|
||||
assert!(task.work.used() - work <= 4);
|
||||
if let Some(pending) = task.pending.as_ref() {
|
||||
let key = (task.spatial, task.sample);
|
||||
if absent && pending.bounce == 0 {
|
||||
assert!(primary_attempts.insert(key), "a fixed S,R attempt was retried");
|
||||
}
|
||||
if pending.bounce == 0
|
||||
&& let Some(hit) = pending.hit
|
||||
{
|
||||
assert_eq!(task.looks[hit.primitive_index].body_index, 0, "every primary must reach the selected reflector first");
|
||||
}
|
||||
if pending.bounce == 1 {
|
||||
secondary_spawns.insert(key);
|
||||
if let Some(hit) = pending.hit {
|
||||
assert_eq!(task.looks[hit.primitive_index].body_index, 1, "spawn alone is insufficient: resolve body identity");
|
||||
second_body_hits.insert(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
if !task.pixels.is_empty() {
|
||||
assert_eq!(primary_attempts.len(), expected, "pixel published before every S*R attempt, including nulls");
|
||||
}
|
||||
if let TaskPoll::Complete(png) = poll {
|
||||
completed = Some(png);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(task.pixel, 1);
|
||||
assert!(task.done);
|
||||
assert_eq!(primary_attempts.len(), expected);
|
||||
assert_eq!(second_body_hits, secondary_spawns, "every accepted secondary must finish tracing its actual second body");
|
||||
if spatial == 1 {
|
||||
assert!(!second_body_hits.is_empty(), "the centre fixture must actually hit another body");
|
||||
if samples == 64 {
|
||||
assert!(secondary_spawns.len() < expected, "unit roughness must also exercise null attempts without retry/renormalization");
|
||||
}
|
||||
}
|
||||
let decoded = ::image::load_from_memory(&completed.expect("bounded full S*R traversal did not complete")).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.dimensions(), (1, 1));
|
||||
assert_eq!(decoded.get_pixel(0, 0).0[3], 255);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn visible_rough_transport_keeps_cancellation_and_work_caps_at_sample_count_extremes() {
|
||||
for samples in [1, 4, 16, 64] {
|
||||
for cancel_now in [false, true] {
|
||||
let mut reflection = reflection_options(ReflectionMode::RoughSpecular);
|
||||
reflection.samples = samples;
|
||||
let request = request(Some(reflection));
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
let before = task.work.used();
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
assert!(task.work.used() - before <= 4, "public quantum expanded");
|
||||
if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
|
||||
reached = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(reached, "actual VNDF rough continuation was not exercised");
|
||||
if cancel_now {
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn scene() -> ProductScene {
|
||||
fn quad(name: &str, positions: Vec<Vec3>, normal: Vec3, color: [u8; 3], surface: Option<OpaqueSurface>) -> ProductMesh {
|
||||
ProductMesh {
|
||||
transmission: None,
|
||||
name: name.into(),
|
||||
mesh: Arc::new(Mesh {
|
||||
positions,
|
||||
normals: vec![normal; 4],
|
||||
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
||||
tri_face: vec![0, 0],
|
||||
..Default::default()
|
||||
}),
|
||||
color,
|
||||
opacity: 1.0,
|
||||
surface,
|
||||
faces: Vec::new(),
|
||||
}
|
||||
}
|
||||
let mirror = quad(
|
||||
"Mirror",
|
||||
vec![Vec3::new(-20.0, -20.0, -20.0), Vec3::new(20.0, -20.0, -20.0), Vec3::new(20.0, 20.0, 20.0), Vec3::new(-20.0, 20.0, 20.0)],
|
||||
Vec3::new(0.0, -1.0, 1.0),
|
||||
[255; 3],
|
||||
Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 0.2, 1.5).unwrap()),
|
||||
);
|
||||
let object = quad(
|
||||
"Orange target",
|
||||
vec![Vec3::new(-8.0, -8.0, 10.0), Vec3::new(-8.0, 8.0, 10.0), Vec3::new(8.0, 8.0, 10.0), Vec3::new(8.0, -8.0, 10.0)],
|
||||
-Vec3::Z,
|
||||
[240, 80, 20],
|
||||
None,
|
||||
);
|
||||
let meshes = vec![mirror, object];
|
||||
let bounds = meshes.iter().fold(solidcraft_geom::Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
|
||||
ProductScene { meshes, bounds }
|
||||
}
|
||||
fn request(reflections: Option<ReflectionOptions>) -> ImageRequest {
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Front);
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
integrator: job::Integrator::Raytrace,
|
||||
raytrace: Some(RaytraceOptions {
|
||||
reflections,
|
||||
shadows: false,
|
||||
lights: Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, -1.0], color: [1.0; 3], intensity: 2.0 }]),
|
||||
..Default::default()
|
||||
}),
|
||||
camera,
|
||||
width: 9,
|
||||
height: 9,
|
||||
background: [13, 27, 41],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
fn reflection_options(mode: ReflectionMode) -> ReflectionOptions {
|
||||
ReflectionOptions { bodies: vec![ReflectionBody { body: "Mirror".into(), mode }], max_bounces: 2, samples: 16 }
|
||||
}
|
||||
fn render(request: ImageRequest) -> Vec<u8> {
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let mut task = ImageTask::new(scene(), request, CancelToken::default(), options).unwrap();
|
||||
for _ in 0..200_000 {
|
||||
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
|
||||
return png;
|
||||
}
|
||||
}
|
||||
panic!("bounded reflection fixture did not complete");
|
||||
}
|
||||
#[test]
|
||||
fn mirror_png_contains_other_body_and_rough_transport_is_reproducible() {
|
||||
let baseline = ::image::load_from_memory(&render(request(None))).unwrap().to_rgba8();
|
||||
let mirrored = ::image::load_from_memory(&render(request(Some(reflection_options(ReflectionMode::Mirror))))).unwrap().to_rgba8();
|
||||
let b = baseline.get_pixel(4, 4).0;
|
||||
let p = mirrored.get_pixel(4, 4).0;
|
||||
assert!(p[0] > p[1] && p[1] > p[2], "actual orange object must be reflected: {p:?}");
|
||||
assert_ne!(p, b, "reflection must change the scene image, not only metadata");
|
||||
let rough = request(Some(reflection_options(ReflectionMode::RoughSpecular)));
|
||||
assert_eq!(render(rough.clone()), render(rough));
|
||||
}
|
||||
#[test]
|
||||
fn explicit_empty_overrides_preserve_baseline_bytes_and_validate_names_atomically() {
|
||||
assert_eq!(render(request(None)), render(request(Some(ReflectionOptions::default()))));
|
||||
let mut options = reflection_options(ReflectionMode::Mirror);
|
||||
options.bodies[0].body = "missing".into();
|
||||
let request = request(Some(options));
|
||||
assert_eq!(admit(&scene(), &request, request.raytrace.as_ref().unwrap()).err().unwrap().code, ErrorCode::InvalidRequest);
|
||||
let hostile = ReflectionOptions { bodies: Vec::with_capacity(65), ..ReflectionOptions::default() };
|
||||
assert!(hostile.validate().is_err());
|
||||
}
|
||||
#[test]
|
||||
fn reflection_cancel_and_work_exhaustion_never_publish_partial_frame() {
|
||||
for mode in [ReflectionMode::Mirror, ReflectionMode::RoughSpecular] {
|
||||
for cancel_now in [false, true] {
|
||||
let request = request(Some(reflection_options(mode)));
|
||||
let options = request.raytrace.clone().unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
|
||||
let mut reached = false;
|
||||
for _ in 0..100_000 {
|
||||
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
|
||||
if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
|
||||
reached = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(reached);
|
||||
if cancel_now {
|
||||
cancel.cancel();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
|
||||
} else {
|
||||
task.work.limit = task.work.used();
|
||||
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn prepared_hit_preserves_original_winding_identity_and_never_certifies_glass() {
|
||||
let source = scene();
|
||||
let primitive = &source.meshes[0];
|
||||
let indices = primitive.mesh.triangles[0];
|
||||
let vertices = indices.map(|i| primitive.mesh.positions[i as usize]);
|
||||
let triangle = Triangle::new(vertices).unwrap();
|
||||
let ray = Ray::new(Vec3::new(2.0, -50.0, 0.0), Vec3::Y, 0.0, 100.0).unwrap();
|
||||
let geometry = triangle.intersect(&ray).unwrap();
|
||||
let cancel = CancelToken::default();
|
||||
let mut builder = BvhBuilder::new(vec![triangle], limits(job::CpuBudget::Compact), &cancel).unwrap();
|
||||
while !builder.step(1, &cancel).unwrap().complete {}
|
||||
let bvh = builder.finish().unwrap();
|
||||
let primitives =
|
||||
[PreparedPrimitive { body_index: 0, face: Some(0), vertices, normals: [geometry.geometric_normal; 3], surface: primitive.surface.unwrap() }];
|
||||
let prepared = PreparedScene { bvh: &bvh, primitives: &primitives, source: &source };
|
||||
let shared = prepared.resolve_hit(ray, super::super::Hit { primitive_index: 0, geometry }).unwrap();
|
||||
assert_eq!(shared.body_name, "Mirror");
|
||||
assert_eq!(shared.geometric_normal, geometry.geometric_normal);
|
||||
assert_eq!(shared.front_face, geometry.front_face);
|
||||
assert_eq!(prepared.boundary_status(0), super::super::prepared::BoundaryStatus::Unknown);
|
||||
}
|
||||
#[test]
|
||||
fn shared_spawn_excludes_signed_zero_self_hit_without_skipping_thin_blockers() {
|
||||
for x in [0.0, 1e12 - 100.0] {
|
||||
let vertices = [Vec3::new(x, 0.0, 0.0), Vec3::new(x + 20.0, 0.0, 0.0), Vec3::new(x, 20.0, 0.0)];
|
||||
let triangle = Triangle::new(vertices).unwrap();
|
||||
let ray = Ray::new(Vec3::new(x + 5.0, 5.0, 10.0), -Vec3::Z, 0.0, 20.0).unwrap();
|
||||
let geometry = triangle.intersect(&ray).unwrap();
|
||||
let primitive = PreparedPrimitive {
|
||||
body_index: 0,
|
||||
face: Some(0),
|
||||
vertices,
|
||||
normals: [Vec3::Z; 3],
|
||||
surface: OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.0, 0.7, 1.5).unwrap(),
|
||||
};
|
||||
let source = ProductScene {
|
||||
meshes: vec![ProductMesh {
|
||||
transmission: None,
|
||||
name: "Plane".into(),
|
||||
mesh: Arc::new(Mesh::default()),
|
||||
color: [255; 3],
|
||||
opacity: 1.0,
|
||||
surface: None,
|
||||
faces: Vec::new(),
|
||||
}],
|
||||
bounds: Default::default(),
|
||||
};
|
||||
let cancel = CancelToken::default();
|
||||
let mut builder = BvhBuilder::new(vec![triangle], limits(job::CpuBudget::Compact), &cancel).unwrap();
|
||||
while !builder.step(1, &cancel).unwrap().complete {}
|
||||
let bvh = builder.finish().unwrap();
|
||||
let primitives = [primitive];
|
||||
let prepared = PreparedScene { bvh: &bvh, primitives: &primitives, source: &source };
|
||||
let hit = prepared.resolve_hit(ray, super::super::Hit { primitive_index: 0, geometry }).unwrap();
|
||||
let secondary = hit.spawn(Vec3::Z).unwrap();
|
||||
assert!(secondary.interval()[0] > 0.0);
|
||||
assert!(triangle.intersect(&secondary).is_none());
|
||||
assert!(Triangle::new(vertices.map(|v| v + Vec3::Z * 0.005)).unwrap().intersect(&secondary).is_some());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,846 @@
|
||||
--- a/crates/engine/src/cmd/render.rs
|
||||
+++ b/crates/engine/src/cmd/render.rs
|
||||
@@ -124,7 +124,7 @@
|
||||
CommandSpec::new("render.settings.capture_hdr", "Save Render Settings with HDR", resources::capture_settings).icon("settings").doc_only()
|
||||
.params("name, set: typed CPU/GPU setup patch with hdr/environment unset; path: scoped HDR; expected_sha256?: digest returned by render.hdr.inspect (changed sources refuse); rotation_rad?:0, intensity?:1; samples?:1/4/16/64 for CPU only (default16); assume_linear_srgb?:false for GPU only. Captures immutable bytes and saves resource plus setup atomically in one undo, without a host; returns name/setup/resource metadata, never source bytes"),
|
||||
CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).icon("inspect").noundo().doc_only()
|
||||
- .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace, transient studio_weights, raster_lights and progressive_feedback may accompany it. raster_lights?: transient null (legacy studio) or 0..8 directional sources {direction:[x,y,z],color:[linear r,g,b],intensity:0..64}; empty array is dark direct lighting. Requires builtin Raster without studio_weights, raytrace, HDR, transmission or other method controls; existing RenderSetup.exposure_ev is captured for Raster within -32..32. Directions are finite/nonzero and bounded by 1e9; RGB is 0..1. Not saved; no shadows or physical glass. raster_punctual_lights?: transient null or 0..8 shared point/spot sources {position_mm:[x,y,z],color:[linear r,g,b],intensity:0..64,reference_distance_mm:0.001..1000000,minimum_distance_mm:0.001..reference_distance_mm,cone?:{emitted_axis:[x,y,z],inner_half_angle_radians,outer_half_angle_radians}}. Spot angles require 0<=inner<outer<=pi/2 and a finite nonzero emitted axis. raster_area_lights?: transient null or 0..4 rectangles {center_mm:[x,y,z],edge_u_mm:[x,y,z],edge_v_mm:[x,y,z],color:[linear r,g,b],intensity:0..64}; full perpendicular side lengths 0.000001..1000000mm, corners within +/-1000000000mm, U cross V emits. Local sources require a runtime request with settings.job:null or an untyped setup; saved typed jobs refuse them. All three absent/null collections preserve the legacy studio; any explicit local array, even empty, disables implicit sources, and absent raster_lights then means no directionals. Local images use unshadowed point/spot falloff and a one-point projected-area rectangle approximation; no finite footprint, soft shadows, environment, area_samples, softness or seed. Local light evaluations count within the existing projected-work limit; caps are 8directional+8shared point/spot+4rectangle, with the existing Raster memory envelope and one captured exposure. Positions and spot-axis components are finite and bounded by1e9; RGB0..1. No saved/UI local-light authoring yet. progressive_feedback?: false; transient protected display updates during CPU progressive rendering only; true refuses raster, GPU and fixed CPU requests. Omission preserves legacy admission/submission. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy requires fixed sampling; certified smooth thin-sheet/box dielectrics support fixed or progressive sampling under the same certificates and bounded optical transport. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption. nested_media?: false is the existing JobOptions opt-in; fixed or progressive CPU images admit only strictly nested certified closed_box boundaries with an exterior camera, while touching/partial overlaps, sheets within volumes and clearcoat combinations refuse. Other nondefault JobOptions remain unsupported on CPU; progressive/Interactive optics retain primary_samples:1 and selected reflections.samples:1 limits and never drop unsupported intent. GPU progressive uses the same nested_media field with its own certified-media contract; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16
Line truncated
|
||||
+ .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace, transient studio_weights, raster_lights and progressive_feedback may accompany it. raster_lights?: transient null (legacy studio) or 0..8 directional sources {direction:[x,y,z],color:[linear r,g,b],intensity:0..64}; empty array is dark direct lighting. Requires builtin Raster without studio_weights, raytrace, HDR, transmission or other method controls; existing RenderSetup.exposure_ev is captured for Raster within -32..32. Directions are finite/nonzero and bounded by 1e9; RGB is 0..1. Not saved; no shadows or physical glass. raster_punctual_lights?: transient null or 0..8 shared point/spot sources {position_mm:[x,y,z],color:[linear r,g,b],intensity:0..64,reference_distance_mm:0.001..1000000,minimum_distance_mm:0.001..reference_distance_mm,cone?:{emitted_axis:[x,y,z],inner_half_angle_radians,outer_half_angle_radians}}. Spot angles require 0<=inner<outer<=pi/2 and a finite nonzero emitted axis. raster_area_lights?: transient null or 0..4 rectangles {center_mm:[x,y,z],edge_u_mm:[x,y,z],edge_v_mm:[x,y,z],color:[linear r,g,b],intensity:0..64}; full perpendicular side lengths 0.000001..1000000mm, corners within +/-1000000000mm, U cross V emits. Local sources require a runtime request with settings.job:null or an untyped setup; saved typed jobs refuse them. All three absent/null collections preserve the legacy studio; any explicit local array, even empty, disables implicit sources, and absent raster_lights then means no directionals. Local images use unshadowed point/spot falloff and a one-point projected-area rectangle approximation; no finite footprint, soft shadows, environment, area_samples, softness or seed. Local light evaluations count within the existing projected-work limit; caps are 8directional+8shared point/spot+4rectangle, with the existing Raster memory envelope and one captured exposure. Positions and spot-axis components are finite and bounded by1e9; RGB0..1. No saved/UI local-light authoring yet. progressive_feedback?: false; transient protected display updates during CPU progressive rendering only; true refuses raster, GPU and fixed CPU requests. Omission preserves legacy admission/submission. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy requires fixed sampling; certified smooth thin-sheet/box dielectrics support fixed or progressive sampling under the same certificates and bounded optical transport. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption. nested_media?: false is the existing JobOptions opt-in; fixed or progressive CPU images admit only strictly nested certified closed_box boundaries with an exterior camera, while touching/partial overlaps, sheets within volumes and clearcoat combinations refuse. Other nondefault JobOptions remain unsupported on CPU; progressive/Interactive optics retain primary_samples:1 and selected reflections.samples:1 limits and never drop unsupported intent. GPU progressive uses the same nested_media field with its own certified-media contract; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16
Line truncated
|
||||
CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image")
|
||||
.params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"),
|
||||
CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only()
|
||||
--- a/crates/engine/src/cmd/render/jobs.rs
|
||||
+++ b/crates/engine/src/cmd/render/jobs.rs
|
||||
@@ -18,6 +18,8 @@
|
||||
#[serde(default, deserialize_with = "solidcraft_render::job::deserialize_raster_area_lights")]
|
||||
raster_area_lights: Option<Vec<solidcraft_render::job::RectangleLightOptions>>,
|
||||
progressive_feedback: bool,
|
||||
+ #[serde(default, deserialize_with = "cpu_progressive_every_pass_input")]
|
||||
+ cpu_progressive_every_pass: Option<bool>,
|
||||
nested_media: bool,
|
||||
studio_weights: Option<[f64; 3]>,
|
||||
progressive: bool,
|
||||
@@ -34,6 +36,11 @@
|
||||
settings: Option<RenderSetup>,
|
||||
transparent_background: bool,
|
||||
replace: bool,
|
||||
+}
|
||||
+
|
||||
+// Omission is allowed; an explicitly supplied null/string/number is not a bool.
|
||||
+fn cpu_progressive_every_pass_input<'de, D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result<Option<bool>, D::Error> {
|
||||
+ bool::deserialize(deserializer).map(Some)
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
@@ -155,6 +162,7 @@
|
||||
}
|
||||
}
|
||||
let final_request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: input.cpu_progressive_every_pass.unwrap_or(true),
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -203,6 +211,69 @@
|
||||
|
||||
#[cfg(test)]
|
||||
mod union_lowering_tests {
|
||||
+ #[test]
|
||||
+ fn cpu_cadence_wire_rejects_null_nonbool_and_nonprogressive_controls_before_capture() {
|
||||
+ let mut wire = json!({"cpu_progressive_every_pass":false});
|
||||
+ assert_eq!(Start::deserialize(&wire).unwrap().cpu_progressive_every_pass, Some(false));
|
||||
+ assert_eq!(Start::deserialize(&json!({})).unwrap().cpu_progressive_every_pass, None);
|
||||
+ for invalid in [Value::Null, json!(0), json!("false"), json!([]), json!({})] {
|
||||
+ wire["cpu_progressive_every_pass"] = invalid;
|
||||
+ assert!(Start::deserialize(&wire).is_err());
|
||||
+ }
|
||||
+ for params in [
|
||||
+ json!({"cpu_progressive_every_pass":false}),
|
||||
+ json!({"cpu_progressive_every_pass":true,"integrator":"raytrace","raytrace":{}}),
|
||||
+ json!({"cpu_progressive_every_pass":false,"progressive":true}),
|
||||
+ ] {
|
||||
+ let error = prepare(&Session::default(), ¶ms, "render.preflight").err().unwrap().to_string();
|
||||
+ assert!(error.contains("cpu_progressive_every_pass requires CPU progressive raytracing"), "{error}");
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
|
||||
+ #[test]
|
||||
+ fn saved_cpu_cadence_command_replay_normalizes_false_and_keeps_it_through_the_native_worker() {
|
||||
+ let mut session = Session::default();
|
||||
+ let host = solidcraft_render::job::CpuHost::for_platform().unwrap();
|
||||
+ session.set_render_job_host(Some(host)).unwrap();
|
||||
+ let document = session.doc.to_json();
|
||||
+ let original = json!({"settings":{"width":4,"height":3,"background":[17,31,59],
|
||||
+ "job":{"method":"cpu_raytrace","options":{"lights":[],"shadows":false,"progressive":{"samples_per_pixel":5,"seed":97}}}},
|
||||
+ "cpu_progressive_every_pass":false});
|
||||
+ let replay: Value = serde_json::from_str(&serde_json::to_string(&original).unwrap()).unwrap();
|
||||
+ assert_eq!(replay, original);
|
||||
+ let normalized = normalize_saved_job(&session, &replay, "render.start").unwrap().unwrap();
|
||||
+ assert_eq!(normalized.params["cpu_progressive_every_pass"], false);
|
||||
+ assert!(normalized.params["settings"]["job"].is_null());
|
||||
+ let prepared = prepare(&session, &replay, "render.preflight").unwrap();
|
||||
+ assert!(!prepared.request.cpu_progressive_every_pass);
|
||||
+ assert_eq!(prepared.reply["request"]["cpu_progressive_every_pass"], false);
|
||||
+ let decoded: ImageRequest = serde_json::from_value(prepared.reply["request"].clone()).unwrap();
|
||||
+ assert!(!decoded.cpu_progressive_every_pass);
|
||||
+ assert_eq!(decoded.raytrace.as_ref().unwrap().progressive.unwrap().seed, 97);
|
||||
+ let mut reference: Option<Vec<u8>> = None;
|
||||
+ for every_pass in [false, true] {
|
||||
+ let mut params = replay.clone();
|
||||
+ params["cpu_progressive_every_pass"] = json!(every_pass);
|
||||
+ let started = start(&mut session, ¶ms).unwrap();
|
||||
+ let id: JobId = serde_json::from_value(started["job"].clone()).unwrap();
|
||||
+ let handle = session.render_job_handle(id).unwrap();
|
||||
+ let status = handle.wait_timeout(std::time::Duration::from_secs(20)).unwrap();
|
||||
+ assert_eq!(status.progress.phase, solidcraft_render::job::Phase::Completed);
|
||||
+ assert_eq!(status.request.cpu_progressive_every_pass, every_pass);
|
||||
+ let status_wire = serde_json::to_value(&status).unwrap();
|
||||
+ assert_eq!(status_wire["request"].get("cpu_progressive_every_pass"), (!every_pass).then_some(&Value::Bool(false)));
|
||||
+ let frame = handle.frame().unwrap().unwrap();
|
||||
+ if let Some(expected) = &reference {
|
||||
+ assert_eq!(frame.png(), expected.as_slice());
|
||||
+ } else {
|
||||
+ reference = Some(frame.png().to_vec());
|
||||
+ }
|
||||
+ }
|
||||
+ assert_eq!(session.doc.to_json(), document, "runtime cadence cannot become saved document intent");
|
||||
+ }
|
||||
+
|
||||
+
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn raster_local_command_fixture() -> (Session, Value) {
|
||||
@@ -755,6 +826,7 @@
|
||||
| "replace"
|
||||
| "studio_weights"
|
||||
| "progressive_feedback"
|
||||
+ | "cpu_progressive_every_pass"
|
||||
| "raster_lights"
|
||||
| "raster_punctual_lights"
|
||||
| "raster_area_lights"
|
||||
@@ -820,6 +892,9 @@
|
||||
if let Some(feedback) = object.get("progressive_feedback") {
|
||||
lowered["progressive_feedback"] = feedback.clone();
|
||||
}
|
||||
+ if let Some(every_pass) = object.get("cpu_progressive_every_pass") {
|
||||
+ lowered["cpu_progressive_every_pass"] = every_pass.clone();
|
||||
+ }
|
||||
Ok(Some(Normalized { params: lowered, hdr, surfaces, optics }))
|
||||
}
|
||||
|
||||
@@ -828,6 +903,9 @@
|
||||
let saved_hdr = normalized.as_ref().and_then(|normalized| normalized.hdr.as_ref());
|
||||
let params = normalized.as_ref().map_or(params, |normalized| &normalized.params);
|
||||
if params.get("progressive").and_then(Value::as_bool) == Some(true) {
|
||||
+ if params.get("cpu_progressive_every_pass").is_some() {
|
||||
+ return Err(bad(command, "cpu_progressive_every_pass requires CPU progressive raytracing"));
|
||||
+ }
|
||||
let hdr = match saved_hdr {
|
||||
Some(SavedHdr::Gpu(hdr)) => Some(*hdr),
|
||||
Some(SavedHdr::Cpu(_)) => return Err(bad(command, "saved CPU HDR cannot enter a GPU request")),
|
||||
@@ -856,6 +934,11 @@
|
||||
));
|
||||
}
|
||||
let mut input = Start::deserialize(params).map_err(|e| bad(command, e.to_string()))?;
|
||||
+ if input.cpu_progressive_every_pass.is_some()
|
||||
+ && (input.integrator != Integrator::Raytrace || input.progressive || input.raytrace.as_ref().and_then(|options| options.progressive).is_none())
|
||||
+ {
|
||||
+ return Err(bad(command, "cpu_progressive_every_pass requires CPU progressive raytracing"));
|
||||
+ }
|
||||
solidcraft_render::job::validate_raster_lights(&input.raster_lights).map_err(job_error)?;
|
||||
solidcraft_render::job::validate_raster_punctual_lights(&input.raster_punctual_lights).map_err(job_error)?;
|
||||
solidcraft_render::job::validate_raster_area_lights(&input.raster_area_lights).map_err(job_error)?;
|
||||
@@ -1052,6 +1135,7 @@
|
||||
return Err(bad(command, "resolved executor is not installed as an image job host"));
|
||||
}
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: input.cpu_progressive_every_pass.unwrap_or(true),
|
||||
raster_punctual_lights: input.raster_punctual_lights.take(),
|
||||
raster_area_lights: input.raster_area_lights.take(),
|
||||
raster_exposure_ev: if input.integrator == Integrator::Raster { settings.exposure_ev } else { 0.0 },
|
||||
@@ -1285,6 +1369,7 @@
|
||||
return Err(bad(command, "image host is unavailable"));
|
||||
}
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/engine/src/render_jobs.rs
|
||||
+++ b/crates/engine/src/render_jobs.rs
|
||||
@@ -800,6 +800,7 @@
|
||||
use solidcraft_render::job::{CpuProgressiveOptions, ImageRequest, JobOptions, RaytraceOptions};
|
||||
let (session, host) = native().unwrap();
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/gpu/src/path/denoise_tests.rs
|
||||
+++ b/crates/gpu/src/path/denoise_tests.rs
|
||||
@@ -157,6 +157,7 @@
|
||||
let mut camera = Camera { distance: 4.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/gpu/src/path/tests.rs
|
||||
+++ b/crates/gpu/src/path/tests.rs
|
||||
@@ -21,6 +21,7 @@
|
||||
let mut camera = Camera { distance: 4.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -434,6 +435,7 @@
|
||||
let bounds = meshes.iter().fold(Aabb3::EMPTY, |a, m| a.union(&m.mesh.bounds()));
|
||||
let camera = Camera { target: Vec3::new(0.0, 0.0, 1.0), yaw: -0.45, pitch: 0.5, distance: 13.0, fov: 0.65, ..Default::default() };
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/examples/cpu_resource_smoke.rs
|
||||
+++ b/crates/render/examples/cpu_resource_smoke.rs
|
||||
@@ -31,6 +31,7 @@
|
||||
let mut camera = Camera { distance: 65.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/host.rs
|
||||
+++ b/crates/render/src/job/host.rs
|
||||
@@ -188,6 +188,7 @@
|
||||
strip.append_to(&mut options, 64)?;
|
||||
}
|
||||
Ok(ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -1183,7 +1184,7 @@
|
||||
if let Some(partial) = self.partial.as_mut() {
|
||||
let partial = partial.get_mut()?;
|
||||
let task = self.task.as_ref().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing partial CPU task"))?;
|
||||
- let uniform_pass = task.completed_pass_ready(partial.credits.plan)?;
|
||||
+ let uniform_pass = if self.handle.0.request.cpu_progressive_every_pass { task.completed_pass_ready(partial.credits.plan)? } else { None };
|
||||
let automatic_pass = uniform_pass.filter(|pass| *pass > partial.last_pass_attempt);
|
||||
if let Some(pass) = automatic_pass {
|
||||
partial.last_pass_attempt = pass;
|
||||
@@ -1383,10 +1384,12 @@
|
||||
data = self.handle.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render preview publication lock poisoned"))?;
|
||||
self.handle.0.cancel.check()?;
|
||||
}
|
||||
- self.next_checkpoint_pass = self
|
||||
- .next_checkpoint_pass
|
||||
- .checked_add(1)
|
||||
- .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "checkpoint pass ordinal exhausted"))?;
|
||||
+ self.next_checkpoint_pass = if self.handle.0.request.cpu_progressive_every_pass {
|
||||
+ self.next_checkpoint_pass.checked_add(1)
|
||||
+ } else {
|
||||
+ self.next_checkpoint_pass.checked_mul(2)
|
||||
+ }
|
||||
+ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "checkpoint pass ordinal exhausted"))?;
|
||||
let Some(reservation) = reservation else {
|
||||
data.cpu_preview_retention_skips = data
|
||||
.cpu_preview_retention_skips
|
||||
@@ -1656,7 +1659,7 @@
|
||||
.and_then(|v| v.progressive)
|
||||
.ok_or_else(|| JobError::new(ErrorCode::InvalidRequest, "protected previews require CPU progressive intent"))?
|
||||
.samples_per_pixel;
|
||||
- let plan = super::ProtectedPreviewPlan::new(request.width, request.height, samples, request.cpu_budget())?;
|
||||
+ let plan = super::ProtectedPreviewPlan::with_cadence(request.width, request.height, samples, request.cpu_budget(), request.cpu_progressive_every_pass)?;
|
||||
Ok(CpuPreviewPolicy::Protected(plan))
|
||||
}
|
||||
|
||||
@@ -1742,7 +1745,7 @@
|
||||
.ok_or_else(|| JobError::new(ErrorCode::InvalidRequest, "protected previews require a progressive sample target"))?
|
||||
.samples_per_pixel;
|
||||
protected.validate()?;
|
||||
- if protected != super::ProtectedPreviewPlan::new(request.width, request.height, samples, request.cpu_budget())? {
|
||||
+ if protected != super::ProtectedPreviewPlan::with_cadence(request.width, request.height, samples, request.cpu_budget(), request.cpu_progressive_every_pass)? {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "protected feedback plan does not match its admitted request"));
|
||||
}
|
||||
}
|
||||
@@ -2159,6 +2162,7 @@
|
||||
)
|
||||
.map_err(|e| JobError::new(ErrorCode::InvalidRequest, e.to_string()))?;
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -2390,6 +2394,7 @@
|
||||
let mut lights = Vec::with_capacity(8);
|
||||
lights.push(super::super::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 });
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -2464,6 +2469,7 @@
|
||||
let mut host = CpuHost::for_platform().unwrap();
|
||||
let budget = host.0.shared.budget.clone();
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -2581,6 +2587,7 @@
|
||||
|
||||
fn request() -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/host_regrade_tests.rs
|
||||
+++ b/crates/render/src/job/host_regrade_tests.rs
|
||||
@@ -47,6 +47,7 @@
|
||||
let begins = Arc::new(AtomicUsize::new(0));
|
||||
let host = ImageHost::cooperative_with(Arc::new(FixtureExecutor(begins.clone())));
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/host_tests.rs
|
||||
+++ b/crates/render/src/job/host_tests.rs
|
||||
@@ -546,6 +546,90 @@
|
||||
(host, job, running)
|
||||
}
|
||||
|
||||
+ fn fixture_with_cadence(samples: u32, every_pass: bool) -> (CpuHost, JobHandle, Running) {
|
||||
+ let host = ImageHost(Arc::new(Owner {
|
||||
+ executor: None,
|
||||
+ shared: CpuHost::shared(MEMORY_LIMIT),
|
||||
+ kind: HostKind::NativeWorker,
|
||||
+ running: Mutex::new(None),
|
||||
+ _worker: None,
|
||||
+ }));
|
||||
+ let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: every_pass,
|
||||
+ integrator: Integrator::Raytrace,
|
||||
+ raytrace: Some(RaytraceOptions {
|
||||
+ progressive: Some(CpuProgressiveOptions { samples_per_pixel: samples, seed: 123 }),
|
||||
+ lights: Some(Vec::new()),
|
||||
+ ..Default::default()
|
||||
+ }),
|
||||
+ width: 4,
|
||||
+ height: 4,
|
||||
+ ..request()
|
||||
+ };
|
||||
+ let expected = admit(&empty(), &request).unwrap().estimated_total_bytes;
|
||||
+ let job = host.submit(id(7300, 1), 19, empty(), request).unwrap();
|
||||
+ assert_eq!(host.admitted_bytes(), expected);
|
||||
+ let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
|
||||
+ let running = Running::begin(work).unwrap();
|
||||
+ (host, job, running)
|
||||
+ }
|
||||
+
|
||||
+ #[test]
|
||||
+ fn captured_legacy_cadence_reaches_real_worker_checkpoints_and_keeps_final_bytes_identical() {
|
||||
+ for (target, sparse) in [(3, vec![1, 2]), (5, vec![1, 2, 4]), (9, vec![1, 2, 4, 8])] {
|
||||
+ let mut baseline: Option<Vec<u8>> = None;
|
||||
+ for every_pass in [true, false] {
|
||||
+ let (host, job, mut running) = fixture_with_cadence(target, every_pass);
|
||||
+ let mut samples = Vec::new();
|
||||
+ let mut last_sequence = 0;
|
||||
+ let mut complete = false;
|
||||
+ for _ in 0..100_000 {
|
||||
+ let more = running.advance(1).unwrap();
|
||||
+ if let Some(preview) = job.preview().unwrap()
|
||||
+ && preview.info.frame_sequence != last_sequence
|
||||
+ {
|
||||
+ last_sequence = preview.info.frame_sequence;
|
||||
+ samples.push(preview.info.samples_per_pixel);
|
||||
+ }
|
||||
+ assert_eq!(job.status().unwrap().request.cpu_progressive_every_pass, every_pass);
|
||||
+ if !more {
|
||||
+ complete = true;
|
||||
+ break;
|
||||
+ }
|
||||
+ }
|
||||
+ assert!(complete);
|
||||
+ assert_eq!(samples, if every_pass { (1..target).collect::<Vec<_>>() } else { sparse.clone() });
|
||||
+ assert_eq!(job.status().unwrap().cpu_preview_retention_skips, 0);
|
||||
+ let frame = job.frame().unwrap().unwrap();
|
||||
+ if let Some(expected) = &baseline {
|
||||
+ assert_eq!(frame.png(), expected.as_slice());
|
||||
+ } else {
|
||||
+ baseline = Some(frame.png().to_vec());
|
||||
+ }
|
||||
+ assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
|
||||
+ drop(frame);
|
||||
+ drop(running);
|
||||
+ drop(job);
|
||||
+ assert_eq!(host.admitted_bytes(), 0);
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ #[test]
|
||||
+ fn legacy_cadence_cancellation_during_hashing_cannot_publish_or_release_a_live_payload_early() {
|
||||
+ let (host, job, mut running) = fixture_with_cadence(9, false);
|
||||
+ before_preview(&mut running);
|
||||
+ assert!(running.pending_png.is_some());
|
||||
+ job.cancel().unwrap();
|
||||
+ assert!(!running.guarded_step(1));
|
||||
+ assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
|
||||
+ assert!(job.preview().unwrap().is_none());
|
||||
+ assert!(job.frame().unwrap().is_none());
|
||||
+ drop(running);
|
||||
+ drop(job);
|
||||
+ assert_eq!(host.admitted_bytes(), 0);
|
||||
+ }
|
||||
+
|
||||
fn before_preview(running: &mut Running) {
|
||||
for _ in 0..100_000 {
|
||||
if running.pending_png.as_ref().is_some_and(|p| p.preview_samples.is_some()) {
|
||||
@@ -655,6 +739,7 @@
|
||||
|
||||
fn request() -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/image_tests.rs
|
||||
+++ b/crates/render/src/job/image_tests.rs
|
||||
@@ -98,6 +98,7 @@
|
||||
let mut camera = Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Front);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -860,3 +861,55 @@
|
||||
assert_eq!(image::load_from_memory(&png).unwrap().to_rgba8().dimensions(), (8, 8));
|
||||
}
|
||||
}
|
||||
+
|
||||
+#[test]
|
||||
+fn captured_cpu_preview_cadence_roundtrips_without_saved_sampling_or_nested_aliases() {
|
||||
+ let mut input = request();
|
||||
+ input.integrator = super::super::Integrator::Raytrace;
|
||||
+ input.transparent_background = false;
|
||||
+ input.raytrace = Some(super::super::RaytraceOptions {
|
||||
+ progressive: Some(super::super::CpuProgressiveOptions { samples_per_pixel: 5, seed: 13 }),
|
||||
+ ..Default::default()
|
||||
+ });
|
||||
+ for every_pass in [true, false] {
|
||||
+ input.cpu_progressive_every_pass = every_pass;
|
||||
+ let wire = serde_json::to_value(&input).unwrap();
|
||||
+ assert_eq!(wire.get("cpu_progressive_every_pass"), (!every_pass).then_some(&serde_json::Value::Bool(false)));
|
||||
+ assert!(wire["raytrace"].get("cpu_progressive_every_pass").is_none());
|
||||
+ let decoded: ImageRequest = serde_json::from_value(wire).unwrap();
|
||||
+ assert_eq!(decoded.cpu_progressive_every_pass, every_pass);
|
||||
+ assert_eq!(decoded.raytrace.as_ref().unwrap().progressive, input.raytrace.as_ref().unwrap().progressive);
|
||||
+ assert_eq!(decoded.try_clone_for_host().unwrap().cpu_progressive_every_pass, every_pass);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+#[cfg(feature = "raytrace-cpu")]
|
||||
+#[test]
|
||||
+fn legacy_protected_feedback_restores_the_original_global_distribution_and_sixty_four_cap() {
|
||||
+ use super::super::{CpuBudget, ProtectedPreviewPlan};
|
||||
+ let tiny = ProtectedPreviewPlan::with_cadence(2, 1, 5, CpuBudget::Compact, false).unwrap();
|
||||
+ assert_eq!(tiny.quota_limit(), 9);
|
||||
+ assert_eq!((0..9).map(|index| tiny.milestone(index).unwrap()).collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||
+ let plan = ProtectedPreviewPlan::with_cadence(65, 1, 3, CpuBudget::Compact, false).unwrap();
|
||||
+ plan.validate().unwrap();
|
||||
+ assert_eq!(plan.quota_limit(), 64);
|
||||
+ assert_eq!([0, 1, 31, 32, 63].map(|index| plan.milestone(index).unwrap()), [1, 4, 95, 99, 194]);
|
||||
+ let milestones: Vec<_> = (0..64).map(|index| plan.milestone(index).unwrap()).collect();
|
||||
+ for committed in 0..=195 {
|
||||
+ let expected = milestones.iter().filter(|&&milestone| milestone <= committed).count() as u32;
|
||||
+ assert_eq!(plan.reached_milestones(committed).unwrap(), expected);
|
||||
+ }
|
||||
+ assert!(plan.reached_milestones(196).is_err());
|
||||
+ assert!(plan.milestone(64).is_err());
|
||||
+ assert_eq!(plan.presentation_limit().unwrap(), 64 * plan.snapshot_work().unwrap());
|
||||
+ assert_eq!(plan.ordinary_limit(), CpuBudget::Compact.limits().max_work_units);
|
||||
+ let single = ProtectedPreviewPlan::with_cadence(1, 1, 1, CpuBudget::Compact, false).unwrap();
|
||||
+ assert_eq!((single.quota_limit(), single.reached_milestones(1).unwrap()), (0, 0));
|
||||
+ let one = ProtectedPreviewPlan::with_cadence(1, 1, 2, CpuBudget::Compact, false).unwrap();
|
||||
+ assert_eq!((one.quota_limit(), one.milestone(0).unwrap(), one.reached_milestones(1).unwrap()), (1, 1, 1));
|
||||
+ let high = ProtectedPreviewPlan::with_cadence(1, 1, 1_048_576, CpuBudget::Workstation, false).unwrap();
|
||||
+ assert_eq!((high.quota_limit(), high.milestone(63).unwrap()), (64, 1_048_575));
|
||||
+ assert_eq!(high.reached_milestones(1_048_576).unwrap(), 64);
|
||||
+ let current = ProtectedPreviewPlan::new(65, 1, 3, CpuBudget::Compact).unwrap();
|
||||
+ assert_eq!(current.quota_limit(), 66);
|
||||
+}
|
||||
--- a/crates/render/src/job/led_strip/tests.rs
|
||||
+++ b/crates/render/src/job/led_strip/tests.rs
|
||||
@@ -192,6 +192,7 @@
|
||||
let mut camera = Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/mod.rs
|
||||
+++ b/crates/render/src/job/mod.rs
|
||||
@@ -1118,6 +1118,10 @@
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct ImageRequest {
|
||||
+ /// Captured CPU publication policy, separate from saved sampling intent.
|
||||
+ /// False survives request serialization; omission preserves every-pass mode.
|
||||
+ #[serde(default = "default_cpu_progressive_every_pass", skip_serializing_if = "cpu_progressive_every_pass_enabled")]
|
||||
+ pub cpu_progressive_every_pass: bool,
|
||||
/// Resolved Raster-only capture of RenderSetup.exposure_ev, never a second authority.
|
||||
#[serde(default, skip_serializing_if = "zero_raster_exposure")]
|
||||
pub raster_exposure_ev: f64,
|
||||
@@ -1160,6 +1164,14 @@
|
||||
Straight,
|
||||
}
|
||||
|
||||
+fn default_cpu_progressive_every_pass() -> bool {
|
||||
+ true
|
||||
+}
|
||||
+
|
||||
+fn cpu_progressive_every_pass_enabled(value: &bool) -> bool {
|
||||
+ *value
|
||||
+}
|
||||
+
|
||||
impl ImageRequest {
|
||||
pub fn has_local_raster_lights(&self) -> bool {
|
||||
self.raster_punctual_lights.is_some() || self.raster_area_lights.is_some()
|
||||
@@ -1234,6 +1246,7 @@
|
||||
return Ok(self.clone());
|
||||
}
|
||||
Ok(Self {
|
||||
+ cpu_progressive_every_pass: self.cpu_progressive_every_pass,
|
||||
raster_exposure_ev: self.raster_exposure_ev,
|
||||
raster_lights: raster_lights::try_copy(&self.raster_lights)?,
|
||||
raster_punctual_lights: raster_lights::try_copy_punctual(&self.raster_punctual_lights)?,
|
||||
@@ -1771,6 +1784,7 @@
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct ProtectedPreviewPlan {
|
||||
preview: PartialPreviewPlan,
|
||||
+ every_pass: bool,
|
||||
samples_per_pixel: u32,
|
||||
budget: CpuBudget,
|
||||
total_commits: u64,
|
||||
@@ -1778,6 +1792,9 @@
|
||||
}
|
||||
impl ProtectedPreviewPlan {
|
||||
pub fn new(source_width: u32, source_height: u32, samples_per_pixel: u32, budget: CpuBudget) -> Result<Self> {
|
||||
+ Self::with_cadence(source_width, source_height, samples_per_pixel, budget, true)
|
||||
+ }
|
||||
+ pub(crate) fn with_cadence(source_width: u32, source_height: u32, samples_per_pixel: u32, budget: CpuBudget, every_pass: bool) -> Result<Self> {
|
||||
budget.validate_image(source_width, source_height, Some(CpuProgressiveOptions { samples_per_pixel, seed: 0 }))?;
|
||||
let preview = PartialPreviewPlan::new(source_width, source_height)?;
|
||||
let total_commits = u64::from(source_width)
|
||||
@@ -1787,14 +1804,17 @@
|
||||
let pixels = u64::from(source_width) * u64::from(source_height);
|
||||
let early =
|
||||
u32::try_from(pixels.saturating_sub(1).min(64)).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "protected early quota overflow"))?;
|
||||
- let quota_limit =
|
||||
- early.checked_add(samples_per_pixel - 1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "protected quota overflow"))?;
|
||||
- let plan = Self { preview, samples_per_pixel, budget, total_commits, quota_limit };
|
||||
+ let quota_limit = if every_pass {
|
||||
+ early.checked_add(samples_per_pixel - 1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "protected quota overflow"))?
|
||||
+ } else {
|
||||
+ u32::try_from(total_commits.saturating_sub(1).min(64)).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "protected quota overflow"))?
|
||||
+ };
|
||||
+ let plan = Self { preview, every_pass, samples_per_pixel, budget, total_commits, quota_limit };
|
||||
plan.aggregate_limit()?;
|
||||
Ok(plan)
|
||||
}
|
||||
pub fn validate(&self) -> Result<()> {
|
||||
- if *self != Self::new(self.preview.source_width(), self.preview.source_height(), self.samples_per_pixel, self.budget)? {
|
||||
+ if *self != Self::with_cadence(self.preview.source_width(), self.preview.source_height(), self.samples_per_pixel, self.budget, self.every_pass)? {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "protected feedback plan differs from its canonical policy"));
|
||||
}
|
||||
Ok(())
|
||||
@@ -1838,6 +1858,20 @@
|
||||
pub(crate) fn reached_milestones(&self, committed: u64) -> Result<u32> {
|
||||
if committed > self.total_commits {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "protected frontier exceeds its final target"));
|
||||
+ }
|
||||
+ if !self.every_pass {
|
||||
+ if committed == 0 || self.quota_limit == 0 {
|
||||
+ return Ok(0);
|
||||
+ }
|
||||
+ if committed >= self.total_commits - 1 || self.quota_limit == 1 {
|
||||
+ return Ok(self.quota_limit);
|
||||
+ }
|
||||
+ return committed
|
||||
+ .checked_mul(u64::from(self.quota_limit - 1))
|
||||
+ .map(|n| n.div_ceil(self.total_commits - 2))
|
||||
+ .and_then(|n| u32::try_from(n).ok())
|
||||
+ .filter(|n| *n <= self.quota_limit)
|
||||
+ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "protected legacy reached quota overflow"));
|
||||
}
|
||||
let pixels = u64::from(self.preview.source_width()) * u64::from(self.preview.source_height());
|
||||
let early = pixels.saturating_sub(1).min(64);
|
||||
@@ -1866,6 +1900,17 @@
|
||||
if index >= self.quota_limit {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "protected milestone index outside its quota"));
|
||||
}
|
||||
+ if !self.every_pass {
|
||||
+ if self.quota_limit == 1 {
|
||||
+ return Ok(1);
|
||||
+ }
|
||||
+ return self.total_commits
|
||||
+ .checked_sub(2)
|
||||
+ .and_then(|n| n.checked_mul(u64::from(index)))
|
||||
+ .and_then(|n| n.checked_div(u64::from(self.quota_limit - 1)))
|
||||
+ .and_then(|n| n.checked_add(1))
|
||||
+ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "protected legacy milestone overflow"));
|
||||
+ }
|
||||
let pixels = u64::from(self.preview.source_width()) * u64::from(self.preview.source_height());
|
||||
let early = u32::try_from(pixels.saturating_sub(1).min(64))
|
||||
.map_err(|_| JobError::new(ErrorCode::LimitExceeded, "protected early milestone overflow"))?;
|
||||
--- a/crates/render/src/job/png.rs
|
||||
+++ b/crates/render/src/job/png.rs
|
||||
@@ -104,6 +104,7 @@
|
||||
|
||||
fn request(width: u32, height: u32) -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/regrade.rs
|
||||
+++ b/crates/render/src/job/regrade.rs
|
||||
@@ -94,6 +94,7 @@
|
||||
return self.pending(done, total);
|
||||
}
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -180,6 +181,7 @@
|
||||
}
|
||||
self.linear = None;
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/job/rt2_tests.rs
|
||||
+++ b/crates/render/src/job/rt2_tests.rs
|
||||
@@ -6,6 +6,7 @@
|
||||
|
||||
fn request(integrator: Integrator) -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/anisotropic_faces_tests.rs
|
||||
+++ b/crates/render/src/raytrace/anisotropic_faces_tests.rs
|
||||
@@ -146,6 +146,7 @@
|
||||
fn decoded_cpu_png_rotates_only_the_two_explicit_planar_targets() {
|
||||
fn render(scene: ProductScene, camera: Camera, options: RaytraceOptions) -> ::image::RgbaImage {
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/anisotropic_reflection_image_tests.rs
|
||||
+++ b/crates/render/src/raytrace/anisotropic_reflection_image_tests.rs
|
||||
@@ -64,6 +64,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/deterministic_primary_tests.rs
|
||||
+++ b/crates/render/src/raytrace/deterministic_primary_tests.rs
|
||||
@@ -64,6 +64,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -233,6 +234,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/dielectric_tests.rs
|
||||
+++ b/crates/render/src/raytrace/dielectric_tests.rs
|
||||
@@ -43,6 +43,7 @@
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/environment_image_tests.rs
|
||||
+++ b/crates/render/src/raytrace/environment_image_tests.rs
|
||||
@@ -35,6 +35,7 @@
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/environment_reflection_tests.rs
|
||||
+++ b/crates/render/src/raytrace/environment_reflection_tests.rs
|
||||
@@ -40,6 +40,7 @@
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Top);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/image.rs
|
||||
+++ b/crates/render/src/raytrace/image.rs
|
||||
@@ -171,7 +171,7 @@
|
||||
plan.validate()?;
|
||||
let progressive =
|
||||
options.progressive.ok_or_else(|| JobError::new(ErrorCode::InvalidRequest, "protected feedback requires progressive CPU sampling"))?;
|
||||
- if plan != job::ProtectedPreviewPlan::new(request.width, request.height, progressive.samples_per_pixel, options.budget)? {
|
||||
+ if plan != job::ProtectedPreviewPlan::with_cadence(request.width, request.height, progressive.samples_per_pixel, options.budget, request.cpu_progressive_every_pass)? {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "protected feedback plan differs from actual source sampling or budget"));
|
||||
}
|
||||
}
|
||||
@@ -2192,13 +2192,13 @@
|
||||
if self.pixel == self.request.width as usize * self.request.height as usize {
|
||||
if let Some(progressive) = &mut self.progressive {
|
||||
let samples = progressive.film.samples();
|
||||
- if progressive.partial_plan.is_some() && samples < progressive.options.samples_per_pixel && samples > self.last_pass_boundary
|
||||
+ if self.request.cpu_progressive_every_pass && progressive.partial_plan.is_some() && samples < progressive.options.samples_per_pixel && samples > self.last_pass_boundary
|
||||
{
|
||||
self.last_pass_boundary = samples;
|
||||
return Ok(ImageAdvance::Legacy(ImagePoll::Pending(self.progress())));
|
||||
}
|
||||
self.work.tick(&self.cancel).map_err(error)?;
|
||||
- if samples == progressive.options.samples_per_pixel || progressive.partial_plan.is_none() {
|
||||
+ if samples == progressive.options.samples_per_pixel || (progressive.partial_plan.is_none() && (self.request.cpu_progressive_every_pass || samples.is_power_of_two())) {
|
||||
progressive.resolving = true;
|
||||
} else {
|
||||
self.pixel = 0;
|
||||
--- a/crates/render/src/raytrace/image_tests.rs
|
||||
+++ b/crates/render/src/raytrace/image_tests.rs
|
||||
@@ -176,6 +176,7 @@
|
||||
}
|
||||
fn request() -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -3127,6 +3128,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/primary_aa_tests.rs
|
||||
+++ b/crates/render/src/raytrace/primary_aa_tests.rs
|
||||
@@ -178,6 +178,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -781,6 +782,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -1978,3 +1980,52 @@
|
||||
assert_eq!(bits, [[0.0_f64.to_bits(); 3]]);
|
||||
assert!(task.done && task.progressive.is_none());
|
||||
}
|
||||
+
|
||||
+#[test]
|
||||
+fn sparse_checkpoint_compatibility_preserves_each_final_png_and_deterministic_sample_prefix() {
|
||||
+ for (target, expected_sparse) in [(1, vec![]), (3, vec![1, 2]), (5, vec![1, 2, 4]), (9, vec![1, 2, 4, 8])] {
|
||||
+ let current = progressive_fixture(target, 19, Some(true), 1.0);
|
||||
+ let source = current.visibility_owner.source().clone();
|
||||
+ let options = current.visibility_owner.options().clone();
|
||||
+ let mut legacy_request = current.request.clone();
|
||||
+ legacy_request.cpu_progressive_every_pass = false;
|
||||
+ let legacy = ImageTask::new(source, legacy_request, CancelToken::default(), options).unwrap();
|
||||
+ let (each_previews, each_final, _) = progressive_complete(current, 1);
|
||||
+ let (legacy_previews, legacy_final, _) = progressive_complete(legacy, 3);
|
||||
+ assert_eq!(each_previews.iter().map(|(samples, _)| *samples).collect::<Vec<_>>(), (1..target).collect::<Vec<_>>());
|
||||
+ assert_eq!(legacy_previews.iter().map(|(samples, _)| *samples).collect::<Vec<_>>(), expected_sparse);
|
||||
+ assert_eq!(legacy_final, each_final, "publication policy must not change the requested final PNG");
|
||||
+ for (samples, png) in legacy_previews {
|
||||
+ assert_eq!(png, each_previews.iter().find(|(count, _)| *count == samples).unwrap().1);
|
||||
+ }
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+#[test]
|
||||
+fn legacy_protected_producer_consumes_the_original_global_milestones_without_changing_final_pixels() {
|
||||
+ let (scene, mut request, options) = partial_four_pixel_source(5, 29);
|
||||
+ request.cpu_progressive_every_pass = false;
|
||||
+ let reference = ImageTask::new(scene.clone(), request.clone(), CancelToken::default(), options.clone()).unwrap();
|
||||
+ let (_, expected_png, _) = progressive_complete(reference, 3);
|
||||
+ let plan = job::ProtectedPreviewPlan::with_cadence(request.width, request.height, 5, options.budget, false).unwrap();
|
||||
+ assert_eq!((plan.total_commits(), plan.quota_limit()), (20, 19));
|
||||
+ let mut task = ImageTask::new_with_environment_and_nested_and_protected_partial(
|
||||
+ scene, request, CancelToken::default(), options, None, false, plan,
|
||||
+ )
|
||||
+ .unwrap();
|
||||
+ let mut rays = Vec::new();
|
||||
+ for committed in 1..20 {
|
||||
+ reach_partial_frontier(&mut task, (committed / 4) as u32, (committed % 4) as usize, &mut rays);
|
||||
+ assert!(matches!(task.begin_partial_preview(plan.preview_plan()).unwrap(), PartialBegin::Started));
|
||||
+ let (_, _, passes, prefix) = finish_partial_snapshot(&mut task);
|
||||
+ assert_eq!(u64::from(passes) * 4 + prefix, committed);
|
||||
+ let report = task.protected_preview_report().unwrap();
|
||||
+ assert_eq!((report.accepted_snapshots, report.next_milestone_index), (committed as u32, committed as u32));
|
||||
+ assert_eq!(report.quota_limit, 19);
|
||||
+ }
|
||||
+ let (actual_png, _) = finish_partial_final(&mut task, true, &mut rays);
|
||||
+ assert_eq!(actual_png, expected_png);
|
||||
+ let report = task.protected_preview_report().unwrap();
|
||||
+ assert_eq!((report.accepted_snapshots, report.quota_limit), (19, 19));
|
||||
+ assert_eq!(report.presentation_used, 19 * plan.snapshot_work().unwrap());
|
||||
+}
|
||||
--- a/crates/render/src/raytrace/punctual_image_tests.rs
|
||||
+++ b/crates/render/src/raytrace/punctual_image_tests.rs
|
||||
@@ -44,6 +44,7 @@
|
||||
..Default::default()
|
||||
};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/render/src/raytrace/reflection_image_tests.rs
|
||||
+++ b/crates/render/src/raytrace/reflection_image_tests.rs
|
||||
@@ -183,6 +183,7 @@
|
||||
let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
|
||||
camera.set_view(crate::StandardView::Front);
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -0,0 +1,192 @@
|
||||
{
|
||||
"status": "SOURCE_ONLY_NOT_ADOPTED_UNCOMPILED_UNRUN",
|
||||
"subpackage": "core",
|
||||
"base_source_manifest_sha256": "d38a8d946b6653864ad8918d4da662725bd24ca01b2e5aa2d3b38b47b1a7e163",
|
||||
"base_rule": "Exact per-file RAW preimages only. Not current main, not a combined candidate. LF patch is review aid; RAW candidate bytes are authoritative.",
|
||||
"files": [
|
||||
{
|
||||
"path": "crates/engine/src/cmd/render.rs",
|
||||
"before_sha256": "13d0bc2e8a72589e0b7a6cad8a6d04d8a22d53196341be8ae6826afaf48584fa",
|
||||
"before_bytes": 44175,
|
||||
"after_sha256": "bcf237b491702c72b39fc6785cd5b2ea122f56bab150ba453890162e5bee4c2c",
|
||||
"after_bytes": 44454
|
||||
},
|
||||
{
|
||||
"path": "crates/engine/src/cmd/render/jobs.rs",
|
||||
"before_sha256": "2047f85079cb63cb5f7707132547495bf04b6ec445ddd5579bfb3e8df2223720",
|
||||
"before_bytes": 80469,
|
||||
"after_sha256": "2fc9237027d138156680a706ba7b21c053e482e315a6853628baaf86719b4a48",
|
||||
"after_bytes": 85636
|
||||
},
|
||||
{
|
||||
"path": "crates/engine/src/render_jobs.rs",
|
||||
"before_sha256": "27aa67247bbd57610432caf62bfc51af25fcd51c8827c41df99f12bd1aa74666",
|
||||
"before_bytes": 42460,
|
||||
"after_sha256": "0dd214ab6a8b0008c5246c06a104486e9c688d4b83cbf9b528f48dff4c115e8f",
|
||||
"after_bytes": 42506
|
||||
},
|
||||
{
|
||||
"path": "crates/gpu/src/path/denoise_tests.rs",
|
||||
"before_sha256": "011bf8457c8fbfa4409ab5469d16472371112c9a68e1500d4d4c652e93f474e0",
|
||||
"before_bytes": 15894,
|
||||
"after_sha256": "6c7cae223c6f1bdba7dead425c2f7071f9ca9c8e0c93f356283162471f784105",
|
||||
"after_bytes": 15936
|
||||
},
|
||||
{
|
||||
"path": "crates/gpu/src/path/tests.rs",
|
||||
"before_sha256": "206f281b911227041f1a9fdb882e6258f6ee2cd474eecb8437334c1712e3be2b",
|
||||
"before_bytes": 164444,
|
||||
"after_sha256": "bd688f029e4a63294dfa8d5609c7a495fbf9978b6ec6f77faa43661a30ae9ad1",
|
||||
"after_bytes": 164528
|
||||
},
|
||||
{
|
||||
"path": "crates/render/examples/cpu_resource_smoke.rs",
|
||||
"before_sha256": "962ec3c205a4a0203a2822654c3000493ce44ea19122b6dbe8be4c07fc28b6a1",
|
||||
"before_bytes": 8548,
|
||||
"after_sha256": "992849c3c2d6c67580539d43d95893cc4bf296f7906b406159f1fd74d5e9e45b",
|
||||
"after_bytes": 8590
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/host.rs",
|
||||
"before_sha256": "9dbf55511147641a8d7d7c3b4bf444ae8b8ece154aab49db4b57cb208347b4a8",
|
||||
"before_bytes": 135424,
|
||||
"after_sha256": "89f289616278f62ac71974df1edb8890ccf910be0307aa2dbb043b82b7eda4a7",
|
||||
"after_bytes": 135938
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/host_regrade_tests.rs",
|
||||
"before_sha256": "f4bd4bd1216ff356691e99a911a110f43bde624cb4544281c9a521b27067d762",
|
||||
"before_bytes": 7156,
|
||||
"after_sha256": "264c69d6a247c1bed7f309d6f13ed38ee18927671db0642fa8dddab71566098f",
|
||||
"after_bytes": 7198
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/host_tests.rs",
|
||||
"before_sha256": "f159bd988beb8055b7d6e80a89eef5ba1e967e982c97d5480b80c93d19509ef0",
|
||||
"before_bytes": 119544,
|
||||
"after_sha256": "455d87a8573e0438b506be62710a3473d30d112151afab6de3ff6cb98c09223a",
|
||||
"after_bytes": 123326
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/image_tests.rs",
|
||||
"before_sha256": "8b8f84e21ded158040c697f9491b6afbf7ab01c5759becee61e56f2606518454",
|
||||
"before_bytes": 43963,
|
||||
"after_sha256": "ed0781fa45aa08be62f2d230f4ed53602e4de9e21ba25021ea81687b6db6b218",
|
||||
"after_bytes": 47200
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/led_strip/tests.rs",
|
||||
"before_sha256": "8788bd088b5baab8a0ef6bd8026cf8d5c4eadfc53b8f3e1cf1ca32cc1b6fa828",
|
||||
"before_bytes": 11810,
|
||||
"after_sha256": "233782eb6b0ff5f08b054aa1252d56f977e9ecd72b99178fa52cb0941927972e",
|
||||
"after_bytes": 11856
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/mod.rs",
|
||||
"before_sha256": "ad442c55f9a3edeeac359ca4c91c2dc5028bee36b981f6953e6399daf65c7c12",
|
||||
"before_bytes": 84674,
|
||||
"after_sha256": "ec10cd33a59211b63d47895590b995c7a9fdaa6da0f987faf84cc2cc172c1027",
|
||||
"after_bytes": 86849
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/png.rs",
|
||||
"before_sha256": "40abe173012f2be59f515517b3e89bbe530d2275f4d6f8b40cbd9686d76c84fd",
|
||||
"before_bytes": 7403,
|
||||
"after_sha256": "4c1ce7363e38315be32b9018f4b0c92450909be5e64b64d85b2f126904e705d5",
|
||||
"after_bytes": 7449
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/regrade.rs",
|
||||
"before_sha256": "5a3d7e3079d5ba1c553b07f8f845876424d6488229baefbcbbc25048b5651a16",
|
||||
"before_bytes": 9698,
|
||||
"after_sha256": "966a4460bbca2e1d800103accaa28fbbc58d2775ff128132169d21de839fc545",
|
||||
"after_bytes": 9794
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/job/rt2_tests.rs",
|
||||
"before_sha256": "8f0c3a3d476c55935367dc95604d02d16d9235beed4ab2e1aa65700cce83b51b",
|
||||
"before_bytes": 12445,
|
||||
"after_sha256": "7e7b3fd7edfd30ae1ca11ce37eb82ff637a1302cec1d5c7991a60cf648e4e61d",
|
||||
"after_bytes": 12487
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/anisotropic_faces_tests.rs",
|
||||
"before_sha256": "b63e1d323aacc2eeea1056a332ada92df78a78ef52b8c2aee5313e064d8cc479",
|
||||
"before_bytes": 11516,
|
||||
"after_sha256": "79eabb6c302a2cc38adb20be1151ec2b307ba21eda0dc39082ba6f9e39b53186",
|
||||
"after_bytes": 11562
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/anisotropic_reflection_image_tests.rs",
|
||||
"before_sha256": "8039e47fd0442f9620065ba180dbec7771bf4c0b606d12d66de3e5e63e1d0b52",
|
||||
"before_bytes": 13853,
|
||||
"after_sha256": "28a93efcdd8e237e5148e70a298e01b66b88572a309d9e077d38d967bfca15f4",
|
||||
"after_bytes": 13895
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/deterministic_primary_tests.rs",
|
||||
"before_sha256": "0fb5830cce4c9b88fe133000f4338041712880793ea7ed897a854a7f1b9a7675",
|
||||
"before_bytes": 26656,
|
||||
"after_sha256": "19e8f7161648e28938ac6e4b779a0ff420b9cb5a5251245b70f9f5532c1ffedc",
|
||||
"after_bytes": 26740
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/dielectric_tests.rs",
|
||||
"before_sha256": "6bdea1646422e925ca071b7e1643af1a9bc4c5125ad0abb69bfed17716ba64ca",
|
||||
"before_bytes": 57132,
|
||||
"after_sha256": "07a5fae9a8d1da52f6d26f9781073e91bcbea5b3143de6cd609f554165f20acd",
|
||||
"after_bytes": 57174
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/environment_image_tests.rs",
|
||||
"before_sha256": "42442aaa4bcdda016b4349e096fd389e731df13683dbef9938925298432912b9",
|
||||
"before_bytes": 14637,
|
||||
"after_sha256": "62b0ebac6e9e6a331b1866d1fca9a0e804b51189c980ff4e861e4443bfa62bce",
|
||||
"after_bytes": 14679
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/environment_reflection_tests.rs",
|
||||
"before_sha256": "1466b408dd3e670ce05ae3cb0487e789c77a7079ad88093d83c70f4de4cb7d75",
|
||||
"before_bytes": 12619,
|
||||
"after_sha256": "1be638c140d841d32549de3bfba78615c51a9d63b52e7a4f7e285bff2d97b225",
|
||||
"after_bytes": 12661
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/image.rs",
|
||||
"before_sha256": "4e8f63765ca35f305e3caa0946fceba90573be243717bd08b54deeb948f59326",
|
||||
"before_bytes": 126260,
|
||||
"after_sha256": "06c517a1827fd53d3f3f0b22d927c5dbcc005c32fd7b556f45ab51ce049ee4e1",
|
||||
"after_bytes": 126424
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/image_tests.rs",
|
||||
"before_sha256": "5e6724dfe01a583b880862e24a2bfada40052bda09388e977f28f70f55029f89",
|
||||
"before_bytes": 173358,
|
||||
"after_sha256": "68ff49f05ab005fa9a8540660f97fedbef637b79c2cb02129ee7f358394b6609",
|
||||
"after_bytes": 173446
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/primary_aa_tests.rs",
|
||||
"before_sha256": "9366a35fa85e3b04eca01438da697979a1be4528fbc57a21d13da4b69aa175fc",
|
||||
"before_bytes": 98436,
|
||||
"after_sha256": "8b728f4c2d8f33dd50a78e93e3328907213e6419e3a84c8403aea4e02b909551",
|
||||
"after_bytes": 101590
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/punctual_image_tests.rs",
|
||||
"before_sha256": "fc07b7dbfb3996952d8c9ad55aa228a4bb4740ec5703bc6a5a551c7657f66394",
|
||||
"before_bytes": 11513,
|
||||
"after_sha256": "0099c88b7982ef8d295cc86d5e56ddc2a814ef405cb0ce0a235149d1e904a870",
|
||||
"after_bytes": 11555
|
||||
},
|
||||
{
|
||||
"path": "crates/render/src/raytrace/reflection_image_tests.rs",
|
||||
"before_sha256": "87d80555bea2bf2e908f20223796f6d58d59508f13a930aa9e11eb36e6d999de",
|
||||
"before_bytes": 15596,
|
||||
"after_sha256": "568a111b43726ff10c98d75c6363360ccadd18cde964bd5192b06aff29c62936",
|
||||
"after_bytes": 15638
|
||||
}
|
||||
],
|
||||
"full_CI_native_or_readiness": false,
|
||||
"candidate_whole_file_overlay_safe": true
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
# Exact earlier C28 formatted host, separate from compatibility WIP
|
||||
|
||||
This is the actual compiled C28 host source (RAW SHA-256
|
||||
9dbf55511147641a8d7d7c3b4bf444ae8b8ece154aab49db4b57cb208347b4a8),
|
||||
retained as the before file in the sealed compatibility core packet. It belongs
|
||||
to the C28 d38a exact-source baseline. The formatter removed exactly one LF
|
||||
from the prior recovery source 2c72c307; every other byte is unchanged.
|
||||
|
||||
Earlier C28 built five library artifacts and completed ten inventories. Selected
|
||||
cases: **28 PASS / 1 font-fixture panic / 954 UNRUN**, with two actual
|
||||
CPU-supported true markers before stopping. Postchecks were not executed; no
|
||||
native application acceptance, full CI or readiness is claimed. This single file
|
||||
is not the whole source binding for that earlier build.
|
||||
|
||||
The failure was case 976's unregistered ui-semibold test font, not a failing
|
||||
SPP/cap assertion. Its before test-file SHA is 28ddafe4; that exact source is
|
||||
already preserved in the [earlier source archive](../../cpu-every-pass-c27-source/candidate/crates/ui-egui/src/render_workspace_tests.rs).
|
||||
The separate fontfix candidate 9a3e58d8 is UNRUN and must not inherit a pass here.
|
||||
|
||||
Do not confuse this file with core's compatibility host candidate 89f28961,
|
||||
which remains NOT ADOPTED, UNCOMPILED and UNRUN. No compatibility code is applied
|
||||
by this reference package.
|
||||
+2992
File diff suppressed because it is too large.
Load diff
+10
@@ -0,0 +1,10 @@
|
||||
--- a/crates/render/src/job/host.rs
|
||||
+++ b/crates/render/src/job/host.rs
|
||||
@@ -842,7 +842,6 @@
|
||||
}
|
||||
}
|
||||
}
|
||||
-
|
||||
|
||||
struct Running {
|
||||
source_master: Option<Arc<RenderFrame>>,
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
{
|
||||
"status": "EXACT_C28_COMPILED_HOST_REFERENCE_NOT_COMPATIBILITY_WIP",
|
||||
"base_source_manifest_sha256": "d38a8d946b6653864ad8918d4da662725bd24ca01b2e5aa2d3b38b47b1a7e163",
|
||||
"source_binding": "RAW before of the sealed compatibility owner packet, preserved as the exact earlier C28 formatted source; not the compatibility candidate.",
|
||||
"files": [
|
||||
{
|
||||
"path": "crates/render/src/job/host.rs",
|
||||
"before_sha256": "2c72c307ec49a94b100f4be32ab6a4af4be494199ff7ad5c87bb698e7f13ab4e",
|
||||
"before_bytes": 135425,
|
||||
"after_sha256": "9dbf55511147641a8d7d7c3b4bf444ae8b8ece154aab49db4b57cb208347b4a8",
|
||||
"after_bytes": 135424
|
||||
}
|
||||
],
|
||||
"delta": "Exactly one LF removed by the earlier C28 formatter, no other bytes changed from the SHA-state recovery.",
|
||||
"known_C28_result": {
|
||||
"build": "five library artifacts; ten inventories completed",
|
||||
"selected_cases": 983,
|
||||
"passed": 28,
|
||||
"failed_font_fixture": 1,
|
||||
"unrun": 954,
|
||||
"cpu_supported_true_markers": 2,
|
||||
"postchecks_executed": false,
|
||||
"native_acceptance": false,
|
||||
"full_CI_or_readiness": false
|
||||
},
|
||||
"standalone_full_source_or_new_execution_claim": false
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
# Case 976 isolated font-fixture correction
|
||||
|
||||
One RAW candidate adds only crate::fonts::setup_bundled_fonts(&ctx) after the
|
||||
new test's separate Context::default(), before it paints the existing UI kit.
|
||||
Removing that line recovers the entire captured before file byte for byte.
|
||||
All assertions, pass targets, seed and mode values are unchanged.
|
||||
|
||||
The sealed C28 failure was an unbound ui-semibold font in this separate test
|
||||
context. Actual app and Harness already register the bundled fonts. This is not
|
||||
a demonstrated product cap/transport defect, nor an SPP assertion result.
|
||||
The correction itself is **UNRUN**; its target test must be executed again on an
|
||||
authorized exact composition. No product font default or new framework changes.
|
||||
|
||||
**Do not overlay this full candidate onto ui.** Both test-file candidates start
|
||||
from the same before 28ddafe4. This file lacks ui's five new tests and four neutral
|
||||
constructor insertions. Preserve the one-line correction during later exact
|
||||
delta composition; there is no precomposed source in this archive.
|
||||
+11591
File diff suppressed because it is too large.
Load diff
+10
@@ -0,0 +1,10 @@
|
||||
--- a/crates/ui-egui/src/render_workspace_tests.rs
|
||||
+++ b/crates/ui-egui/src/render_workspace_tests.rs
|
||||
@@ -11335,6 +11335,7 @@
|
||||
h.app.render_workspace.view.raytrace.budget = budget;
|
||||
let before = json!(h.app.render_workspace.view.raytrace);
|
||||
let ctx = egui::Context::default();
|
||||
+ crate::fonts::setup_bundled_fonts(&ctx);
|
||||
let _ = ctx.run_ui(egui::RawInput::default(), |ui| {
|
||||
assert!(cpu::progressive_controls(&mut h.app, ui));
|
||||
});
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"status": "SOURCE_ONLY_NOT_ADOPTED_UNCOMPILED_UNRUN",
|
||||
"subpackage": "fontfix",
|
||||
"base_source_manifest_sha256": "d38a8d946b6653864ad8918d4da662725bd24ca01b2e5aa2d3b38b47b1a7e163",
|
||||
"base_rule": "Exact per-file RAW preimages only. Not current main, not a combined candidate. LF patch is review aid; RAW candidate bytes are authoritative.",
|
||||
"files": [
|
||||
{
|
||||
"path": "crates/ui-egui/src/render_workspace_tests.rs",
|
||||
"before_sha256": "28ddafe4a8f133c522ddf6f1e0eaaaf70f954d7b8acdb7cca44aabef9a512e47",
|
||||
"before_bytes": 634699,
|
||||
"after_sha256": "9a3e58d83f6180ef8cd89c36a4ae4a8d09679f23a15f222a95edc2b70db25e9c",
|
||||
"after_bytes": 634748
|
||||
}
|
||||
],
|
||||
"full_CI_native_or_readiness": false,
|
||||
"candidate_whole_file_overlay_safe": false,
|
||||
"shared_before_test_file_sha256": "28ddafe4a8f133c522ddf6f1e0eaaaf70f954d7b8acdb7cca44aabef9a512e47"
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
# Preference UI and locale successor WIP
|
||||
|
||||
Two RAW candidates: prefs.rs from the sealed preferences proposal and the exact
|
||||
locale-only v2 successor. **NOT ADOPTED, UNCOMPILED, UNRUN**. One new preference
|
||||
contract test is written, not executed. Both bools default true, persist through
|
||||
the existing typed protocol, reject nonboolean values and reset with Graphics.
|
||||
Unrelated page reset preserves them. The collapsed Advanced CPU rendering
|
||||
section uses existing UI-kit controls. Runtime consumers require core + ui.
|
||||
|
||||
The locale successor changes one help message in six languages, describing the
|
||||
earlier sparse policy without promising powers-of-two for protected rendering.
|
||||
Publication can be coalesced by the display; no physical-repaint guarantee is
|
||||
made. Other message values remain exact. The new locale has no original base
|
||||
file; the intermediate v1 hash is recorded only as lineage in the bindings.
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
{
|
||||
"de": {
|
||||
"prefs.cpu_render_advanced": "Erweitertes CPU-Rendering",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "Erfasste progressive Abtastung in Interactive verwenden",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "Verwendet das erfasste Abtastziel und den Zufallsstartwert. Aus stellt nur für Interactive 16 Abtastungen und Startwert 0 wieder her. Ohne progressive Anfrage bleibt 16/0; finale Einstellungen bleiben unverändert.",
|
||||
"prefs.render_cpu_progressive_every_pass": "Jeden vollständigen CPU-Durchgang veröffentlichen",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "Veröffentlicht jeden vollständigen nichtfinalen Durchgang bei verfügbarem Snapshot-Speicher. Aus stellt die frühere sparsame Rückmeldung wieder her. Das Ziel bleibt gleich; die Anzeige kann Aktualisierungen zusammenfassen."
|
||||
},
|
||||
"en": {
|
||||
"prefs.cpu_render_advanced": "Advanced CPU rendering",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "Use captured progressive sampling in Interactive",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "Use the captured progressive target and seed. Off restores 16 samples and seed 0 for Interactive only. An absent progressive request still uses 16/0; final settings are unchanged.",
|
||||
"prefs.render_cpu_progressive_every_pass": "Publish every complete CPU pass",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "Publish each complete nonfinal pass when snapshot storage is available. Off restores the earlier sparse feedback policy. The target is unchanged; the screen may combine updates."
|
||||
},
|
||||
"es": {
|
||||
"prefs.cpu_render_advanced": "Renderizado CPU avanzado",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "Usar el muestreo progresivo capturado en Interactive",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "Usa el objetivo y la semilla progresivos capturados. Desactivado restaura 16 muestras y semilla 0 solo en Interactive. Sin petición progresiva se conserva 16/0; los ajustes finales no cambian.",
|
||||
"prefs.render_cpu_progressive_every_pass": "Publicar cada pasada CPU completa",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "Publica cada pasada completa no final cuando hay espacio para snapshots. Desactivado restaura la política anterior de actualizaciones espaciadas. El objetivo no cambia; la pantalla puede agrupar actualizaciones."
|
||||
},
|
||||
"ja": {
|
||||
"prefs.cpu_render_advanced": "CPUレンダリングの詳細設定",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "Interactiveで取得済みのプログレッシブ設定を使用",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "取得済みの目標サンプル数とシードを使用します。オフではInteractiveのみ16サンプル、シード0に戻ります。プログレッシブ指定がない場合は16/0を維持し、最終設定は変わりません。",
|
||||
"prefs.render_cpu_progressive_every_pass": "CPUの各完了パスを公開",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "スナップショット用の空きがある場合、最終以外の各完了パスを公開します。オフでは以前の間隔を空けた更新方針に戻ります。目標は変わらず、画面更新はまとめられる場合があります。"
|
||||
},
|
||||
"ko": {
|
||||
"prefs.cpu_render_advanced": "고급 CPU 렌더링",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "Interactive에서 캡처한 점진적 샘플링 사용",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "캡처한 샘플 목표와 시드를 사용합니다. 끄면 Interactive만16샘플과 시드0으로 돌아갑니다. 점진적 요청이 없으면16/0을 유지하며 최종 설정은 바뀌지 않습니다.",
|
||||
"prefs.render_cpu_progressive_every_pass": "완료된 CPU 패스마다 게시",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "스냅샷 공간이 있으면 마지막을 제외한 각 완료 패스를 게시합니다. 끄면 이전의 간헐적 피드백 정책으로 돌아갑니다. 목표는 그대로이며 화면 업데이트가 합쳐질 수 있습니다."
|
||||
},
|
||||
"zh": {
|
||||
"prefs.cpu_render_advanced": "高级CPU渲染",
|
||||
"prefs.render_cpu_interactive_explicit_sampling": "在Interactive中使用已捕获的渐进采样设置",
|
||||
"prefs.render_cpu_interactive_explicit_sampling_help": "使用已捕获的采样目标和种子。关闭后,仅Interactive恢复为16个样本和种子0。未指定渐进请求时仍使用16/0;最终设置不变。",
|
||||
"prefs.render_cpu_progressive_every_pass": "发布每个完整的CPU遍次",
|
||||
"prefs.render_cpu_progressive_every_pass_help": "快照空间可用时,发布最终遍次之前的每个完整遍次。关闭后恢复之前间隔更新的策略。目标不变;屏幕可能合并更新。"
|
||||
}
|
||||
}
|
||||
+6840
File diff suppressed because it is too large.
Load diff
+125
@@ -0,0 +1,125 @@
|
||||
--- /dev/null
|
||||
+++ b/assets/locales/pending/cpu-progressive-policy-preferences.json
|
||||
@@ -0,0 +1,44 @@
|
||||
+{
|
||||
+ "de": {
|
||||
+ "prefs.cpu_render_advanced": "Erweitertes CPU-Rendering",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "Erfasste progressive Abtastung in Interactive verwenden",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "Verwendet das erfasste Abtastziel und den Zufallsstartwert. Aus stellt nur für Interactive 16 Abtastungen und Startwert 0 wieder her. Ohne progressive Anfrage bleibt 16/0; finale Einstellungen bleiben unverändert.",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "Jeden vollständigen CPU-Durchgang veröffentlichen",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "Veröffentlicht jeden vollständigen nichtfinalen Durchgang bei verfügbarem Snapshot-Speicher. Aus stellt die frühere sparsame Rückmeldung wieder her. Das Ziel bleibt gleich; die Anzeige kann Aktualisierungen zusammenfassen."
|
||||
+ },
|
||||
+ "en": {
|
||||
+ "prefs.cpu_render_advanced": "Advanced CPU rendering",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "Use captured progressive sampling in Interactive",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "Use the captured progressive target and seed. Off restores 16 samples and seed 0 for Interactive only. An absent progressive request still uses 16/0; final settings are unchanged.",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "Publish every complete CPU pass",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "Publish each complete nonfinal pass when snapshot storage is available. Off restores the earlier sparse feedback policy. The target is unchanged; the screen may combine updates."
|
||||
+ },
|
||||
+ "es": {
|
||||
+ "prefs.cpu_render_advanced": "Renderizado CPU avanzado",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "Usar el muestreo progresivo capturado en Interactive",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "Usa el objetivo y la semilla progresivos capturados. Desactivado restaura 16 muestras y semilla 0 solo en Interactive. Sin petición progresiva se conserva 16/0; los ajustes finales no cambian.",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "Publicar cada pasada CPU completa",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "Publica cada pasada completa no final cuando hay espacio para snapshots. Desactivado restaura la política anterior de actualizaciones espaciadas. El objetivo no cambia; la pantalla puede agrupar actualizaciones."
|
||||
+ },
|
||||
+ "ja": {
|
||||
+ "prefs.cpu_render_advanced": "CPUレンダリングの詳細設定",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "Interactiveで取得済みのプログレッシブ設定を使用",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "取得済みの目標サンプル数とシードを使用します。オフではInteractiveのみ16サンプル、シード0に戻ります。プログレッシブ指定がない場合は16/0を維持し、最終設定は変わりません。",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "CPUの各完了パスを公開",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "スナップショット用の空きがある場合、最終以外の各完了パスを公開します。オフでは以前の間隔を空けた更新方針に戻ります。目標は変わらず、画面更新はまとめられる場合があります。"
|
||||
+ },
|
||||
+ "ko": {
|
||||
+ "prefs.cpu_render_advanced": "고급 CPU 렌더링",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "Interactive에서 캡처한 점진적 샘플링 사용",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "캡처한 샘플 목표와 시드를 사용합니다. 끄면 Interactive만16샘플과 시드0으로 돌아갑니다. 점진적 요청이 없으면16/0을 유지하며 최종 설정은 바뀌지 않습니다.",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "완료된 CPU 패스마다 게시",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "스냅샷 공간이 있으면 마지막을 제외한 각 완료 패스를 게시합니다. 끄면 이전의 간헐적 피드백 정책으로 돌아갑니다. 목표는 그대로이며 화면 업데이트가 합쳐질 수 있습니다."
|
||||
+ },
|
||||
+ "zh": {
|
||||
+ "prefs.cpu_render_advanced": "高级CPU渲染",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling": "在Interactive中使用已捕获的渐进采样设置",
|
||||
+ "prefs.render_cpu_interactive_explicit_sampling_help": "使用已捕获的采样目标和种子。关闭后,仅Interactive恢复为16个样本和种子0。未指定渐进请求时仍使用16/0;最终设置不变。",
|
||||
+ "prefs.render_cpu_progressive_every_pass": "发布每个完整的CPU遍次",
|
||||
+ "prefs.render_cpu_progressive_every_pass_help": "快照空间可用时,发布最终遍次之前的每个完整遍次。关闭后恢复之前间隔更新的策略。目标不变;屏幕可能合并更新。"
|
||||
+ }
|
||||
+}
|
||||
--- a/crates/ui-egui/src/prefs.rs
|
||||
+++ b/crates/ui-egui/src/prefs.rs
|
||||
@@ -942,6 +942,10 @@
|
||||
render_previous_geometry_budget: bool = false, PAGE_GRAPHICS => check_id("prefs.render_previous_geometry_budget");
|
||||
/// Open Result once after a successful GUI Start; false preserves the selected view.
|
||||
render_open_result_on_start: bool = true, PAGE_GRAPHICS => check_id("prefs.render_open_result_on_start");
|
||||
+ /// CPU snapshot boundaries; false restores powers-of-two feedback without changing the sample target.
|
||||
+ render_cpu_progressive_every_pass: bool = true, PAGE_GRAPHICS => check_id("prefs.render_cpu_progressive_every_pass");
|
||||
+ /// Interactive sampling policy; false restores its old16SPP/seed0 envelope.
|
||||
+ render_cpu_interactive_explicit_sampling: bool = true, PAGE_GRAPHICS => check_id("prefs.render_cpu_interactive_explicit_sampling");
|
||||
/// How finely the viewport tessellates curved faces and edges: `coarse`, `normal`, `fine` or
|
||||
/// `ultra` (#1287). Only the display plan the viewport draws; never the design or exports.
|
||||
display_quality: String = "normal".into(), PAGE_GRAPHICS;
|
||||
@@ -2278,10 +2282,25 @@
|
||||
PAGE_INTERFACE => interface::interface(app, ui, t),
|
||||
PAGE_DESIGN => design::show(app, ui),
|
||||
PAGE_NAVIGATION => navigation::show(app, ui, t),
|
||||
- PAGE_GRAPHICS => graphics::show(app, ui),
|
||||
+ PAGE_GRAPHICS => {
|
||||
+ graphics::show(app, ui);
|
||||
+ cpu_progressive_advanced_preferences(app, ui);
|
||||
+ }
|
||||
PAGE_SKETCH => sketch::show(app, ui),
|
||||
_ => {}
|
||||
}
|
||||
+}
|
||||
+
|
||||
+fn cpu_progressive_advanced_preferences(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
+ let title = app.tr("prefs.cpu_render_advanced").to_string();
|
||||
+ ui_kit::section(ui, "prefs_cpu_render_advanced", &title, false, |ui| {
|
||||
+ let response = setting::render_cpu_progressive_every_pass(app, ui)
|
||||
+ .on_hover_text(app.tr("prefs.render_cpu_progressive_every_pass_help"));
|
||||
+ crate::scenario::publish_target("prefs:render-cpu-progressive-every-pass", response.rect);
|
||||
+ let response = setting::render_cpu_interactive_explicit_sampling(app, ui)
|
||||
+ .on_hover_text(app.tr("prefs.render_cpu_interactive_explicit_sampling_help"));
|
||||
+ crate::scenario::publish_target("prefs:render-cpu-interactive-explicit-sampling", response.rect);
|
||||
+ });
|
||||
}
|
||||
|
||||
fn page_index(name: &str) -> Option<usize> {
|
||||
@@ -3334,6 +3353,37 @@
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
+ fn cpu_progressive_policy_preferences_default_roundtrip_validate_and_reset_independently() {
|
||||
+ let defaults = Prefs::default();
|
||||
+ assert!(defaults.render_cpu_progressive_every_pass && defaults.render_cpu_interactive_explicit_sampling);
|
||||
+ let omitted: Prefs = serde_json::from_value(json!({})).unwrap();
|
||||
+ assert!(omitted.render_cpu_progressive_every_pass && omitted.render_cpu_interactive_explicit_sampling);
|
||||
+ let mut app = SolveApp::new(Default::default(), Default::default());
|
||||
+ let document = app.session.doc.clone();
|
||||
+ let history = (app.session.revision, app.session.undo.len(), app.session.is_dirty());
|
||||
+ for key in ["render_cpu_progressive_every_pass", "render_cpu_interactive_explicit_sampling"] {
|
||||
+ let reply = super::set(&mut app, &json!({key:false})).unwrap();
|
||||
+ assert_eq!(reply[key], false);
|
||||
+ for invalid in [json!("false"), json!(0), json!(null), json!([])] {
|
||||
+ assert!(super::set(&mut app, &json!({key:invalid})).is_err());
|
||||
+ assert_eq!(serde_json::to_value(&app.preferences).unwrap()[key], false);
|
||||
+ }
|
||||
+ }
|
||||
+ let mut restored = SolveApp::new(Default::default(), Default::default());
|
||||
+ restored.load_prefs(&app.prefs());
|
||||
+ assert!(!restored.preferences.render_cpu_progressive_every_pass && !restored.preferences.render_cpu_interactive_explicit_sampling);
|
||||
+ super::defaults(&mut restored, super::PAGE_GENERAL);
|
||||
+ assert!(!restored.preferences.render_cpu_progressive_every_pass && !restored.preferences.render_cpu_interactive_explicit_sampling);
|
||||
+ let reply = super::set(&mut restored, &json!({"render_cpu_progressive_every_pass":true})).unwrap();
|
||||
+ assert_eq!(reply["render_cpu_progressive_every_pass"], true);
|
||||
+ assert_eq!(reply["render_cpu_interactive_explicit_sampling"], false);
|
||||
+ super::defaults(&mut restored, super::PAGE_GRAPHICS);
|
||||
+ assert!(restored.preferences.render_cpu_progressive_every_pass && restored.preferences.render_cpu_interactive_explicit_sampling);
|
||||
+ assert!(std::sync::Arc::ptr_eq(&document, &app.session.doc));
|
||||
+ assert_eq!(history, (app.session.revision, app.session.undo.len(), app.session.is_dirty()));
|
||||
+ }
|
||||
+
|
||||
+ #[test]
|
||||
fn render_open_result_on_start_defaults_persists_validates_and_resets() {
|
||||
assert!(Prefs::default().render_open_result_on_start);
|
||||
assert!(serde_json::from_value::<Prefs>(json!({})).unwrap().render_open_result_on_start);
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"status": "SOURCE_ONLY_NOT_ADOPTED_UNCOMPILED_UNRUN",
|
||||
"subpackage": "prefs",
|
||||
"base_source_manifest_sha256": "d38a8d946b6653864ad8918d4da662725bd24ca01b2e5aa2d3b38b47b1a7e163",
|
||||
"base_rule": "Exact per-file RAW preimages only. Not current main, not a combined candidate. LF patch is review aid; RAW candidate bytes are authoritative.",
|
||||
"files": [
|
||||
{
|
||||
"path": "assets/locales/pending/cpu-progressive-policy-preferences.json",
|
||||
"before_sha256": null,
|
||||
"before_bytes": null,
|
||||
"after_sha256": "18fc39ddb923c03eb640f02f860c8ae10d9debf8843b1b9eadb9b0e0ce397f20",
|
||||
"after_bytes": 4818
|
||||
},
|
||||
{
|
||||
"path": "crates/ui-egui/src/prefs.rs",
|
||||
"before_sha256": "b90ea63d6238bf41cb467a41efcd2b3888196e3be60f2453c635078d0933c97d",
|
||||
"before_bytes": 378635,
|
||||
"after_sha256": "b24b15f754e2ab01f5b3dc084db3fe214474669c936da244a189e708c8cb6b11",
|
||||
"after_bytes": 382245
|
||||
}
|
||||
],
|
||||
"full_CI_native_or_readiness": false,
|
||||
"candidate_whole_file_overlay_safe": true,
|
||||
"locale_successor_lineage": {
|
||||
"intermediate_before_sha256": "6d9e78b16fc3d8e015467c6512fb6401fd01b64ae871e8d643bdd61669fb154a",
|
||||
"successor_after_sha256": "18fc39ddb923c03eb640f02f860c8ae10d9debf8843b1b9eadb9b0e0ce397f20",
|
||||
"new_original_base_file": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
# Capture and Interactive compatibility WIP
|
||||
|
||||
Five exact RAW candidates, **NOT ADOPTED, UNCOMPILED, UNRUN**. Requires the core
|
||||
canonical field and the prefs package. Five new tests are written, not run.
|
||||
The transient command Value carries false only for effective progressive CPU
|
||||
requests, including Interactive derived from a Fixed final editor. Single final,
|
||||
Raster and GPU commands omit it. Legacy 16/seed0 sampling changes only an
|
||||
Interactive request copy, after original numerical validation; it does not
|
||||
weaken final admission or change saved/editor intent.
|
||||
|
||||
The Snapshot test uses frozen real command input. The UI invalidation test holds
|
||||
a real already-completed callback; it does not establish in-flight cancellation
|
||||
or physical presentation of every pass. Native CPU-supported branches and full
|
||||
validation remain pending. Four workspace-test constructors, one render test
|
||||
constructor and one thumbnail constructor receive neutral true fields only.
|
||||
|
||||
**Overlap:** this candidate render_workspace_tests.rs and fontfix both use RAW
|
||||
before 28ddafe4. This whole file does not contain the separate font correction.
|
||||
Compose exact deltas with review; copying either full candidate over the other
|
||||
would lose work. No combined candidate is supplied here.
|
||||
+372
@@ -0,0 +1,372 @@
|
||||
//! Transient CPU Interactive scheduling. The UI adapter owns visual revisions;
|
||||
//! this controller owns cancellation, not document settings or final-image export.
|
||||
use std::time::Duration;
|
||||
|
||||
use super::{CpuProgressiveOptions, ErrorCode, ImageRequest, Integrator, JobError, JobHandle, JobId, Phase, Result};
|
||||
|
||||
const SETTLE: Duration = Duration::from_millis(200);
|
||||
const MAX_EDGE: u32 = 1024;
|
||||
|
||||
/// Prepare a separate low-resolution request. Never edits the final request,
|
||||
/// changes renderer, removes optics/lights, or promises geometry admission.
|
||||
pub fn cpu_request(final_request: &ImageRequest) -> Result<ImageRequest> {
|
||||
final_request.validate_raster_request()?;
|
||||
if final_request.integrator != Integrator::Raytrace || final_request.transparent_background {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "Interactive CPU requires opaque ray tracing"));
|
||||
}
|
||||
let (width, height) = (final_request.width, final_request.height);
|
||||
if width == 0 || height == 0 {
|
||||
return Err(JobError::new(ErrorCode::InvalidRequest, "Interactive output dimensions must be positive"));
|
||||
}
|
||||
if let Some(options) = &final_request.raytrace {
|
||||
options.validate()?;
|
||||
}
|
||||
let edge = width.max(height);
|
||||
let fit = |side: u32| {
|
||||
if edge <= MAX_EDGE { side } else { ((u64::from(side) * u64::from(MAX_EDGE) + u64::from(edge) / 2) / u64::from(edge)).max(1) as u32 }
|
||||
};
|
||||
let mut request = final_request.clone();
|
||||
request.width = fit(width);
|
||||
request.height = fit(height);
|
||||
let options = request.raytrace.get_or_insert_default();
|
||||
options.primary_samples = 1;
|
||||
// Preserve explicit accumulation intent, including its deterministic seed.
|
||||
// Fixed-image callers keep the original preview default. Incompatible
|
||||
// transport remains an error rather than silently removing requested effects.
|
||||
options.progressive.get_or_insert_with(CpuProgressiveOptions::default);
|
||||
if let Some(reflections) = &mut options.reflections {
|
||||
reflections.samples = 1;
|
||||
}
|
||||
options.validate()?;
|
||||
options.budget.validate_image(request.width, request.height, options.progressive)?;
|
||||
Ok(request)
|
||||
}
|
||||
|
||||
/// Caller increments visual_revision for every camera/draft/appearance/light/HDR
|
||||
/// or output edit, even if scene_generation did not change. Never use only a CAD
|
||||
/// revision, a body name, or the selected setup name as the visual identity.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct VisualRevision {
|
||||
pub scene_generation: u64,
|
||||
pub visual_revision: u64,
|
||||
}
|
||||
|
||||
/// Issued only after the edit group settles. Private fields prevent fabricating
|
||||
/// a ticket for a newer request from a delayed capture.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct CaptureTicket {
|
||||
session: u64,
|
||||
serial: u64,
|
||||
revision: VisualRevision,
|
||||
}
|
||||
|
||||
impl CaptureTicket {
|
||||
pub fn revision(self) -> VisualRevision {
|
||||
self.revision
|
||||
}
|
||||
|
||||
/// Submit this identity to the preview host, outside the final-job registry.
|
||||
pub fn job_id(self) -> JobId {
|
||||
JobId { session: self.session, serial: self.serial, generation: self.serial }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum State {
|
||||
Off,
|
||||
Updating,
|
||||
Refining,
|
||||
Paused,
|
||||
TargetReached,
|
||||
Error,
|
||||
}
|
||||
|
||||
/// One controller per document session. No serialization, clocks, threads, scene
|
||||
/// extraction or new renderer here. Supply monotonic elapsed time from the host;
|
||||
/// this keeps both browser integration and deterministic event tests possible.
|
||||
pub struct Interactive {
|
||||
session: u64,
|
||||
serial: u64,
|
||||
revision: Option<VisualRevision>,
|
||||
changed_at: Duration,
|
||||
enabled: bool,
|
||||
paused: bool,
|
||||
final_active: bool,
|
||||
ticket: Option<CaptureTicket>,
|
||||
active: Option<JobHandle>,
|
||||
error: Option<JobError>,
|
||||
}
|
||||
|
||||
impl Interactive {
|
||||
pub fn new(session: u64) -> Self {
|
||||
Self {
|
||||
session,
|
||||
serial: 0,
|
||||
revision: None,
|
||||
changed_at: Duration::ZERO,
|
||||
enabled: false,
|
||||
paused: false,
|
||||
final_active: false,
|
||||
ticket: None,
|
||||
active: None,
|
||||
error: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn cancel(&mut self) -> Result<()> {
|
||||
// Invalidate first, including when a poisoned host refuses cancellation.
|
||||
self.ticket = None;
|
||||
if let Some(job) = self.active.take() {
|
||||
job.cancel()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Explicit user activation. Merely entering Render must not call this.
|
||||
pub fn enable(&mut self, revision: VisualRevision, now: Duration) -> Result<()> {
|
||||
self.cancel()?;
|
||||
self.enabled = true;
|
||||
self.paused = false;
|
||||
self.error = None;
|
||||
self.revision = Some(revision);
|
||||
self.changed_at = now;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Workspace/document departure uses disable; manually started final jobs
|
||||
/// are deliberately outside this controller and are never cancelled here.
|
||||
pub fn disable(&mut self) -> Result<()> {
|
||||
self.enabled = false;
|
||||
self.paused = false;
|
||||
self.error = None;
|
||||
self.cancel()
|
||||
}
|
||||
|
||||
pub fn edit(&mut self, revision: VisualRevision, now: Duration) -> Result<()> {
|
||||
if self.revision != Some(revision) {
|
||||
self.revision = Some(revision);
|
||||
self.changed_at = now;
|
||||
self.error = None;
|
||||
self.cancel()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A view may retain an identified immutable PNG before pausing, but must
|
||||
/// label it paused/stale. It is never a current or exportable final image.
|
||||
pub fn pause(&mut self) -> Result<()> {
|
||||
self.paused = true;
|
||||
self.cancel()
|
||||
}
|
||||
|
||||
pub fn resume(&mut self, now: Duration) -> Result<()> {
|
||||
self.cancel()?;
|
||||
self.paused = false;
|
||||
self.error = None;
|
||||
self.changed_at = now;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn set_final_active(&mut self, active: bool, now: Duration) -> Result<()> {
|
||||
if self.final_active != active {
|
||||
self.final_active = active;
|
||||
self.changed_at = now;
|
||||
self.cancel()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// At most one unacknowledged capture; no queue of obsolete requests.
|
||||
pub fn capture(&mut self, now: Duration) -> Result<Option<CaptureTicket>> {
|
||||
if !self.enabled
|
||||
|| self.paused
|
||||
|| self.final_active
|
||||
|| self.ticket.is_some()
|
||||
|| self.error.is_some()
|
||||
|| now.checked_sub(self.changed_at).is_none_or(|elapsed| elapsed < SETTLE)
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let Some(revision) = self.revision else { return Ok(None) };
|
||||
self.serial = self.serial.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "Interactive capture identity exhausted"))?;
|
||||
let ticket = CaptureTicket { session: self.session, serial: self.serial, revision };
|
||||
self.ticket = Some(ticket);
|
||||
Ok(Some(ticket))
|
||||
}
|
||||
|
||||
/// Recheck before expensive capture/admission, including after a worker delay.
|
||||
/// A ticket is not permission to prepare an obsolete or already adopted job.
|
||||
pub fn accepts_capture(&self, ticket: CaptureTicket) -> bool {
|
||||
self.enabled && !self.paused && !self.final_active && self.error.is_none() && self.ticket == Some(ticket) && self.active.is_none()
|
||||
}
|
||||
|
||||
/// Attach an admitted preview-only job after immutable capture. Delayed jobs
|
||||
/// are cancelled, including a previous ticket for the same visual revision.
|
||||
/// Use a separate engine job session/registry from final-image export.
|
||||
pub fn attach(&mut self, ticket: CaptureTicket, job: JobHandle) -> Result<bool> {
|
||||
// A misrouted callback must never cancel another document's work or a
|
||||
// manual final job. Only our dedicated preview session is ours to stop.
|
||||
if job.id().session != self.session {
|
||||
self.capture_failed(ticket, JobError::new(ErrorCode::WrongOwner, "Interactive job belongs to another session"));
|
||||
return Ok(false);
|
||||
}
|
||||
if self.ticket != Some(ticket) || ticket.session != self.session {
|
||||
// Protect an admitted current capture even before acknowledgement.
|
||||
// Once accepted, only the same record (not merely its JobId) is ours.
|
||||
let current = match &self.active {
|
||||
Some(active) => active.same_record(&job),
|
||||
None => self.ticket.is_some_and(|ticket| ticket.job_id() == job.id()),
|
||||
};
|
||||
if !current {
|
||||
job.cancel()?;
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
let status = job.status()?;
|
||||
if status.job != ticket.job_id() || status.scene_generation != ticket.revision.scene_generation {
|
||||
job.cancel()?;
|
||||
self.capture_failed(ticket, JobError::new(ErrorCode::WrongOwner, "Interactive job capture identity mismatch"));
|
||||
return Ok(false);
|
||||
}
|
||||
if status.request.integrator != Integrator::Raytrace || status.request.raytrace.as_ref().is_none_or(|options| options.progressive.is_none()) {
|
||||
job.cancel()?;
|
||||
self.capture_failed(ticket, JobError::new(ErrorCode::InvalidRequest, "Interactive requires a CPU progressive job"));
|
||||
return Ok(false);
|
||||
}
|
||||
// A ticket is acknowledged exactly once, even if the same capture is
|
||||
// delivered twice while an earlier attached job is still running.
|
||||
if self.active.is_some() {
|
||||
if self.active.as_ref().is_none_or(|active| !active.same_record(&job)) {
|
||||
job.cancel()?;
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
self.active = Some(job);
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub fn capture_failed(&mut self, ticket: CaptureTicket, error: JobError) {
|
||||
if self.ticket == Some(ticket) && self.active.is_none() {
|
||||
self.ticket = None;
|
||||
self.error = Some(error);
|
||||
}
|
||||
}
|
||||
|
||||
/// Access only the current capture. The adapter reads checkpoint/final bytes
|
||||
/// through this handle, displaying both as Interactive/provisional content.
|
||||
pub fn current(&self) -> Option<&JobHandle> {
|
||||
self.active.as_ref()
|
||||
}
|
||||
|
||||
pub fn error(&self) -> Option<&JobError> {
|
||||
self.error.as_ref()
|
||||
}
|
||||
|
||||
pub fn state(&self) -> Result<State> {
|
||||
if !self.enabled {
|
||||
return Ok(State::Off);
|
||||
}
|
||||
if self.paused || self.final_active {
|
||||
return Ok(State::Paused);
|
||||
}
|
||||
if self.error.is_some() {
|
||||
return Ok(State::Error);
|
||||
}
|
||||
if let Some(job) = &self.active {
|
||||
return Ok(match job.status()?.progress.phase {
|
||||
Phase::Completed => State::TargetReached,
|
||||
Phase::Cancelled | Phase::Failed => State::Error,
|
||||
_ => State::Refining,
|
||||
});
|
||||
}
|
||||
Ok(State::Updating)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Interactive {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::job::{CpuBudget, RaytraceOptions};
|
||||
|
||||
fn request(options: RaytraceOptions) -> ImageRequest {
|
||||
ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
integrator: Integrator::Raytrace,
|
||||
raytrace: Some(options),
|
||||
textures: None,
|
||||
environment: None,
|
||||
camera: Default::default(),
|
||||
width: 81,
|
||||
height: 53,
|
||||
background: [40, 80, 120],
|
||||
transparent_background: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_progressive_target_and_seed_survive_interactive_conversion() {
|
||||
for (budget, samples) in [(CpuBudget::Compact, 31), (CpuBudget::Studio, 997), (CpuBudget::Workstation, 1_048_576)] {
|
||||
let mut source = request(RaytraceOptions {
|
||||
budget,
|
||||
progressive: Some(CpuProgressiveOptions { samples_per_pixel: samples, seed: u32::MAX }),
|
||||
primary_samples: 1,
|
||||
exposure_ev: -2.0,
|
||||
shadows: false,
|
||||
..Default::default()
|
||||
});
|
||||
// The high target still obeys P*SPP admission; no implicit resize/profile.
|
||||
if budget == CpuBudget::Workstation {
|
||||
source.width = 3840;
|
||||
source.height = 1;
|
||||
}
|
||||
let before = serde_json::to_value(&source).unwrap();
|
||||
let converted = cpu_request(&source).unwrap();
|
||||
let mut expected = source.clone();
|
||||
if budget == CpuBudget::Workstation {
|
||||
expected.width = 1024;
|
||||
}
|
||||
assert_eq!(serde_json::to_value(converted).unwrap(), serde_json::to_value(expected).unwrap());
|
||||
assert_eq!(serde_json::to_value(&source).unwrap(), before);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_interactive_keeps_original_default_and_invalid_explicit_intent_refuses() {
|
||||
let source = request(RaytraceOptions { primary_samples: 16, ..Default::default() });
|
||||
let converted = cpu_request(&source).unwrap();
|
||||
let options = converted.raytrace.unwrap();
|
||||
assert_eq!(options.progressive, Some(CpuProgressiveOptions { samples_per_pixel: 16, seed: 0 }));
|
||||
assert_eq!(options.primary_samples, 1);
|
||||
assert!(source.raytrace.as_ref().unwrap().progressive.is_none());
|
||||
for (budget, samples) in [(CpuBudget::Compact, 65), (CpuBudget::Studio, 1025), (CpuBudget::Workstation, 1_048_577)] {
|
||||
let invalid = request(RaytraceOptions {
|
||||
budget,
|
||||
primary_samples: 1,
|
||||
progressive: Some(CpuProgressiveOptions { samples_per_pixel: samples, seed: 741 }),
|
||||
..Default::default()
|
||||
});
|
||||
let before = serde_json::to_value(&invalid).unwrap();
|
||||
assert!(cpu_request(&invalid).is_err());
|
||||
assert_eq!(serde_json::to_value(&invalid).unwrap(), before);
|
||||
}
|
||||
let mut over_work = request(RaytraceOptions {
|
||||
primary_samples: 1,
|
||||
progressive: Some(CpuProgressiveOptions { samples_per_pixel: 64, seed: 741 }),
|
||||
..Default::default()
|
||||
});
|
||||
over_work.width = 1024;
|
||||
over_work.height = 1024;
|
||||
assert!(cpu_request(&over_work).is_err(), "do not reduce the explicit target to fit the profile");
|
||||
}
|
||||
}
|
||||
+2516
File diff suppressed because it is too large.
Load diff
+870
@@ -0,0 +1,870 @@
|
||||
//! Transient CPU image controls; engine commands own file capture and admission.
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_engine::render::job::{CpuBudget, CpuDielectricTransport, RaytraceEnvironmentOptions, ReflectionBody, ReflectionMode};
|
||||
|
||||
use super::hdr;
|
||||
use crate::{SolveApp, ui_kit};
|
||||
|
||||
pub(super) fn validate_progressive_image(app: &SolveApp) -> Result<(), String> {
|
||||
if app.render_workspace.view.method == super::ImageMethod::CpuRaytrace {
|
||||
let view = &app.render_workspace.view;
|
||||
view.raytrace.budget.validate_image(view.draft.width, view.draft.height, view.raytrace.progressive).map_err(|error| error.to_string())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn image_limits(app: &SolveApp) -> solidcraft_engine::render::RenderLimits {
|
||||
if app.render_workspace.view.method == super::ImageMethod::GpuRaytrace {
|
||||
return solidcraft_engine::render::job::GPU_PATH_LIMITS;
|
||||
}
|
||||
if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace {
|
||||
return Default::default();
|
||||
}
|
||||
let options = &app.render_workspace.view.raytrace;
|
||||
let mut limits = options.budget.image_limits(options.progressive.is_some());
|
||||
if let Some(progressive) = options.progressive {
|
||||
limits.max_pixels = limits.max_pixels.min(options.budget.limits().max_camera_samples / u64::from(progressive.samples_per_pixel.max(1)));
|
||||
}
|
||||
limits
|
||||
}
|
||||
|
||||
fn budget_key(budget: CpuBudget) -> &'static str {
|
||||
match budget {
|
||||
CpuBudget::Compact => "render.children.compact",
|
||||
CpuBudget::Studio => "render.children.studio",
|
||||
CpuBudget::Workstation => "render.children.workstation",
|
||||
}
|
||||
}
|
||||
|
||||
fn budget_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
let budgets = CpuBudget::ALL;
|
||||
let mut selected = budgets.iter().position(|b| *b == app.render_workspace.view.raytrace.budget).unwrap_or(0);
|
||||
let labels = budgets.map(|b| app.tr(budget_key(b)).to_string());
|
||||
let response = ui.scope(|ui| {
|
||||
ui_kit::segmented(
|
||||
ui,
|
||||
&mut selected,
|
||||
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
|
||||
ui_kit::Segments {
|
||||
compact: true,
|
||||
targets: &["render.cpu_budget_compact", "render.cpu_budget_studio", "render.cpu_budget_workstation"],
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
});
|
||||
crate::scenario::publish_rect("render:cpu-budget", response.response.rect);
|
||||
if response.inner
|
||||
&& let Some(budget) = budgets.get(selected)
|
||||
{
|
||||
app.render_workspace.view.raytrace.budget = *budget;
|
||||
app.render_workspace.view.dirty = true;
|
||||
}
|
||||
let limits = app.render_workspace.view.raytrace.budget.limits();
|
||||
let note = format!(
|
||||
"{}: {:.2} GiB · {}: {} · {}: {} · {}: {}. {}",
|
||||
app.tr("render.cpu_budget_memory"),
|
||||
limits.max_job_bytes as f64 / 1_073_741_824.0,
|
||||
app.tr("render.cpu_budget_triangles"),
|
||||
limits.max_triangles,
|
||||
app.tr("render.cpu_budget_bodies"),
|
||||
limits.max_bodies,
|
||||
app.tr("render.cpu_progressive_spp"),
|
||||
limits.max_samples_per_pixel,
|
||||
app.tr("render.cpu_budget_not_guarantee")
|
||||
);
|
||||
ui_kit::text(ui, ¬e, ui_kit::Text::Note("render.cpu_budget_help"));
|
||||
}
|
||||
fn set_progressive(app: &mut SolveApp, enabled: bool) {
|
||||
let options = &mut app.render_workspace.view.raytrace;
|
||||
if enabled {
|
||||
options.progressive.get_or_insert_default();
|
||||
options.primary_samples = 1;
|
||||
} else {
|
||||
options.progressive = None;
|
||||
}
|
||||
app.render_workspace.view.dirty = true;
|
||||
}
|
||||
|
||||
/// The saved CPU choice is independent of sampling, profiles and material bindings.
|
||||
fn set_dielectric_transport(app: &mut SolveApp, policy: CpuDielectricTransport) -> bool {
|
||||
let view = &mut app.render_workspace.view;
|
||||
if view.raytrace.dielectric_transport == policy {
|
||||
return false;
|
||||
}
|
||||
view.raytrace.dielectric_transport = policy;
|
||||
view.dirty = true;
|
||||
true
|
||||
}
|
||||
|
||||
fn dielectric_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
let mut selected = usize::from(app.render_workspace.view.raytrace.dielectric_transport == CpuDielectricTransport::StrictTir);
|
||||
let labels = [app.tr("render.cpu_glass_standard").to_string(), app.tr("render.cpu_glass_continue").to_string()];
|
||||
let label = app.tr("render.cpu_glass_label").to_string();
|
||||
if ui_kit::row(ui, &label, |ui| {
|
||||
ui_kit::segmented(
|
||||
ui,
|
||||
&mut selected,
|
||||
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
|
||||
ui_kit::Segments { compact: true, targets: &["render:cpu-glass-standard", "render:cpu-glass-continue"], ..Default::default() },
|
||||
)
|
||||
}) {
|
||||
set_dielectric_transport(app, if selected == 1 { CpuDielectricTransport::StrictTir } else { CpuDielectricTransport::LegacyBounded });
|
||||
}
|
||||
ui_kit::text(ui, app.tr("render.cpu_glass_help"), ui_kit::Text::Note("render.cpu_glass_help"));
|
||||
}
|
||||
|
||||
pub(super) fn progressive_controls(app: &mut SolveApp, ui: &mut egui::Ui) -> bool {
|
||||
budget_controls(app, ui);
|
||||
dielectric_controls(app, ui);
|
||||
let mut selected = usize::from(app.render_workspace.view.raytrace.progressive.is_some());
|
||||
let labels = [app.tr("render.children.single_image").to_string(), app.tr("render.cpu_progressive").to_string()];
|
||||
let response = ui.scope(|ui| {
|
||||
ui_kit::row(ui, app.tr("render.children.sampling"), |ui| {
|
||||
ui_kit::segmented(
|
||||
ui,
|
||||
&mut selected,
|
||||
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
|
||||
ui_kit::Segments { compact: true, targets: &["render:cpu-fixed", "render:cpu-progressive"], ..Default::default() },
|
||||
)
|
||||
})
|
||||
});
|
||||
crate::scenario::publish_target("render:cpu-sampling", response.response.rect);
|
||||
if response.inner {
|
||||
set_progressive(app, selected == 1);
|
||||
}
|
||||
let enabled = app.render_workspace.view.raytrace.progressive.is_some();
|
||||
let mut options = app.render_workspace.view.raytrace.progressive.unwrap_or_default();
|
||||
if !enabled {
|
||||
ui_kit::text(ui, app.tr("render.children.progressive_reason"), ui_kit::Text::Note("render.children.progressive_reason"));
|
||||
}
|
||||
ui.add_enabled_ui(enabled, |ui| {
|
||||
let response = ui_kit::row(ui, app.tr("render.cpu_progressive_spp"), |ui| {
|
||||
ui_kit::number_field(ui, &mut options.samples_per_pixel, 1..=solidcraft_engine::render::job::MAX_CPU_SAMPLES_PER_PIXEL, 1.0, "")
|
||||
});
|
||||
app.render_workspace.view.dirty |= response.changed();
|
||||
crate::scenario::publish_target("render:cpu-spp", response.rect);
|
||||
let response =
|
||||
ui_kit::row(ui, app.tr("render.cpu_progressive_seed"), |ui| ui_kit::number_field(ui, &mut options.seed, 0..=u32::MAX, 1.0, ""));
|
||||
app.render_workspace.view.dirty |= response.changed();
|
||||
crate::scenario::publish_target("render:cpu-seed", response.rect);
|
||||
});
|
||||
if enabled {
|
||||
app.render_workspace.view.raytrace.progressive = Some(options);
|
||||
}
|
||||
ui_kit::text(ui, app.tr("render.cpu_progressive_help"), ui_kit::Text::Note("render.cpu_progressive_help"));
|
||||
enabled
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub(super) enum Environment {
|
||||
#[default]
|
||||
None,
|
||||
Constant,
|
||||
Hdr,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) struct View {
|
||||
#[cfg(test)]
|
||||
pub selected_body: Option<String>,
|
||||
#[cfg(test)]
|
||||
pub body_filter: String,
|
||||
pub environment: Environment,
|
||||
pub hdr: hdr::Input,
|
||||
pub rotation_rad: f64,
|
||||
pub intensity: f64,
|
||||
pub samples: u32,
|
||||
pub color: [f64; 3],
|
||||
pub checked: Option<Checked>,
|
||||
/// Request-local, explicitly selected certified-box nesting; never inferred from GPU state.
|
||||
pub nested_media: bool,
|
||||
bindings: std::collections::BTreeMap<String, Binding>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
struct Target {
|
||||
ordinal: usize,
|
||||
feature: u64,
|
||||
component: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Binding {
|
||||
target: Target,
|
||||
revision: u64,
|
||||
document: std::sync::Weak<solidcraft_engine::doc::Document>,
|
||||
// Interactive may follow appearance/render-only edits only while this exact
|
||||
// evaluated world survives in the same open document. Weak ownership avoids
|
||||
// retaining old geometry and prevents pointer reuse after the world drops.
|
||||
session_uid: u64,
|
||||
world: std::sync::Weak<solidcraft_engine::doc::ModelState>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) struct Checked {
|
||||
pub request: Value,
|
||||
pub revision: u64,
|
||||
pub environment: Value,
|
||||
document: std::sync::Weak<solidcraft_engine::doc::Document>,
|
||||
}
|
||||
|
||||
impl Default for View {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
#[cfg(test)]
|
||||
selected_body: None,
|
||||
#[cfg(test)]
|
||||
body_filter: String::new(),
|
||||
environment: Environment::None,
|
||||
hdr: hdr::Input::default(),
|
||||
rotation_rad: 0.0,
|
||||
intensity: 1.0,
|
||||
samples: 16,
|
||||
color: [1.0; 3],
|
||||
checked: None,
|
||||
nested_media: false,
|
||||
bindings: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn valid_name(name: &str) -> bool {
|
||||
!name.is_empty() && name.len() <= 128 && !name.chars().any(char::is_control)
|
||||
}
|
||||
|
||||
fn target(app: &SolveApp, name: &str) -> Option<Target> {
|
||||
if !valid_name(name) || app.session.model.is_stale() {
|
||||
return None;
|
||||
}
|
||||
let world = app.session.world_state();
|
||||
let mut matches = world.bodies.iter().filter(|body| app.session.body_visible(&body.name)).enumerate().filter(|(_, body)| body.name == name);
|
||||
let (ordinal, body) = matches.next()?;
|
||||
if matches.next().is_some() {
|
||||
return None;
|
||||
}
|
||||
Some(Target { ordinal, feature: body.feature, component: body.component })
|
||||
}
|
||||
|
||||
fn unique_visible_body(app: &SolveApp, name: &str) -> bool {
|
||||
target(app, name).is_some()
|
||||
}
|
||||
|
||||
fn binding_current(app: &SolveApp, name: &str) -> bool {
|
||||
app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| {
|
||||
binding.revision == app.session.revision
|
||||
&& std::sync::Weak::ptr_eq(&binding.document, &std::sync::Arc::downgrade(&app.session.doc))
|
||||
&& target(app, name).as_ref() == Some(&binding.target)
|
||||
})
|
||||
}
|
||||
|
||||
// Unlike final Check/Start, Interactive may refresh harmless appearance/render
|
||||
// edits. The engine retains the exact world Arc for those edits (refresh_render).
|
||||
// No geometry extraction, cold meshing, name-only rebinding or revision stamping.
|
||||
fn binding_interactive_world_current(app: &SolveApp, name: &str) -> bool {
|
||||
app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| {
|
||||
binding.session_uid == app.session.uid
|
||||
&& !app.session.model.is_stale()
|
||||
&& app
|
||||
.session
|
||||
.interactive_cached_world_state()
|
||||
.is_some_and(|world| std::sync::Weak::ptr_eq(&binding.world, &std::sync::Arc::downgrade(&world)))
|
||||
})
|
||||
}
|
||||
|
||||
fn binding_interactive_current(app: &SolveApp, name: &str) -> bool {
|
||||
binding_interactive_world_current(app, name)
|
||||
&& app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| target(app, name).as_ref() == Some(&binding.target))
|
||||
}
|
||||
|
||||
pub(super) fn revalidate(app: &mut SolveApp, name: &str) -> Result<(), String> {
|
||||
let current = target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?;
|
||||
if app.render_workspace.view.cpu.bindings.get(name).is_none_or(|binding| binding.target != current) {
|
||||
return Err(app.tr("render.cpu_body_missing").to_string());
|
||||
}
|
||||
let revision = app.session.revision;
|
||||
let document = std::sync::Arc::downgrade(&app.session.doc);
|
||||
let world = std::sync::Arc::downgrade(&app.session.world_state());
|
||||
let session_uid = app.session.uid;
|
||||
if let Some(binding) = app.render_workspace.view.cpu.bindings.get_mut(name) {
|
||||
binding.revision = revision;
|
||||
binding.document = document;
|
||||
binding.session_uid = session_uid;
|
||||
binding.world = world;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A removed, hidden or ambiguous body never silently becomes a different target.
|
||||
pub(super) fn set_reflection(app: &mut SolveApp, name: &str, mode: Option<ReflectionMode>) -> Result<(), String> {
|
||||
let selected = if mode.is_some() { Some(target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?) } else { None };
|
||||
// Changing the mode of an existing row is not a new body selection. Only an
|
||||
// explicit confirmation of the same target, or Off followed by Add, may
|
||||
// establish a fresh binding after the document or body identity changes.
|
||||
if mode.is_some()
|
||||
&& app.render_workspace.view.raytrace.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| entry.body == name))
|
||||
&& !binding_current(app, name)
|
||||
{
|
||||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||||
}
|
||||
let message = app.tr("render.cpu_reflection_limit").to_string();
|
||||
let options = &mut app.render_workspace.view.raytrace;
|
||||
if let Some(mode) = mode {
|
||||
let mut reflections = options.reflections.clone().unwrap_or_default();
|
||||
if let Some(entry) = reflections.bodies.iter_mut().find(|entry| entry.body == name) {
|
||||
entry.mode = mode;
|
||||
} else {
|
||||
if reflections.bodies.len() >= 64 {
|
||||
return Err(message);
|
||||
}
|
||||
reflections.bodies.try_reserve_exact(1).map_err(|_| message.clone())?;
|
||||
if reflections.bodies.capacity() > 64 {
|
||||
return Err(message);
|
||||
}
|
||||
reflections.bodies.push(ReflectionBody { body: name.to_string(), mode });
|
||||
}
|
||||
options.reflections = Some(reflections);
|
||||
} else if let Some(reflections) = &mut options.reflections {
|
||||
reflections.bodies.retain(|entry| entry.body != name);
|
||||
if reflections.bodies.is_empty() {
|
||||
options.reflections = None;
|
||||
}
|
||||
}
|
||||
if let Some(target) = selected {
|
||||
app.render_workspace.view.cpu.bindings.insert(
|
||||
name.to_string(),
|
||||
Binding {
|
||||
target,
|
||||
revision: app.session.revision,
|
||||
document: std::sync::Arc::downgrade(&app.session.doc),
|
||||
session_uid: app.session.uid,
|
||||
world: std::sync::Arc::downgrade(&app.session.world_state()),
|
||||
},
|
||||
);
|
||||
} else {
|
||||
app.render_workspace.view.cpu.bindings.remove(name);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Shared by the parent Check and Start builder. This does not read an HDR file.
|
||||
pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> {
|
||||
params_with_binding_policy(app, params, binding_current)
|
||||
}
|
||||
|
||||
/// Interactive-only wire lowering. This does not requalify final Check/Start,
|
||||
/// change a stored binding or read an HDR file; the engine still captures and admits it.
|
||||
pub(super) fn params_interactive(app: &SolveApp, params: &mut Value) -> Result<(), String> {
|
||||
// runtime_image_request composes the explicit material DTO immediately
|
||||
// after these numerical controls, exactly once. The engine then converts
|
||||
// the separate Interactive request to progressive sampling and admits its
|
||||
// complete optics; a Fixed editor never licenses dropping that intent.
|
||||
// Refuse unproved bound worlds before shared lowering checks visibility via
|
||||
// target()/world_state(). Empty reflections never require a warm world.
|
||||
if app
|
||||
.render_workspace
|
||||
.view
|
||||
.raytrace
|
||||
.reflections
|
||||
.as_ref()
|
||||
.is_some_and(|r| r.bodies.iter().any(|entry| !binding_interactive_world_current(app, &entry.body)))
|
||||
{
|
||||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||||
}
|
||||
params_with_binding_policy(app, params, binding_interactive_current)?;
|
||||
if !app.preferences.render_cpu_interactive_explicit_sampling {
|
||||
let options = params
|
||||
.get_mut("raytrace")
|
||||
.and_then(Value::as_object_mut)
|
||||
.ok_or_else(|| app.tr("render.error_provisional_identity").to_string())?;
|
||||
// The original request was validated above. Only an explicit progressive
|
||||
// object is replaced; Fixed stays Fixed until the engine's existing
|
||||
// preview conversion applies primary/reflection1 and the fallback16/0.
|
||||
if options.get("progressive").is_some_and(|value| !value.is_null()) {
|
||||
options.insert("progressive".into(), json!(solidcraft_engine::render::job::CpuProgressiveOptions::default()));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn params_with_binding_policy(app: &SolveApp, params: &mut Value, current: fn(&SolveApp, &str) -> bool) -> Result<(), String> {
|
||||
let base = &app.render_workspace.view.raytrace;
|
||||
if base.anisotropic_faces.iter().any(Option::is_some)
|
||||
|| !base.dielectrics.is_empty()
|
||||
|| base.environment.is_some()
|
||||
|| base.surface_effects.is_some()
|
||||
|| base.emissions.is_some()
|
||||
{
|
||||
return Err(app.tr("render.cpu_options_pending").to_string());
|
||||
}
|
||||
if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !unique_visible_body(app, &entry.body))) {
|
||||
return Err(app.tr("render.cpu_body_missing").to_string());
|
||||
}
|
||||
if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !current(app, &entry.body))) {
|
||||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||||
}
|
||||
let view = &app.render_workspace.view.cpu;
|
||||
let mut options = base.clone();
|
||||
if options.area_samples.is_some_and(|n| !matches!(n, 1 | 4 | 16 | 64)) {
|
||||
return Err(crate::i18n::tr("render.error_area_samples").into());
|
||||
}
|
||||
if options.area_lights.as_ref().is_none_or(Vec::is_empty) {
|
||||
options.area_samples = None;
|
||||
options.seed = None;
|
||||
}
|
||||
options.exposure_ev = app.render_workspace.view.draft.exposure_ev;
|
||||
// Runtime CPU requests keep the same single saved EV authority as typed jobs.
|
||||
params["settings"]["exposure_ev"] = json!(0.0);
|
||||
if view.environment != Environment::None {
|
||||
if !view.intensity.is_finite() || !(0.0..=64.0).contains(&view.intensity) {
|
||||
return Err(app.tr("render.cpu_environment_bounds").to_string());
|
||||
}
|
||||
match view.environment {
|
||||
Environment::Constant => options.environment = Some(RaytraceEnvironmentOptions { color: view.color, intensity: view.intensity }),
|
||||
Environment::Hdr => {
|
||||
if !view.rotation_rad.is_finite() || view.rotation_rad.abs() > 1e6 || !matches!(view.samples, 1 | 4 | 16 | 64) {
|
||||
return Err(app.tr("render.cpu_environment_bounds").to_string());
|
||||
}
|
||||
let mut environment = hdr::request(app, hdr::Target::Cpu)?;
|
||||
environment["rotation_radians"] = json!(view.rotation_rad);
|
||||
environment["intensity"] = json!(view.intensity);
|
||||
environment["samples"] = json!(view.samples);
|
||||
params["environment"] = environment;
|
||||
}
|
||||
Environment::None => {}
|
||||
}
|
||||
}
|
||||
options.validate().map_err(|error| error.to_string())?;
|
||||
params["integrator"] = json!("raytrace");
|
||||
params["raytrace"] = json!(options);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
for (id, key, section) in [
|
||||
("render_cpu_reflections", "render.cpu_reflections", 0),
|
||||
("render_cpu_environment", "render.cpu_environment", 1),
|
||||
("render_cpu_lights", "render.cpu_lights", 2),
|
||||
] {
|
||||
let title = app.tr(key).to_string();
|
||||
ui_kit::section(ui, id, &title, false, |ui| match section {
|
||||
0 => reflection_controls(app, ui),
|
||||
1 => environment_controls(app, ui),
|
||||
_ => light_controls(app, ui),
|
||||
});
|
||||
}
|
||||
ui.small(app.tr("render.cpu_runtime_help"));
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn reflection_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
ui.small(app.tr("render.cpu_reflection_help"));
|
||||
let entries = app.render_workspace.view.raytrace.reflections.as_ref().map(|r| r.bodies.clone()).unwrap_or_default();
|
||||
for entry in entries {
|
||||
ui.label(&entry.body);
|
||||
if !binding_current(app, &entry.body) {
|
||||
ui.small(app.tr("render.cpu_binding_stale"));
|
||||
if ui_kit::button(ui, app.tr("render.cpu_binding_confirm"), ui_kit::Button::Normal).clicked()
|
||||
&& let Err(error) = revalidate(app, &entry.body)
|
||||
{
|
||||
app.set_status(error, true);
|
||||
}
|
||||
}
|
||||
let selected = match entry.mode {
|
||||
ReflectionMode::Mirror => "render.cpu_reflection_mirror",
|
||||
ReflectionMode::RoughSpecular => "render.cpu_reflection_rough",
|
||||
};
|
||||
let label = app.tr(selected).to_string();
|
||||
let mode_control = ui_kit::dropdown_menu(ui, ("cpu_reflection_mode", &entry.body), &label, |ui| {
|
||||
for (mode, key) in [
|
||||
(None, "render.cpu_reflection_off"),
|
||||
(Some(ReflectionMode::Mirror), "render.cpu_reflection_mirror"),
|
||||
(Some(ReflectionMode::RoughSpecular), "render.cpu_reflection_rough"),
|
||||
] {
|
||||
let enabled = mode.is_none() || binding_current(app, &entry.body);
|
||||
if ui.add_enabled_ui(enabled, |ui| ui_kit::list_picker(ui, key, app.tr(key), mode == Some(entry.mode))).inner.clicked() {
|
||||
if let Err(error) = set_reflection(app, &entry.body, mode) {
|
||||
app.set_status(error, true);
|
||||
}
|
||||
ui.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
crate::scenario::publish_handle(&format!("render:cpu-reflection-mode:{}", entry.body), mode_control.rect.center());
|
||||
}
|
||||
let hint = app.tr("render.cpu_body_filter").to_string();
|
||||
ui_kit::bounded_cell_editor(ui, ui.id().with("cpu_body_filter"), &mut app.render_workspace.view.cpu.body_filter, &hint, false, 128);
|
||||
let selected = app.render_workspace.view.cpu.selected_body.clone();
|
||||
let label = selected.clone().unwrap_or_else(|| app.tr("render.cpu_body_choose").to_string());
|
||||
let world = app.session.world_state();
|
||||
let filter = app.render_workspace.view.cpu.body_filter.to_lowercase();
|
||||
let candidates: Vec<_> = world
|
||||
.bodies
|
||||
.iter()
|
||||
.filter(|body| app.session.body_visible(&body.name) && body.name.to_lowercase().contains(&filter))
|
||||
.take(257)
|
||||
.map(|body| body.name.as_str())
|
||||
.collect();
|
||||
let dropdown = ui_kit::dropdown_menu(ui, "cpu_reflection_body", &label, |ui| {
|
||||
egui::ScrollArea::vertical().max_height(240.0).show(ui, |ui| {
|
||||
for (shown, name) in candidates.iter().enumerate() {
|
||||
if shown == 256 {
|
||||
ui.small(app.tr("render.cpu_body_filter_more"));
|
||||
break;
|
||||
}
|
||||
let response =
|
||||
ui.add_enabled_ui(valid_name(name), |ui| ui_kit::list_picker(ui, name, name, selected.as_deref() == Some(*name))).inner;
|
||||
if response.clicked() {
|
||||
app.render_workspace.view.cpu.selected_body = Some((*name).to_string());
|
||||
ui.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
crate::scenario::publish_handle("render:cpu-reflection-body", dropdown.rect.center());
|
||||
let can_add = selected.as_ref().is_some_and(|name| unique_visible_body(app, name))
|
||||
&& app.render_workspace.view.raytrace.reflections.as_ref().is_none_or(|r| r.bodies.len() < 64);
|
||||
let add = ui_kit::button(ui, app.tr("render.cpu_reflection_add"), ui_kit::Button::Enabled(can_add));
|
||||
crate::scenario::publish_handle("render:cpu-reflection-add", add.rect.center());
|
||||
if add.clicked()
|
||||
&& let Some(name) = selected
|
||||
&& let Err(error) = set_reflection(app, &name, Some(ReflectionMode::RoughSpecular))
|
||||
{
|
||||
app.set_status(error, true);
|
||||
}
|
||||
reflection_sampling_controls(app, ui);
|
||||
}
|
||||
|
||||
/// Existing global reflection budget, shared during the Sampling-editor migration.
|
||||
pub(super) fn reflection_sampling_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
let depth = app.tr("render.cpu_reflection_depth").to_string();
|
||||
let samples = app.tr("render.cpu_reflection_samples").to_string();
|
||||
if let Some(reflections) = &mut app.render_workspace.view.raytrace.reflections {
|
||||
ui_kit::row(ui, &depth, |ui| ui_kit::number_field(ui, &mut reflections.max_bounces, 1..=8, 1.0, ""));
|
||||
ui_kit::row(ui, &samples, |ui| ui_kit::number_field(ui, &mut reflections.samples, 1..=64, 1.0, ""));
|
||||
} else {
|
||||
ui.small(app.tr("render.cpu_reflection_empty"));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn environment_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
let selected = app.render_workspace.view.cpu.environment;
|
||||
let key = match selected {
|
||||
Environment::None => "render.cpu_environment_none",
|
||||
Environment::Constant => "render.cpu_environment_constant",
|
||||
Environment::Hdr => "render.studio_hdr",
|
||||
};
|
||||
let label = app.tr(key).to_string();
|
||||
ui_kit::dropdown_menu(ui, "cpu_environment_kind", &label, |ui| {
|
||||
for (value, key) in [
|
||||
(Environment::None, "render.cpu_environment_none"),
|
||||
(Environment::Constant, "render.cpu_environment_constant"),
|
||||
(Environment::Hdr, "render.studio_hdr"),
|
||||
] {
|
||||
if ui_kit::list_picker(ui, key, app.tr(key), value == selected).clicked() {
|
||||
app.render_workspace.view.cpu.environment = value;
|
||||
ui.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
if app.render_workspace.view.cpu.environment == Environment::None {
|
||||
return;
|
||||
}
|
||||
if app.render_workspace.view.cpu.environment == Environment::Constant {
|
||||
let color = app.tr("render.cpu_linear_color").to_string();
|
||||
vector(ui, &color, &mut app.render_workspace.view.cpu.color, 0.0..=1.0, 0.01, "");
|
||||
ui.small(app.tr("render.cpu_constant_help"));
|
||||
} else {
|
||||
hdr::controls(app, ui, hdr::Target::Cpu);
|
||||
ui.small(app.tr("render.cpu_hdr_help"));
|
||||
ui.label(app.tr("render.studio_rotation"));
|
||||
let mut degrees = app.render_workspace.view.cpu.rotation_rad.to_degrees();
|
||||
if ui_kit::number_field(ui, &mut degrees, -1e6_f64.to_degrees()..=1e6_f64.to_degrees(), 1.0, "°").changed() {
|
||||
app.render_workspace.view.cpu.rotation_rad = degrees.to_radians();
|
||||
}
|
||||
ui.label(app.tr("render.cpu_environment_samples"));
|
||||
let samples = app.render_workspace.view.cpu.samples;
|
||||
ui_kit::dropdown_menu(ui, "cpu_hdr_samples", &samples.to_string(), |ui| {
|
||||
for value in [1, 4, 16, 64] {
|
||||
if ui_kit::list_picker(ui, &value.to_string(), &value.to_string(), value == samples).clicked() {
|
||||
app.render_workspace.view.cpu.samples = value;
|
||||
ui.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
ui.small(app.tr("render.cpu_hdr_reflection_help"));
|
||||
}
|
||||
ui.label(app.tr("render.studio_intensity"));
|
||||
ui_kit::number_field(ui, &mut app.render_workspace.view.cpu.intensity, 0.0..=64.0, 0.1, "");
|
||||
ui.small(app.tr("render.cpu_environment_background"));
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn vector(ui: &mut egui::Ui, label: &str, value: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, speed: f64, suffix: &str) {
|
||||
ui.label(label);
|
||||
ui.horizontal(|ui| {
|
||||
for component in value {
|
||||
ui_kit::number_field(ui, component, range.clone(), speed, suffix);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn light_controls(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
super::light::lighting(app, ui);
|
||||
}
|
||||
|
||||
pub(super) fn record_checked(app: &mut SolveApp, params: &Value, reply: &Value) {
|
||||
if params["integrator"] == "raytrace" || params["settings"]["job"]["method"] == "cpu_raytrace" {
|
||||
app.render_workspace.view.cpu.checked = Some(Checked {
|
||||
request: params.clone(),
|
||||
revision: app.session.revision,
|
||||
environment: reply["environment"].clone(),
|
||||
document: std::sync::Arc::downgrade(&app.session.doc),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn metadata(app: &SolveApp, ui: &mut egui::Ui, info: &Value) {
|
||||
let Some(hash) = info["source_sha256"].as_array().filter(|hash| hash.len() == 32) else { return };
|
||||
let digest: Option<Vec<_>> = hash.iter().map(|byte| byte.as_u64().and_then(|n| u8::try_from(n).ok())).collect();
|
||||
let Some(digest) = digest else { return };
|
||||
let digest: String = digest.into_iter().map(|byte| format!("{byte:02x}")).collect();
|
||||
let width = info["header"]["width"].as_u64().unwrap_or(0);
|
||||
let height = info["header"]["height"].as_u64().unwrap_or(0);
|
||||
ui.label(format!("{width} × {height} px"));
|
||||
ui.label(format!("{}: {}", app.tr("render.cpu_environment_samples"), info["samples"].as_u64().unwrap_or(0)));
|
||||
ui.label(format!("{}: {:.2}", app.tr("render.studio_intensity"), info["intensity"].as_f64().unwrap_or(0.0)));
|
||||
ui.label(format!("{}: {:.1}°", app.tr("render.studio_rotation"), info["rotation_radians"].as_f64().unwrap_or(0.0).to_degrees()));
|
||||
ui.label(format!("SHA-256: {digest}"));
|
||||
}
|
||||
|
||||
pub(super) fn checked_status(app: &SolveApp, ui: &mut egui::Ui, params: Option<&Value>) {
|
||||
if app.render_workspace.view.method != super::ImageMethod::CpuRaytrace {
|
||||
return;
|
||||
}
|
||||
if let Some(checked) = &app.render_workspace.view.cpu.checked {
|
||||
let title = app.tr("render.cpu_last_check").to_string();
|
||||
ui_kit::section(ui, "cpu_last_check", &title, false, |ui| {
|
||||
if params != Some(&checked.request)
|
||||
|| checked.revision != app.session.revision
|
||||
|| !std::sync::Weak::ptr_eq(&checked.document, &std::sync::Arc::downgrade(&app.session.doc))
|
||||
{
|
||||
ui.small(app.tr("render.cpu_check_changed"));
|
||||
}
|
||||
metadata(app, ui, &checked.environment);
|
||||
ui.small(app.tr("render.cpu_check_capture_help"));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn captured_status(app: &SolveApp, ui: &mut egui::Ui, status: &Value) {
|
||||
if status["request"]["integrator"] == "raytrace" && status["environment"]["source_sha256"].is_array() {
|
||||
let title = app.tr("render.cpu_captured_hdr").to_string();
|
||||
ui_kit::section(ui, "cpu_captured_hdr", &title, false, |ui| metadata(app, ui, &status["environment"]));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn dielectric_policy_harness() -> crate::scenario::Harness {
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
h.app.ui.tab = "RENDER".into();
|
||||
h.app.render_workspace.view.method = super::ImageMethod::CpuRaytrace;
|
||||
h.app.render_workspace.view.result = false;
|
||||
h.app.render_workspace.view.name = "Policy".into();
|
||||
h.app.render_workspace.view.draft.width = 1;
|
||||
h.app.render_workspace.view.draft.height = 1;
|
||||
h.app.render_workspace.view.draft.exposure_ev = 0.0;
|
||||
h.app.render_workspace.view.raytrace = Default::default();
|
||||
h.app.render_workspace.view.cpu = View::default();
|
||||
h
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn cpu_glass_policy_no_binding_ui_snapshot_save_reopen_load_preserves_portable_choice() {
|
||||
use solidcraft_engine::doc::render_settings::RenderJob;
|
||||
let mut h = dielectric_policy_harness();
|
||||
assert!(!set_dielectric_transport(&mut h.app, CpuDielectricTransport::LegacyBounded));
|
||||
assert!(set_dielectric_transport(&mut h.app, CpuDielectricTransport::StrictTir));
|
||||
assert!(h.app.render_workspace.view.dirty);
|
||||
assert!(!super::setups::has_runtime_inputs(&h.app), "the choice itself is portable");
|
||||
let saved = super::setups::snapshot(&h.app).unwrap();
|
||||
let Some(RenderJob::CpuRaytrace { options }) = &saved.job else { panic!("CPU draft changed method") };
|
||||
assert_eq!(options.dielectric_transport, CpuDielectricTransport::StrictTir);
|
||||
let wire = super::image_request(&h.app).unwrap();
|
||||
assert_eq!(wire["settings"]["job"]["options"]["dielectric_transport"], "strict_tir");
|
||||
super::setups::save(&mut h.app).unwrap();
|
||||
let document = solidcraft_engine::doc::Document::from_json(&h.app.session.doc.to_json()).unwrap();
|
||||
h.app.session = solidcraft_engine::Session::new(document);
|
||||
h.app.render_workspace.view.raytrace.dielectric_transport = CpuDielectricTransport::LegacyBounded;
|
||||
super::setups::load(&mut h.app);
|
||||
assert_eq!(h.app.render_workspace.view.raytrace.dielectric_transport, CpuDielectricTransport::StrictTir);
|
||||
assert_eq!(super::setups::snapshot(&h.app).unwrap(), saved);
|
||||
assert_eq!(super::image_request(&h.app).unwrap()["settings"]["job"]["options"]["dielectric_transport"], "strict_tir");
|
||||
assert!(set_dielectric_transport(&mut h.app, CpuDielectricTransport::LegacyBounded));
|
||||
assert!(serde_json::to_value(super::setups::snapshot(&h.app).unwrap()).unwrap()["job"]["options"].get("dielectric_transport").is_none());
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn cpu_glass_policy_numeric_lowering_and_active_light_filter_preserve_the_exact_choice() {
|
||||
use solidcraft_engine::render::job::DirectionalLightOptions;
|
||||
let mut h = dielectric_policy_harness();
|
||||
h.app.render_workspace.view.raytrace.lights = Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]);
|
||||
h.app.render_workspace.view.lights.visibility.muted.insert("directional:0".into());
|
||||
for policy in [CpuDielectricTransport::LegacyBounded, CpuDielectricTransport::StrictTir] {
|
||||
set_dielectric_transport(&mut h.app, policy);
|
||||
let source = h.app.render_workspace.view.raytrace.clone();
|
||||
for interactive in [false, true] {
|
||||
let mut wire = json!({"settings":{"job":null}});
|
||||
if interactive {
|
||||
params_interactive(&h.app, &mut wire).unwrap();
|
||||
} else {
|
||||
params(&h.app, &mut wire).unwrap();
|
||||
}
|
||||
super::materials::params(&h.app, &mut wire).unwrap();
|
||||
let wire = super::light::filter_request(&h.app, wire).unwrap();
|
||||
let options: solidcraft_engine::render::job::RaytraceOptions = serde_json::from_value(wire["raytrace"].clone()).unwrap();
|
||||
assert_eq!(options.dielectric_transport, policy);
|
||||
assert_eq!(options.lights.as_ref().unwrap()[0].intensity, 0.0);
|
||||
assert_eq!(h.app.render_workspace.view.raytrace, source, "transient visibility must not rewrite authored input");
|
||||
}
|
||||
let portable = super::image_request(&h.app).unwrap();
|
||||
let options: solidcraft_engine::doc::render_settings::CpuJob =
|
||||
serde_json::from_value(portable["settings"]["job"]["options"].clone()).unwrap();
|
||||
assert_eq!(options.dielectric_transport, policy);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn cpu_glass_policy_selection_preserves_unsupported_opaque_reflection_and_advanced_intent() {
|
||||
use solidcraft_engine::render::job::{EmissionSides, SurfaceEmission};
|
||||
let mut h = dielectric_policy_harness();
|
||||
h.app.session.execute("solid.box", &json!({"length":20,"width":20,"height":10})).unwrap();
|
||||
h.app.session.execute("render.scene", &json!({})).unwrap();
|
||||
let target = super::materials::read_targets(&mut h.app).unwrap().remove(0);
|
||||
set_reflection(&mut h.app, &target.name, Some(ReflectionMode::Mirror)).unwrap();
|
||||
let authored = h.app.render_workspace.view.raytrace.clone();
|
||||
set_dielectric_transport(&mut h.app, CpuDielectricTransport::StrictTir);
|
||||
assert_eq!(h.app.render_workspace.view.raytrace.reflections, authored.reflections);
|
||||
assert!(super::image_request(&h.app).is_err());
|
||||
assert!(super::interactive_request(&h.app).is_err());
|
||||
assert_eq!(h.app.render_workspace.view.raytrace.reflections, authored.reflections);
|
||||
assert_eq!(h.app.render_workspace.view.raytrace.dielectric_transport, CpuDielectricTransport::StrictTir);
|
||||
h.app.render_workspace.view.raytrace.reflections = None;
|
||||
h.app.render_workspace.view.raytrace.emissions = Some(vec![SurfaceEmission {
|
||||
body_index: target.ordinal,
|
||||
body: target.name,
|
||||
color: [1.0, 0.5, 0.25],
|
||||
strength: 1.0,
|
||||
sides: EmissionSides::Front,
|
||||
}]);
|
||||
let authored = h.app.render_workspace.view.raytrace.clone();
|
||||
assert!(super::image_request(&h.app).is_err());
|
||||
assert!(super::interactive_request(&h.app).is_err());
|
||||
assert_eq!(h.app.render_workspace.view.raytrace, authored);
|
||||
}
|
||||
|
||||
#[cfg(all(test, not(target_arch = "wasm32")))]
|
||||
#[test]
|
||||
fn native_cpu_glass_policy_public_ui_check_start_and_interactive_preserve_real_material_and_visibility() {
|
||||
use solidcraft_engine::render::job::interactive::VisualRevision;
|
||||
use solidcraft_engine::render::job::{CpuHost, CpuProgressiveOptions, DirectionalLightOptions, HostKind, Integrator, JobId, Phase};
|
||||
use solidcraft_engine::schema::render_ui::Action;
|
||||
use std::time::Duration;
|
||||
let host = CpuHost::for_platform().unwrap();
|
||||
assert_eq!(host.kind(), HostKind::NativeWorker);
|
||||
host.validate_integrator(Integrator::Raytrace).unwrap();
|
||||
eprintln!("CPU_GLASS_POLICY_UI_BRANCH cpu_supported=true");
|
||||
for policy in [CpuDielectricTransport::LegacyBounded, CpuDielectricTransport::StrictTir] {
|
||||
let mut h = dielectric_policy_harness();
|
||||
h.app.session.set_render_job_host(Some(host.clone())).unwrap();
|
||||
h.app.session.execute("solid.box", &json!({"length":20,"width":20,"height":10})).unwrap();
|
||||
h.app.session.execute("render.scene", &json!({})).unwrap();
|
||||
set_dielectric_transport(&mut h.app, policy);
|
||||
h.app.render_workspace.view.raytrace.lights =
|
||||
Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]);
|
||||
h.app.render_workspace.view.lights.visibility.muted.insert("directional:0".into());
|
||||
let target = super::materials::read_targets(&mut h.app).unwrap().remove(0);
|
||||
let mut binding = super::materials::Binding::new(target, &h.app);
|
||||
binding.glass_enabled = true;
|
||||
binding.cpu_optics = true;
|
||||
// Explicit index-matched certified box: this is capture/consumer
|
||||
// acceptance, not a new oracle for general reflective glass quality.
|
||||
binding.glass.ior = 1.0;
|
||||
binding.glass.boundary = super::materials::Boundary::Box;
|
||||
binding.glass.thickness = 0.0;
|
||||
h.app.render_workspace.view.materials.enabled = true;
|
||||
h.app.render_workspace.view.materials.bindings.push(binding);
|
||||
assert!(super::setups::snapshot(&h.app).is_err(), "captured body bindings remain runtime-only");
|
||||
for progressive in [false, true] {
|
||||
h.app.render_workspace.view.raytrace.progressive = progressive.then_some(CpuProgressiveOptions { samples_per_pixel: 3, seed: 411 });
|
||||
let wire = super::image_request(&h.app).unwrap();
|
||||
assert_eq!(wire["raytrace"]["dielectrics"].as_array().unwrap().len(), 1);
|
||||
let checked = h.app.session.execute("render.preflight", &wire).unwrap();
|
||||
record_checked(&mut h.app, &wire, &checked);
|
||||
let revision = h.app.session.revision;
|
||||
let other =
|
||||
if policy == CpuDielectricTransport::StrictTir { CpuDielectricTransport::LegacyBounded } else { CpuDielectricTransport::StrictTir };
|
||||
set_dielectric_transport(&mut h.app, other);
|
||||
assert_ne!(Some(&super::image_request(&h.app).unwrap()), h.app.render_workspace.view.cpu.checked.as_ref().map(|c| &c.request));
|
||||
assert_eq!(h.app.session.revision, revision);
|
||||
set_dielectric_transport(&mut h.app, policy);
|
||||
let started = h.app.session.execute("render.start", &wire).unwrap();
|
||||
let id: JobId = serde_json::from_value(started["job"].clone()).unwrap();
|
||||
let final_handle = h.app.session.render_job_handle(id).unwrap();
|
||||
let final_status = final_handle.wait_timeout(Duration::from_secs(60)).unwrap();
|
||||
assert_eq!(final_status.progress.phase, Phase::Completed, "{:?}", final_status.error);
|
||||
assert_eq!(json!(final_status.request), checked["request"]);
|
||||
assert_eq!(final_status.request.raytrace.as_ref().unwrap().dielectric_transport, policy);
|
||||
assert!(final_handle.frame().unwrap().is_some());
|
||||
let preview_wire = super::interactive_request(&h.app).unwrap();
|
||||
let context = h.app.session.interactive_render().unwrap();
|
||||
context.enable(VisualRevision { scene_generation: revision, visual_revision: 1 }, Duration::ZERO).unwrap();
|
||||
let ticket = context.capture(Duration::from_millis(201)).unwrap().unwrap();
|
||||
assert!(context.snapshot(&h.app.session, ticket, &preview_wire).unwrap().run().unwrap());
|
||||
let preview_handle = context.current().unwrap().unwrap();
|
||||
let status = preview_handle.wait_timeout(Duration::from_secs(60)).unwrap();
|
||||
assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
|
||||
let captured = status.request.raytrace.as_ref().unwrap();
|
||||
assert_eq!(captured.dielectric_transport, policy);
|
||||
assert_eq!(captured.dielectrics, final_status.request.raytrace.as_ref().unwrap().dielectrics);
|
||||
assert_eq!(captured.lights.as_ref().unwrap()[0].intensity, 0.0);
|
||||
assert_ne!(status.job, final_status.job);
|
||||
assert!(final_handle.frame().unwrap().is_some(), "Interactive cannot replace the final source");
|
||||
context.disable().unwrap();
|
||||
}
|
||||
// Exercise actual UI intent observation while paused, without a fake
|
||||
// receiver or a second capture worker. No timer result is asserted.
|
||||
super::interactive::apply_command(&mut h.app, Action::On).unwrap();
|
||||
let before = super::interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap();
|
||||
super::interactive::apply_command(&mut h.app, Action::Pause).unwrap();
|
||||
let revision = h.app.session.revision;
|
||||
set_dielectric_transport(
|
||||
&mut h.app,
|
||||
if policy == CpuDielectricTransport::StrictTir { CpuDielectricTransport::LegacyBounded } else { CpuDielectricTransport::StrictTir },
|
||||
);
|
||||
super::interactive::apply_command(&mut h.app, Action::Resume).unwrap();
|
||||
assert!(super::interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > before);
|
||||
assert_eq!(h.app.session.revision, revision);
|
||||
super::interactive::apply_command(&mut h.app, Action::Off).unwrap();
|
||||
h.app.render_workspace.view.materials.bindings[0].glass.shadows = true;
|
||||
let shadow_wire = super::image_request(&h.app).unwrap();
|
||||
let shadow_options: solidcraft_engine::render::job::RaytraceOptions = serde_json::from_value(shadow_wire["raytrace"].clone()).unwrap();
|
||||
assert!(shadow_options.directional_shadow_transmission);
|
||||
assert!(shadow_options.shadows);
|
||||
assert_eq!(shadow_options.dielectric_transport, h.app.render_workspace.view.raytrace.dielectric_transport);
|
||||
assert_eq!(shadow_options.dielectrics[0].ior, 1.0);
|
||||
let shadow_check = h.app.session.execute("render.preflight", &shadow_wire).unwrap();
|
||||
let shadow_request: solidcraft_engine::render::job::ImageRequest = serde_json::from_value(shadow_check["request"].clone()).unwrap();
|
||||
assert_eq!(shadow_request.raytrace.as_ref(), Some(&shadow_options));
|
||||
assert!(!h.app.render_workspace.view.raytrace.directional_shadow_transmission, "the bridge is request-local");
|
||||
assert!(h.app.render_workspace.view.materials.bindings[0].glass.shadows);
|
||||
h.app.render_workspace.view.materials.bindings[0].glass.shadows = false;
|
||||
h.app.render_workspace.view.materials.bindings[0].maps_enabled = true;
|
||||
assert!(super::interactive_request(&h.app).is_err());
|
||||
assert!(h.app.render_workspace.view.materials.bindings[0].maps_enabled);
|
||||
}
|
||||
}
|
||||
+11763
File diff suppressed because it is too large.
Load diff
+189
@@ -0,0 +1,189 @@
|
||||
//! Ephemeral shot previews. One cancellable CPU task; no host, job identity or document edits.
|
||||
use std::collections::BTreeMap;
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
use crate::SolveApp;
|
||||
use solidcraft_engine::render::{Camera, job::CancelToken};
|
||||
|
||||
pub(super) const LIMIT: usize = 16;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const SIZE: [u32; 2] = [104, 60];
|
||||
|
||||
// Cancellation is cooperative. Keep a single process-wide worker permit so rapid tab/document
|
||||
// changes cannot accumulate detached workers while the previous task finishes its bounded step.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
static WORKER_ACTIVE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
struct WorkerPermit;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl Drop for WorkerPermit {
|
||||
fn drop(&mut self) {
|
||||
WORKER_ACTIVE.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub(super) struct Key {
|
||||
pub name: String,
|
||||
revision: u64,
|
||||
scene: u64,
|
||||
camera: u64,
|
||||
}
|
||||
|
||||
impl Key {
|
||||
pub(super) fn new(name: String, revision: u64, scene: u64, camera: Camera) -> Self {
|
||||
let mut hash = std::collections::hash_map::DefaultHasher::new();
|
||||
// Camera's complete serialized numerical intent, including roll, projection and up axis.
|
||||
if let Ok(bytes) = serde_json::to_vec(&camera) {
|
||||
bytes.hash(&mut hash);
|
||||
}
|
||||
Self { name, revision, scene, camera: hash.finish() }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Cache {
|
||||
pub entries: BTreeMap<Key, Option<egui::TextureHandle>>,
|
||||
visible: Vec<String>,
|
||||
pending: Option<Pending>,
|
||||
}
|
||||
struct Pending {
|
||||
key: Key,
|
||||
cancel: CancelToken,
|
||||
result: std::sync::mpsc::Receiver<Option<egui::ColorImage>>,
|
||||
}
|
||||
impl Drop for Cache {
|
||||
fn drop(&mut self) {
|
||||
if let Some(pending) = &self.pending {
|
||||
pending.cancel.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Cache {
|
||||
pub fn show(&mut self, names: Vec<String>, ctx: &egui::Context) {
|
||||
let names = names.into_iter().take(LIMIT).collect::<Vec<_>>();
|
||||
if self.visible != names {
|
||||
self.visible = names;
|
||||
ctx.request_repaint();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn texture(&self, name: &str) -> Option<egui::TextureId> {
|
||||
self.entries.iter().find(|(key, _)| key.name == name).and_then(|(_, value)| value.as_ref().map(egui::TextureHandle::id))
|
||||
}
|
||||
|
||||
pub fn retain(&mut self, keys: &[Key]) {
|
||||
self.entries.retain(|key, _| keys.iter().take(LIMIT).any(|wanted| wanted == key));
|
||||
if let Some(pending) = &self.pending
|
||||
&& !keys.iter().take(LIMIT).any(|key| key == &pending.key)
|
||||
{
|
||||
// Keep the receiver until the worker exits: invalidation cannot spawn extra workers.
|
||||
pending.cancel.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
fn poll(&mut self, ctx: &egui::Context, keys: &[Key]) {
|
||||
let Some(pending) = &self.pending else { return };
|
||||
let image = match pending.result.try_recv() {
|
||||
Ok(image) => image,
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => {
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(100));
|
||||
return;
|
||||
}
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => None,
|
||||
};
|
||||
if let Some(pending) = self.pending.take()
|
||||
&& keys.iter().take(LIMIT).any(|key| key == &pending.key)
|
||||
&& !pending.cancel.is_cancelled()
|
||||
{
|
||||
self.entries.insert(pending.key, image.map(|image| ctx.load_texture("shot_thumbnail", image, egui::TextureOptions::LINEAR)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn refresh(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
let mut scene = std::collections::hash_map::DefaultHasher::new();
|
||||
app.session.visibility.hidden_bodies.hash(&mut scene);
|
||||
app.session.visibility.hidden_occurrences.hash(&mut scene);
|
||||
(std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut scene);
|
||||
let scene = scene.finish();
|
||||
let mut keys = Vec::new();
|
||||
for name in std::iter::once(&app.render_workspace.view.name)
|
||||
.chain(app.render_workspace.thumbnails.visible.iter())
|
||||
.chain(app.session.doc.render.setups.keys())
|
||||
{
|
||||
if keys.len() == LIMIT {
|
||||
break;
|
||||
}
|
||||
if keys.iter().any(|key: &Key| &key.name == name) {
|
||||
continue;
|
||||
}
|
||||
if let Some(setup) = app.session.doc.render.setups.get(name) {
|
||||
keys.push(Key::new(name.clone(), app.session.revision, scene, setup.camera));
|
||||
}
|
||||
}
|
||||
let cache = &mut app.render_workspace.thumbnails;
|
||||
cache.retain(&keys);
|
||||
cache.poll(ctx, &keys);
|
||||
if cache.pending.is_some() {
|
||||
return;
|
||||
}
|
||||
let Some(key) = keys.into_iter().find(|key| !cache.entries.contains_key(key)) else { return };
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
if WORKER_ACTIVE.compare_exchange(false, true, std::sync::atomic::Ordering::Acquire, std::sync::atomic::Ordering::Relaxed).is_err() {
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(100));
|
||||
return;
|
||||
}
|
||||
let permit = WorkerPermit;
|
||||
let Some(setup) = app.session.doc.render.setups.get(&key.name) else { return };
|
||||
let request = solidcraft_engine::render::job::ImageRequest {
|
||||
cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
studio_weights: None,
|
||||
camera: setup.camera,
|
||||
width: SIZE[0],
|
||||
height: SIZE[1],
|
||||
background: setup.background,
|
||||
transparent_background: false,
|
||||
integrator: Default::default(),
|
||||
raytrace: None,
|
||||
environment: None,
|
||||
textures: None,
|
||||
};
|
||||
let scene = solidcraft_engine::product_scene::extract(&app.session);
|
||||
let cancel = CancelToken::default();
|
||||
let worker_cancel = cancel.clone();
|
||||
let (send, result) = std::sync::mpsc::sync_channel(1);
|
||||
let worker = std::thread::Builder::new().name("shot-thumbnail".into()).spawn(move || {
|
||||
let _permit = permit;
|
||||
let image = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
||||
let scene = scene.ok()?;
|
||||
let mut task = solidcraft_engine::render::job::ImageTask::new(scene, request, worker_cancel).ok()?;
|
||||
loop {
|
||||
match task.step(1024).ok()? {
|
||||
solidcraft_engine::render::job::TaskPoll::Pending(_) => {}
|
||||
solidcraft_engine::render::job::TaskPoll::Complete(png) => {
|
||||
let image = image::load_from_memory(&png).ok()?.to_rgba8();
|
||||
return Some(egui::ColorImage::from_rgba_unmultiplied([SIZE[0] as usize, SIZE[1] as usize], image.as_raw()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}))
|
||||
.ok()
|
||||
.flatten();
|
||||
let _ = send.send(image);
|
||||
});
|
||||
if worker.is_ok() {
|
||||
app.render_workspace.thumbnails.pending = Some(Pending { key, cancel, result });
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(100));
|
||||
} else {
|
||||
app.render_workspace.thumbnails.entries.insert(key, None);
|
||||
}
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
cache.entries.insert(key, None);
|
||||
}
|
||||
@@ -0,0 +1,285 @@
|
||||
--- a/crates/render/src/job/interactive.rs
|
||||
+++ b/crates/render/src/job/interactive.rs
|
||||
@@ -296,6 +296,7 @@
|
||||
|
||||
fn request(options: RaytraceOptions) -> ImageRequest {
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
--- a/crates/ui-egui/src/render_workspace.rs
|
||||
+++ b/crates/ui-egui/src/render_workspace.rs
|
||||
@@ -898,7 +898,19 @@
|
||||
|
||||
/// Pure request construction is shared with offline setup editing; host checks stay above.
|
||||
fn image_request(app: &SolveApp) -> Result<serde_json::Value, String> {
|
||||
- light::filter_request(app, raw_image_request(app)?)
|
||||
+ let request = light::filter_request(app, raw_image_request(app)?)?;
|
||||
+ cpu_checkpoint_policy(app, request, app.render_workspace.view.raytrace.progressive.is_some())
|
||||
+}
|
||||
+
|
||||
+/// One transient command flag for capture and identity, never saved setup intent.
|
||||
+fn cpu_checkpoint_policy(app: &SolveApp, mut request: serde_json::Value, progressive: bool) -> Result<serde_json::Value, String> {
|
||||
+ if app.render_workspace.view.method == ImageMethod::CpuRaytrace && progressive && !app.preferences.render_cpu_progressive_every_pass {
|
||||
+ request
|
||||
+ .as_object_mut()
|
||||
+ .ok_or_else(|| app.tr("render.error_provisional_identity").to_string())?
|
||||
+ .insert("cpu_progressive_every_pass".into(), json!(false));
|
||||
+ }
|
||||
+ Ok(request)
|
||||
}
|
||||
|
||||
fn raw_image_request(app: &SolveApp) -> Result<serde_json::Value, String> {
|
||||
@@ -915,7 +927,9 @@
|
||||
if app.render_workspace.view.method != ImageMethod::CpuRaytrace {
|
||||
return Err(app.tr("render.interactive_requires_cpu").into());
|
||||
}
|
||||
- light::filter_request(app, runtime_image_request(app, true)?)
|
||||
+ let request = light::filter_request(app, runtime_image_request(app, true)?)?;
|
||||
+ // Interactive always becomes CPU progressive, including a Fixed final editor.
|
||||
+ cpu_checkpoint_policy(app, request, true)
|
||||
}
|
||||
|
||||
/// The existing runtime branch, shared without changing Final Check/Start policy.
|
||||
--- a/crates/ui-egui/src/render_workspace_cpu.rs
|
||||
+++ b/crates/ui-egui/src/render_workspace_cpu.rs
|
||||
@@ -369,7 +369,20 @@
|
||||
{
|
||||
return Err(app.tr("render.cpu_binding_stale").to_string());
|
||||
}
|
||||
- params_with_binding_policy(app, params, binding_interactive_current)
|
||||
+ params_with_binding_policy(app, params, binding_interactive_current)?;
|
||||
+ if !app.preferences.render_cpu_interactive_explicit_sampling {
|
||||
+ let options = params
|
||||
+ .get_mut("raytrace")
|
||||
+ .and_then(Value::as_object_mut)
|
||||
+ .ok_or_else(|| app.tr("render.error_provisional_identity").to_string())?;
|
||||
+ // The original request was validated above. Only an explicit progressive
|
||||
+ // object is replaced; Fixed stays Fixed until the engine's existing
|
||||
+ // preview conversion applies primary/reflection1 and the fallback16/0.
|
||||
+ if options.get("progressive").is_some_and(|value| !value.is_null()) {
|
||||
+ options.insert("progressive".into(), json!(solidcraft_engine::render::job::CpuProgressiveOptions::default()));
|
||||
+ }
|
||||
+ }
|
||||
+ Ok(())
|
||||
}
|
||||
|
||||
fn params_with_binding_policy(app: &SolveApp, params: &mut Value, current: fn(&SolveApp, &str) -> bool) -> Result<(), String> {
|
||||
--- a/crates/ui-egui/src/render_workspace_tests.rs
|
||||
+++ b/crates/ui-egui/src/render_workspace_tests.rs
|
||||
@@ -1211,6 +1211,7 @@
|
||||
let mut task = ImageTask::new(
|
||||
scene,
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -3622,6 +3623,7 @@
|
||||
fn large_image_display_uses_captured_profile_and_keeps_export_pixels_unchanged() {
|
||||
use solidcraft_engine::render::job::{CpuBudget, ImageRequest, RaytraceOptions};
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -8613,6 +8615,7 @@
|
||||
fn partial_png_contract_request() -> solidcraft_engine::render::job::ImageRequest {
|
||||
use solidcraft_engine::render::job::{CpuProgressiveOptions, ImageRequest, RaytraceOptions};
|
||||
ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -11484,6 +11487,7 @@
|
||||
state.view.job = Some(job);
|
||||
state.preview_image = Some(PreviewImage { info: PreviewInfo { frame_sequence: 2, samples_per_pixel: 2, frame }, image: Ok(texture) });
|
||||
let request = ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_exposure_ev: 0.0,
|
||||
raster_lights: None,
|
||||
raster_punctual_lights: None,
|
||||
@@ -11588,3 +11592,172 @@
|
||||
cache_preview_image(&mut h.app, &ctx);
|
||||
assert!(h.app.render_workspace.preview_image.is_none());
|
||||
}
|
||||
+
|
||||
+
|
||||
+#[test]
|
||||
+fn cpu_capture_policy_preferences_preserve_typed_setup_final_intent_and_independent_sampling_copy() {
|
||||
+ use solidcraft_engine::render::job::CpuProgressiveOptions;
|
||||
+ let mut h = Harness::new();
|
||||
+ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace;
|
||||
+ h.app.render_workspace.view.draft.width = 16;
|
||||
+ h.app.render_workspace.view.draft.height = 16;
|
||||
+ h.app.render_workspace.view.raytrace.primary_samples = 1;
|
||||
+ h.app.render_workspace.view.raytrace.progressive = Some(CpuProgressiveOptions { samples_per_pixel: 31, seed: 741 });
|
||||
+ let original_options = json!(h.app.render_workspace.view.raytrace);
|
||||
+ let saved = setups::snapshot(&h.app).unwrap();
|
||||
+ let document = h.app.session.doc.clone();
|
||||
+ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.is_dirty());
|
||||
+ for each_pass in [true, false] {
|
||||
+ for preserve_sampling in [true, false] {
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = each_pass;
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = preserve_sampling;
|
||||
+ let final_request = image_request(&h.app).unwrap();
|
||||
+ assert_eq!(final_request["settings"], json!(saved), "portable settings.job stays intact");
|
||||
+ assert!(final_request.get("raytrace").is_none(), "no contradictory parallel runtime CPU options");
|
||||
+ assert_eq!(final_request.get("cpu_progressive_every_pass"), (!each_pass).then_some(&json!(false)));
|
||||
+ let interactive = interactive_request(&h.app).unwrap();
|
||||
+ assert_eq!(interactive["raytrace"]["progressive"]["samples_per_pixel"], if preserve_sampling { 31 } else { 16 });
|
||||
+ assert_eq!(interactive["raytrace"]["progressive"]["seed"], if preserve_sampling { 741 } else { 0 });
|
||||
+ assert_eq!(interactive.get("cpu_progressive_every_pass"), (!each_pass).then_some(&json!(false)));
|
||||
+ assert_eq!(interactive["settings"]["width"], 16);
|
||||
+ assert_eq!(interactive["settings"]["height"], 16);
|
||||
+ let frozen_command = interactive.clone();
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = !each_pass;
|
||||
+ let later_command = interactive_request(&h.app).unwrap();
|
||||
+ assert_ne!(frozen_command, later_command, "the exact Value identity carries the policy");
|
||||
+ assert_eq!(frozen_command, interactive, "an issued command copy cannot follow a later preference edit");
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = each_pass;
|
||||
+ assert_eq!(json!(h.app.render_workspace.view.raytrace), original_options);
|
||||
+ assert_eq!(setups::snapshot(&h.app).unwrap(), saved);
|
||||
+ }
|
||||
+ }
|
||||
+ assert!(Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
+ assert_eq!(history, (h.app.session.revision, h.app.session.undo.len(), h.app.session.is_dirty()));
|
||||
+}
|
||||
+
|
||||
+#[test]
|
||||
+fn cpu_capture_cadence_is_absent_for_single_raster_gpu_and_present_for_derived_interactive_progressive() {
|
||||
+ let mut h = Harness::new();
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = false;
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = false;
|
||||
+ h.app.render_workspace.view.draft.width = 16;
|
||||
+ h.app.render_workspace.view.draft.height = 16;
|
||||
+ for method in [ImageMethod::Raster, ImageMethod::GpuRaytrace, ImageMethod::CpuRaytrace] {
|
||||
+ h.app.render_workspace.view.method = method;
|
||||
+ h.app.render_workspace.view.raytrace.progressive = None;
|
||||
+ let request = image_request(&h.app).unwrap();
|
||||
+ assert!(request.get("cpu_progressive_every_pass").is_none());
|
||||
+ }
|
||||
+ h.app.render_workspace.view.raytrace.primary_samples = 16;
|
||||
+ let fixed_editor = json!(h.app.render_workspace.view.raytrace);
|
||||
+ let preview_request = interactive_request(&h.app).unwrap();
|
||||
+ assert_eq!(preview_request["cpu_progressive_every_pass"], false);
|
||||
+ assert!(preview_request["raytrace"].get("progressive").is_none(), "engine owns Fixed-to-Interactive conversion");
|
||||
+ assert_eq!(preview_request["raytrace"]["primary_samples"], 16);
|
||||
+ assert_eq!(json!(h.app.render_workspace.view.raytrace), fixed_editor);
|
||||
+}
|
||||
+
|
||||
+#[cfg(not(target_arch = "wasm32"))]
|
||||
+#[test]
|
||||
+fn legacy_interactive_sampling_keeps_reduced_preview_admission_without_final_budget_or_hostile_repair() {
|
||||
+ use solidcraft_engine::render::job::{CpuProgressiveOptions, ImageRequest, interactive::cpu_request};
|
||||
+ let mut h = Harness::new();
|
||||
+ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace;
|
||||
+ h.app.render_workspace.view.draft.width = 3840;
|
||||
+ h.app.render_workspace.view.draft.height = 2160;
|
||||
+ h.app.render_workspace.view.raytrace.primary_samples = 1;
|
||||
+ h.app.render_workspace.view.raytrace.progressive = Some(CpuProgressiveOptions { samples_per_pixel: 31, seed: 741 });
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = false;
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = false;
|
||||
+ let editor = json!(h.app.render_workspace.view.raytrace);
|
||||
+ assert!(image_request(&h.app).is_err(), "the original final dimensions still exceed Compact progressive admission");
|
||||
+ let wire = interactive_request(&h.app).unwrap();
|
||||
+ assert_eq!((wire["settings"]["width"].as_u64(), wire["settings"]["height"].as_u64()), (Some(3840), Some(2160)));
|
||||
+ let request: ImageRequest = serde_json::from_value(json!({
|
||||
+ "integrator":"raytrace", "camera":h.app.cam, "width":3840, "height":2160,
|
||||
+ "background":h.app.render_workspace.view.draft.background, "transparent_background":false,
|
||||
+ "raytrace":wire["raytrace"], "cpu_progressive_every_pass":wire["cpu_progressive_every_pass"]
|
||||
+ })).unwrap();
|
||||
+ let preview = cpu_request(&request).unwrap();
|
||||
+ assert_eq!((preview.width, preview.height), (1024, 576));
|
||||
+ assert!(!preview.cpu_progressive_every_pass, "the same canonical cadence flag survives derived capture");
|
||||
+ assert_eq!(preview.raytrace.as_ref().unwrap().progressive, Some(CpuProgressiveOptions { samples_per_pixel: 16, seed: 0 }));
|
||||
+ assert_eq!(json!(h.app.render_workspace.view.raytrace), editor);
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = true;
|
||||
+ let explicit = interactive_request(&h.app).unwrap();
|
||||
+ let mut explicit_request = request.clone();
|
||||
+ explicit_request.raytrace = Some(serde_json::from_value(explicit["raytrace"].clone()).unwrap());
|
||||
+ assert!(cpu_request(&explicit_request).is_err(), "31SPP exceeds the reduced image's original camera-sample envelope; never downgrade it");
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = false;
|
||||
+ h.app.render_workspace.view.raytrace.progressive.as_mut().unwrap().samples_per_pixel = 0;
|
||||
+ assert!(interactive_request(&h.app).is_err(), "legacy preview cannot repair an invalid numerical request");
|
||||
+ assert_eq!(h.app.render_workspace.view.raytrace.progressive.unwrap().samples_per_pixel, 0);
|
||||
+}
|
||||
+
|
||||
+#[cfg(not(target_arch = "wasm32"))]
|
||||
+#[test]
|
||||
+fn interactive_snapshot_policy_and_sampling_stay_captured_after_later_preference_edits() {
|
||||
+ use solidcraft_engine::render::job::{CpuProgressiveOptions, Phase, interactive::VisualRevision};
|
||||
+ use std::time::Duration;
|
||||
+ let mut h = interactive_ui_fixture();
|
||||
+ if !interactive_test_cpu_branch(&mut h, "interactive_snapshot_policy_and_sampling_stay_captured_after_later_preference_edits") {
|
||||
+ return;
|
||||
+ }
|
||||
+ h.app.render_workspace.view.draft.width = 4;
|
||||
+ h.app.render_workspace.view.draft.height = 4;
|
||||
+ h.app.render_workspace.view.raytrace.primary_samples = 1;
|
||||
+ h.app.render_workspace.view.raytrace.progressive = Some(CpuProgressiveOptions { samples_per_pixel: 5, seed: 741 });
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = false;
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = false;
|
||||
+ let captured_value = interactive_request(&h.app).unwrap();
|
||||
+ let context = h.app.session.interactive_render().unwrap();
|
||||
+ context.enable(VisualRevision { scene_generation: h.app.session.revision, visual_revision: 1 }, Duration::ZERO).unwrap();
|
||||
+ let ticket = context.capture(Duration::from_millis(201)).unwrap().unwrap();
|
||||
+ let snapshot = context.snapshot(&h.app.session, ticket, &captured_value).unwrap();
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = true;
|
||||
+ h.app.preferences.render_cpu_interactive_explicit_sampling = true;
|
||||
+ assert_ne!(interactive_request(&h.app).unwrap(), captured_value);
|
||||
+ assert!(snapshot.run().unwrap(), "the real snapshot prepares its frozen command Value");
|
||||
+ let handle = context.current().unwrap().unwrap();
|
||||
+ let status = handle.wait_timeout(Duration::from_secs(60)).unwrap();
|
||||
+ assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
|
||||
+ assert!(!status.request.cpu_progressive_every_pass);
|
||||
+ assert_eq!(status.request.raytrace.as_ref().unwrap().progressive, Some(CpuProgressiveOptions { samples_per_pixel: 16, seed: 0 }));
|
||||
+ assert_eq!(serde_json::to_value(&status.request).unwrap()["cpu_progressive_every_pass"], false, "prepared metadata keeps the canonical false value");
|
||||
+ assert!(handle.frame().unwrap().is_some());
|
||||
+ assert_eq!(h.app.render_workspace.view.raytrace.progressive, Some(CpuProgressiveOptions { samples_per_pixel: 5, seed: 741 }));
|
||||
+ interactive_assert_final_export_isolation(&mut h, &handle);
|
||||
+ context.disable().unwrap();
|
||||
+}
|
||||
+
|
||||
+#[cfg(not(target_arch = "wasm32"))]
|
||||
+#[test]
|
||||
+fn interactive_cadence_preference_edit_invalidates_real_capture_through_existing_request_identity() {
|
||||
+ let mut h = interactive_ui_fixture();
|
||||
+ if !interactive_test_cpu_branch(&mut h, "interactive_cadence_preference_edit_invalidates_real_capture_through_existing_request_identity") {
|
||||
+ return;
|
||||
+ }
|
||||
+ let epoch = interactive::test_clock(&h.app).as_secs_f64();
|
||||
+ h.app.run("render.interactive", json!({"action":"on"})).unwrap();
|
||||
+ interactive_clear_acceptance_frame(&mut h, epoch, true);
|
||||
+ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true);
|
||||
+ let held = interactive_hold_real_completed_callback(&mut h);
|
||||
+ held.sender.send(held.reply).unwrap();
|
||||
+ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.3, false, true);
|
||||
+ assert!(painted);
|
||||
+ output.textures_delta.clear();
|
||||
+ let old_visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap();
|
||||
+ let old_request = interactive_request(&h.app).unwrap();
|
||||
+ h.app.preferences.render_cpu_progressive_every_pass = false;
|
||||
+ interactive_control_frame(&mut h, epoch + 0.4, vec![]);
|
||||
+ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > old_visual);
|
||||
+ assert!(interactive::test_current(&h.app).unwrap().is_none(), "existing edit path releases/cancels its owned capture");
|
||||
+ assert!(interactive::test_cache(&h.app).is_none());
|
||||
+ assert!(!h.app.render_workspace.interactive.pending(), "before_paint cannot launch a replacement");
|
||||
+ assert_ne!(interactive_request(&h.app).unwrap(), old_request);
|
||||
+ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none());
|
||||
+ // This real source completed before the edit; this test does not claim to
|
||||
+ // observe cancellation of an in-flight renderer or every physical repaint.
|
||||
+ assert!(held.job.frame().unwrap().is_some());
|
||||
+ h.app.run("render.interactive", json!({"action":"off"})).unwrap();
|
||||
+}
|
||||
--- a/crates/ui-egui/src/render_workspace_thumbnails.rs
|
||||
+++ b/crates/ui-egui/src/render_workspace_thumbnails.rs
|
||||
@@ -138,6 +138,7 @@
|
||||
let permit = WorkerPermit;
|
||||
let Some(setup) = app.session.doc.render.setups.get(&key.name) else { return };
|
||||
let request = solidcraft_engine::render::job::ImageRequest {
|
||||
+ cpu_progressive_every_pass: true,
|
||||
raster_punctual_lights: None,
|
||||
raster_area_lights: None,
|
||||
raster_exposure_ev: 0.0,
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"status": "SOURCE_ONLY_NOT_ADOPTED_UNCOMPILED_UNRUN",
|
||||
"subpackage": "ui",
|
||||
"base_source_manifest_sha256": "d38a8d946b6653864ad8918d4da662725bd24ca01b2e5aa2d3b38b47b1a7e163",
|
||||
"base_rule": "Exact per-file RAW preimages only. Not current main, not a combined candidate. LF patch is review aid; RAW candidate bytes are authoritative.",
|
||||
"files": [
|
||||
{
|
||||
"path": "crates/render/src/job/interactive.rs",
|
||||
"before_sha256": "97395da5b097d9283ac080e197f6de612b6123d9a90396e1850ca911d6ca5812",
|
||||
"before_bytes": 14389,
|
||||
"after_sha256": "5e0c502ffd7efdcfddc27dda0aa496d640e57eed0f775fd94a4ad036360748ab",
|
||||
"after_bytes": 14435
|
||||
},
|
||||
{
|
||||
"path": "crates/ui-egui/src/render_workspace.rs",
|
||||
"before_sha256": "1434d0b576ab7c8a94ca7f23b9f0bb617f755509cd6f16bfafb3a86cfed05263",
|
||||
"before_bytes": 111146,
|
||||
"after_sha256": "cffe8870ab6a3608ef0e286009ca8caa3f5e905a4aa1c57c418dab130018d59e",
|
||||
"after_bytes": 111985
|
||||
},
|
||||
{
|
||||
"path": "crates/ui-egui/src/render_workspace_cpu.rs",
|
||||
"before_sha256": "fd6de0f8121dc4d1bfce308c376901f65e2d920b68a756c38a25f82679db64ad",
|
||||
"before_bytes": 42703,
|
||||
"after_sha256": "00b1f5c25f8fe07719451683dd8d9a5f8b0b52b89f8b5e466b365cafc14e585d",
|
||||
"after_bytes": 43431
|
||||
},
|
||||
{
|
||||
"path": "crates/ui-egui/src/render_workspace_tests.rs",
|
||||
"before_sha256": "28ddafe4a8f133c522ddf6f1e0eaaaf70f954d7b8acdb7cca44aabef9a512e47",
|
||||
"before_bytes": 634699,
|
||||
"after_sha256": "d9850e1996aecdcef2d3c55a5704ea7d3c29e7c237025415ce3d69a3c63f2fcf",
|
||||
"after_bytes": 646092
|
||||
},
|
||||
{
|
||||
"path": "crates/ui-egui/src/render_workspace_thumbnails.rs",
|
||||
"before_sha256": "001729728a657f2ba0f2d1b50d1a4644f3f7ad505609cf8e674fa7f3f627e445",
|
||||
"before_bytes": 7420,
|
||||
"after_sha256": "85d5a8d2529df5b922243eab4f14de3b4ab684907834c4bbe29784930077e83d",
|
||||
"after_bytes": 7466
|
||||
}
|
||||
],
|
||||
"full_CI_native_or_readiness": false,
|
||||
"candidate_whole_file_overlay_safe": false,
|
||||
"shared_before_test_file_sha256": "28ddafe4a8f133c522ddf6f1e0eaaaf70f954d7b8acdb7cca44aabef9a512e47"
|
||||
}
|
||||
Reference in new issue
Block a user