settings

The renderer’s feature toggles: the storage behind SETTINGS.raytracing.

Renderer switches stored here use the same names exposed by SETTINGS.raytracing. Some have environment-variable defaults; others have ordinary Python defaults. Additional fields live in the storage modules listed by algan.settings.raytracing_settings. The validated settings facade exposes all of those modules together; the switches that change what the image looks like are exposed on it directly, and the kernel and performance switches through SETTINGS.raytracing.experimental.

One name, deliberately. These used to be UPPER_CASE here and lowercase there, joined by a hand-maintained table in algan/settings/raytracing_settings.py, and nine switches reached the engine with no way to set them because nobody added their row. The field set is derived from this module now, so a switch declared here is reachable by construction. The corollary is that a helper function may not share a name with a field – the later def would take the name over and the field would vanish silently (see _shadowed_fields).

Read these live – rt_settings.x at call time, not from ... import X at module import. Importing by value freezes a toggle at its import-time state, before user code has had a chance to set it. That bug has shipped before.

set_unsupported_feature_policy() and report_unsupported_features() decide what happens when a Scene asks for something the selected tracer cannot do: raise (the default), warn, or ignore.

Functions

analytic_aa_bez_active()

Live effective value of circuit analytic coverage.

Read at call time, never imported by value: settings are module globals with env-var defaults and user code flips them after import.

analytic_aa_bez_mode()

Circuit coverage as the kernels’ aa_bez template value.

0 off, 1 the box filter, 2 the exact angle-aware area (analytic_aa_exact), 3 that plus the two-segment boundary model (analytic_aa_bez_wedge, default on since 2026-08-13). The distinction rides in the template value so the two forms cannot share an offline-cache entry; everything downstream that only asks whether circuit coverage is on keeps testing it for truth.

analytic_aa_sliver_mode()

Index of the live sample-less-triangle policy in the mode tuple.

Read at call time (never imported by value) and returned as an int, because it reaches the kernels as part of the aa template value: the geometry kernels see 1 + mode, so each policy compiles its own variant and the offline cache cannot serve one policy’s kernel for another.

analytic_aa_tri_active()

Live effective value of flat-triangle analytic coverage.

effective_analytic_aa_secondary_samples()

Live continuation-ray tap count; 1 (off) unless analytic AA is on.

Clamped to [1, _AA_SEC_MAX] and otherwise returned unchanged: every count in that range has real sub-pixel positions (hand-written for 1/2/4/8, generated for the rest), so there is no supported set left to snap to. N still reaches the resolve as a template value, which is why a value above the ceiling is clamped with a warning rather than honoured – the position mask is an i32 bitfield, and each extra distinct tap count also pays a kernel compile of its own (see the warning text).

glossy_blur_sigma_px(roughness, d_reflected, d_primary, theta_px)

The prefilter’s blur radius in pixels, in pure Python.

The kernels compute this inline (sheet_resolve_taichi produces the per-pixel scale, glossy_prefilter_taichi.gloss_scatter applies the cone factor); this is the same arithmetic in one place, for tests and for anything on the host that needs to predict it. See DESIGN_glossy_prefilter.md §3 for where each term comes from.

d_reflected is how far past the primary hit the reflected content sits; inf (a ray that escaped) is a reflection of the sky and blurs by the full lobe angle, and 0 (a reflection in contact with its reflector) does not blur at all.

glossy_reflection_mode()

Live glossy-lobe mode: 0 off, 1 fan only, 2 fan + per-pixel rotation, 3 split-sum prefilter (glossy_prefilter, the default when glossy reflections are on at all).

Read at call time (never imported by value) and returned as an int, because it reaches the resolve as a TEMPLATE value: each mode compiles its own kernel variant with its own cache key, so the offline cache cannot serve one mode’s kernel for another. A module-level constant read at import would instead freeze the first value for the process, which no cache could fix.

hdr_frame_dtype()

dtype of the linear-HDR frame buffer used under post-process tonemapping: float32, or float16 when hdr_buffer_f16 is on.

is_post_process_tonemap_enabled()

Return whether post-process tonemapping is enabled.

is_post_tonemap_kernel_enabled()

kernel_compiled_in_values()

What a kernel compiled right now would fold in.

Read through SETTINGS.raytracing rather than off this module’s globals, because two of the five are stored beside the kernels that bake them (raytrace_kernels_taichi) and the facade resolves a field wherever its storage module keeps it.

merge_on_gpu_active()

True when the scene merge + STBVH build should run on the render device.

Requires merge_on_gpu and a CUDA render device – the offload only pays off on a real accelerator, and the transient-peak accounting uses the torch.cuda memory-stats API. A CPU (or MPS) render device keeps the merge on the CPU, byte-identically to the pre-toggle path.

nested_ior_mode()

Live nested-IOR mode: 0 off, 1 media stack maintained.

Read at call time (never imported by value) and returned as an int, because it reaches the shade/resolve kernels as a TEMPLATE value: each mode compiles its own kernel variant, so the offline cache cannot serve one mode’s kernel for another (see glossy_reflection_mode).

note_sparse_discovery_footprint(arena_bytes, num_frames)

Record the arena footprint of one sparse-coverage discovery pass so the render-chunk preflight can reserve for the next one (see _SPARSE_DISCOVERY_BYTES_PER_FRAME).

pn_criterion_kernel_active()

True when the level searches should use their fused Taichi kernels.

Two arrangements put the criterion’s tensors on Taichi’s arch device, which is the whole requirement (see taichi_runtime.taichi_launch_is_local):

• projection ran on a CUDA render device, so the geometry is already there;

• the arch is the CPU, so the host tensors never had to go anywhere.

The second was excluded until 2026-08-26 for a reason that only covered the first: launching against CPU tensors stages every argument through VRAM. That is true when the arch is CUDA and false when it is x64, so the rule as written turned the kernels off in the one case where they are free. The remaining tensor-by-tensor device check lives in the input builders.

project_on_gpu_active()

True when project_to_screen should run on the render device.

Requires project_on_gpu and a CUDA render device (see merge_on_gpu_active for why CUDA specifically).

raster_write_compact_active()

True when the write pass should be launched over the live pairs only.

Off on MPS, where it corrupts the fragment stream. Measured on the Mac runner, both arms in one session with everything else identical (benchmarks/performance/reports/mac_2026_09): with the compaction the emitted keys carry scattered pixel ordinals the write kernel cannot have produced – it guards 0 <= lp < tile_pixels – and the values are stale arena bytes, i.e. slots the write pass never visited. The same emission without it is clean, and so is every later one, including the whole 4K render that the compaction had never let finish.

The selection is not what breaks: _check_write_compaction compares the pairs with counts > 0, the pairs with accepts != 0, and what nonzero returns, and on the failing run all three agree. What is left is the gathered argument tensors the compacted launch passes instead of the originals, and that is a torch-MPS / Taichi-Metal interaction this gate does not attempt to fix – it declines to depend on it.

ALGAN_RASTER_WRITE_COMPACT=0 still turns it off everywhere, and setting it to 1 does not force it back on for MPS: a wrong picture is not a thing to opt into by accident. Use set_raster_write_compact for the A/B.

refit_bvh_active()

Live effective value of the refit-BVH toggle.

report_unsupported_features(message)

Apply the configured policy to an unsupported render combination.

set_analytic_aa(enabled, *, bezier=None, triangles=None, seam=None, sliver=None, secondary=None, exact=None, wedge=None, run=None, run_rule=None, run_full=None, one_mesh=None)

Toggle analytic anti-aliasing (see analytic_aa).

set_bez_bvh_split(enabled)

Toggle median-split ordering for the bezier STBVH (see bez_bvh_split).

Takes effect on the next scene build.

set_bvh_defer(enabled)

Toggle deferred (on-demand) STBVH builds for batches that provably do not traverse them (see bvh_defer). Takes effect at the next batch’s scene merge.

set_bvh_refit(enabled)

Toggle the shared-topology binned-SAH refit BVH (see bvh_refit). Takes effect at the next batch’s scene merge.

set_denoise_precision(value)

Select the denoiser’s arithmetic precision (see denoise_precision).

One of "auto", "fp16" or "fp32". Takes effect at the next render; the loaded network is re-cast when the choice changes.

set_frag_pid_gate(enabled)

Toggle compile-time material-pipeline gating of the shade kernels (see frag_pid_gate). Takes effect at the next render batch.

set_fragment_shading(enabled)

Toggle per-fragment shading of the deterministic ray tracer.

When enabled, triangle/PN hits whose material is one of the core lit shaders (the legacy diffuse default, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshStandardMaterial, MeshPhysicalMaterial, MeshToonMaterial, MeshNormalMaterial, MeshMatcapMaterial and MeshDepthMaterial) are shaded per fragment in-kernel from the raw albedo, a per-primitive material block and the scene’s lights – crisper specular highlights and smooth shading on coarse meshes. Other materials keep vertex shading. Only the deterministic renderer (set_samples_per_pixel(1), non-physical) is affected. Set before rendering.

set_glossy_reflection(enabled, *, interleave=None, prefilter=None)

Toggle roughness-driven glossy reflections (see glossy_reflection).

prefilter selects the split-sum route (default) over the tap fan; interleave only means anything to the fan.

set_hdr_buffer_f16(enabled)

Toggle the float16 linear-HDR frame buffer (see hdr_buffer_f16).

Takes effect at the next render batch’s buffer allocation.

set_hybrid_raster(enabled)

Toggle the hybrid raster primary-visibility front-end (see hybrid_raster).

set_linear_color_space(enabled)

Enable or disable the linear working color space.

On by default. Authored color is decoded from sRGB to linear light at the render boundary, every shading and compositing operation happens in linear, and the sRGB transfer function is applied once at the byte write. This is the arrangement three.js uses, and it is what makes lights add: sRGB encoding is concave, so adding encoded values overshoots the encoded sum – two lights that should put a white surface on byte 188 put it on 255.

Unlit flat 2-D content is unaffected either way, because decoding and then encoding with no arithmetic in between is the identity. What moves is anything the renderer actually computes: lit surfaces (mid-tones lift, a surface at half illumination going from byte 128 to 188), antialiased edges, alpha compositing and the supersample downsample.

Turning it off restores the previous display-referred pipeline exactly, including the illumination-budget normalisation that had to exist to stop gamma-space light sums running away. It is there for A/B comparison and for reproducing pre-change output; agent_guidance/rendering.md has the measurements.

Both arms are correct in one process, but not free: the shading kernels fold this gate in when they compile (KERNEL_COMPILED_IN_FIELDS), so the first render after a change rebuilds the Taichi program and pays a kernel-preparation pass. Set it once at the top of a script rather than per frame.

set_merge_dedup_geometry(enabled)

Toggle the merge-time collapse of temporally-constant geometry tables (see merge_dedup_geometry). Takes effect at the next batch’s merge.

set_merge_dedup_time(enabled)

Toggle the merge-time collapse of temporally-constant tables (see merge_dedup_time). Takes effect at the next batch’s scene merge.

set_merge_on_gpu(enabled)

Toggle GPU-side scene merge + STBVH build (see merge_on_gpu).

set_mesh_id(enabled)

Toggle mob-declared surface identity (see mesh_id). Takes effect at the next batch’s primitive build.

set_nested_ior(enabled)

Toggle the nested-dielectric IOR stack (see nested_ior).

set_opaque_bvh_skip_dead(enabled)

Toggle skipping the dedicated opaque-only STBVH builds while no rollout consumes them (see opaque_bvh_skip_dead). Takes effect at the next batch’s scene merge.

set_per_mob_shadow_flags(enabled)

Toggle the per-mob shadow flags (see per_mob_shadow_flags). Takes effect at the next batch’s scene merge.

set_pn_criterion_kernel(enabled)

Toggle the fused subdivision-level criterion kernels (see pn_criterion_kernel).

set_polyhedron_winding(enabled)

Toggle outward face orientation for closed polyhedra (see polyhedron_winding). Takes effect for the next Polyhedron built.

set_post_process_tonemap(enabled)

Enable or disable post-process tonemapping instead of in-kernel tonemapping.

Disabling it makes the composite write uint8, which clamps every channel – including the glow lane – to 0-255 before bloom runs. A mob with glow > 1 therefore saturates and its halo comes out markedly dimmer and less saturated than on the default HDR path. Turn this off only for an A/B against the legacy in-kernel tonemap; to get linear output, use set_tonemapping() alone, which keeps the HDR buffer.

set_post_tonemap_kernel(enabled)

Toggle the standalone Taichi post-process tonemap kernel (vs the torch tonemap pipeline). The kernel reuses the in-composite tonemap ti.funcs and computes in f32, recovering most of the cost the move to post-process tonemapping added (the torch tonemap ran ~20 ops/pixel over every frame). Kill-switch / A-B hook.

set_project_on_gpu(enabled)

Toggle GPU-side project_to_screen (see project_on_gpu).

set_pt_authored_light_sampling(value)

Select how the path tracer lights authored-appearance materials.

One of "off", "auto" (the default) or "always"; see pt_authored_light_sampling. Host-side, read at the start of each render call, so both arms run in one process.

set_raster_bez_precompute(enabled)

Toggle the batched circuit screen-bounds precompute in the hybrid raster front-end (see raster_bez_precompute).

set_raster_covered_shade(enabled)

Toggle the covered-pixel-compacted raster resolve (see raster_covered_shade).

set_raster_empty_skip(enabled)

Toggle the empty-pixel fast path of the hybrid raster resolve (see raster_empty_skip).

set_raster_fused_gather(enabled)

Toggle the fused six-array fragment gather (see raster_fused_gather). Takes effect at the next batch’s emission.

set_raster_opaque_trunc_kernel(enabled)

Toggle the kernel opaque-prefix truncation mask (see raster_opaque_trunc_kernel). Takes effect at the next batch’s emission.

set_raster_pair_expand_kernel(enabled)

Toggle the kernel pair-row expansion (see raster_pair_expand_kernel). Takes effect at the next batch’s emission.

set_raster_pair_flags(enabled)

Toggle the host-side per-frame candidate-class flags used to skip empty per-tile pair emission (see raster_pair_flags).

set_raster_span_candidates(enabled)

Toggle row-span pair candidates (see raster_span_candidates). Takes effect at the next batch’s emission.

set_raster_sparse_coverage(enabled)

Toggle the exact covered-pixel lifecycle of the hybrid raster path.

set_raster_ss(enabled)

Toggle screen-space rasterization in the hybrid raster front-end (see raster_ss).

set_raster_straddle_clip(enabled)

Toggle the camera-plane clip of hybrid-raster candidate bboxes (see raster_straddle_clip).

set_raster_tri_precompute(enabled)

Toggle the batched triangle screen-bounds precompute in the hybrid raster front-end (see raster_tri_precompute).

set_raster_write_compact(enabled)

Toggle the write-pass pair compaction (see raster_write_compact). Takes effect at the next render batch.

set_rgb_shadow_tint(enabled)

Toggle colored shadow tinting/absorption (see rgb_shadow_tint).

Because the gate compiles into the kernels, this takes effect for kernels compiled AFTER the call – existing variants are reused. For a guaranteed switch, set ALGAN_RGB_SHADOW_TINT before importing algan or run the other arm in its own process.

set_samples_per_pixel(samples)

Set how many rays are averaged per pixel. 1 (the default) uses the exact deterministic renderer; larger values enable Monte Carlo path tracing with that many samples.

set_shadow_adaptive_taps(enabled)

Toggle the adaptive sub-pixel shadow fan (see shadow_adaptive_taps). Takes effect at the next render batch.

set_shadow_anyhit(enabled)

Select the shadow-query early-out mode (see shadow_anyhit).

True enables the opaque any-hit walks, the string "gather" the kbuf gather-march, False the classic ordered march. Takes effect at the next render batch.

set_shadow_eps_relative(value)

Set the shadow acceptance floor as a fraction of scene scale (see shadow_eps_relative). Takes effect at the next render batch.

set_shadow_identity_reject(enabled)

Toggle self-shadow rejection by identity (see shadow_identity_reject). Takes effect at the next render batch.

set_shadow_near_fraction(value)

Set the same-mesh share of the shadow acceptance floor (see shadow_near_fraction). Takes effect at the next render batch.

set_shadow_sided_cull(enabled)

Toggle the one-sided back-face shadow cull (see shadow_sided_cull). Takes effect at the next render batch.

set_shadow_terminator(enabled)

Toggle the shadow-terminator offset (see shadow_terminator).

True/False switch it on/off; the string "relax" (or a value equal to 2) selects mode 2, the diagnostic guard-relaxation-only arm. Anything else is read for truth: None and 0 are off, other numbers are on. Takes effect at the next render batch.

Selecting mode 2 needs an EXACT 2, and that is deliberate. It is the arm whose images are knowingly wrong, so nothing should land on it by rounding: an earlier version truncated with int(enabled) == 2 and quietly put 2.5 there, while routing np.int32(2) and np.float64(2.0) – the same number in two dtypes – to different arms, because only the latter passes isinstance(x, float). Comparing by value fixes both.

set_shadows(enabled)

Toggle hard shadows in the deterministic ray tracer.

When enabled, every shaded triangle/PN fragment traces one shadow ray per scene point light. Every partially opaque surface between the fragment and light attenuates its direct diffuse/specular term by 1 - opacity; stacked surfaces multiply, while a fully opaque surface blocks it. Ambient and emissive terms remain unchanged. Shadows are evaluated inside the wavefront shade kernel’s per-fragment lighting model, so this implies set_fragment_shading() for the render. Lights with a non-zero shadow_radius / shadow_angle get soft shadows via a deterministic fan of SOFT_SHADOW_SAMPLES rays; a RectAreaLight’s rows do too – each integrating visibility over its own cell of the emitter grid – when area_light_soft_shadows is on (the default). Refractive glass transport still needs the physical path tracer (set_samples_per_pixel(n) with n > 1). Only the deterministic renderer (set_samples_per_pixel(1), non-physical) is affected. Set before rendering.

set_sheet_band_stats_kernel(enabled)

Toggle the fused per-band order stats / dominant fragment scan (see sheet_band_stats_kernel). Takes effect at the next batch’s compaction.

set_sheet_mask_kernel(enabled)

Toggle the kernel sample-mask reductions in sheet compaction (see sheet_mask_kernel). Takes effect at the next batch’s emission.

set_sheet_one_mesh_kernel(enabled)

Toggle the kernel one-mesh reduction in the sparse emission (see sheet_one_mesh_kernel). Takes effect at the next batch’s emission.

set_sheet_positioned_depth(enabled)

Toggle positioned-fragment sheet ordering (see sheet_positioned_depth). Takes effect at the next batch’s emission.

set_sheet_rank_kernel(enabled)

Toggle the kernel conflict-rank scan in sheet compaction (see sheet_rank_kernel). Takes effect at the next batch’s emission.

set_sheet_resolve(enabled)

Toggle the sheet-compaction resolve (DESIGN_sheet_resolve.md).

set_sheet_resolve_memo(enabled)

Toggle the shadowed resolve’s cross-pass material memo (see sheet_resolve_memo). Takes effect at the next resolve launch.

set_sheet_sample_depth(enabled)

Toggle per-sample depth gating of interpenetrating sheets (see sheet_sample_depth). Takes effect at the next batch’s compaction.

set_sheet_sample_depth_kernel(enabled)

Toggle the kernel lane-owner scan of sheet_sample_depth (see sheet_sample_depth_kernel). Takes effect at the next batch’s emission.

set_sheet_shade_split(enabled)

Toggle the crease shading-class split in sheet compaction (see sheet_shade_split). Takes effect at the next batch’s emission.

set_sheet_shell_ceiling_kernel(enabled)

Toggle the kernel solid-shell ceiling application (see sheet_shell_ceiling_kernel). Takes effect at the next batch’s compaction.

set_sliver_split(max_pieces=None, aspect=None, min_piece=None)

Configure the sliver leaf split (see sliver_split_max_pieces). Arguments left None keep their value. Takes effect at the next batch’s BVH build.

set_texture_content_dedup(enabled)

Toggle texture-bank content dedup (see texture_content_dedup). Takes effect at the next batch’s scene merge.

set_texture_opacity_in_kernel(enabled)

Toggle the in-sampler texture opacity multiply (see texture_opacity_in_kernel). Takes effect at the next primitive build.

set_texture_time_flat(enabled)

Toggle per-map texture time lengths (see texture_time_flat). Takes effect at the next batch’s scene merge.

set_texture_time_lerp(enabled)

Toggle in-kernel texture time interpolation (see texture_time_lerp). Takes effect at the next frame batch.

set_texture_u8_storage(enabled)

Toggle u8 color-map storage (see texture_u8_storage). Takes effect at the next batch’s scene merge.

set_texture_window_collapse(enabled)

Toggle the static color-texture window collapse (see texture_window_collapse). Takes effect at the next primitive build.

set_tonemap_exposure(exposure)

Set the exposure multiplier applied to the frame before it is encoded.

The color is multiplied by this before the tonemap curve runs, and – since tonemapping is off by default – before the plain clamp too, so it brightens or darkens the whole render either way. Defaults to 1.0, which is exact: it moves no pixel.

This is the right control for “the whole scene is too dark”. Reach for it before raising every light’s intensity.

set_tonemap_method(method)

Set the tonemapping method (“neutral” or “agx”).

set_tonemapping(enabled)

Enable or disable tonemapping of the rendered frame.

Off by default, which makes output linear: an authored color lands on the pixel it names, white renders as 255, and a primary stays primary.

Enabling it applies the curve selected by set_tonemap_method() (“neutral”, the Khronos PBR Neutral mapper, or “agx”) – not ACES, whatever the old docstring said. That buys highlight roll-off, so values above 1.0 stay distinguishable instead of clipping flat, and it costs a shift on every value: the curve is not the identity anywhere except at 0, an authored 255 renders as 222, and saturated colors desaturate. The two are not separable – a curve that is the identity on [0, 1] must clamp above it – so this is a choice about which you would rather have. TONEMAP_FINDINGS.md has the measurements.

This flag is honoured wherever the tonemap actually runs, so it works on its own – with post_process_tonemap on (the default) the composite writes linear HDR and the post stage simply clamps instead of applying a curve. There is no need to also disable post_process_tonemap, and doing so costs HDR headroom (see set_post_process_tonemap()).

set_unsupported_feature_policy(policy)

Set unsupported-feature handling to error, warn, or ignore.

set_watertight_tri(enabled)

Toggle the watertight ray/triangle intersection (see watertight_tri).

The gate compiles into the kernels, so a variant that already exists bakes the previous value and no write reaches it. That is what KERNEL_COMPILED_IN_FIELDS is for: the next render job rebuilds the Taichi program instead of reusing those variants, so both arms are right in one process and the switch costs a kernel-preparation pass rather than a wrong picture. Set ALGAN_WATERTIGHT_TRI before importing algan to choose an arm without paying for the switch. (The Taichi offline cache is not a hazard here: it keys on the compiled IR, so each arm has its own entry.)

set_wavefront_tile_auto(enabled)

Toggle adaptive (pool-sized) wavefront tile sizing (see wavefront_tile_auto). Off falls back to the fixed wavefront_tile_rays.

set_weld_surface_seams(enabled)

Toggle surface seam/pole welding (see weld_surface_seams).

Takes effect on the next primitive build.

set_wf_deferred_shadows(enabled)

Toggle the bounce loop’s deferred shadow events (see wf_deferred_shadows). Takes effect at the next render batch.

set_wf_gen_fused(mode)

Set fused primary-ray generation on the deterministic wavefront: True/False force it on/off; "auto" (default) starts unfused for fast startup and enables it mid-render when the forecasted remaining render time justifies compiling the fused kernel variants. All modes are byte-identical (see wf_gen_fused).

set_wf_ray_sort(enabled)

Toggle the drain’s spatial ray ordering (see wf_ray_sort). Takes effect at the next render batch.

set_wf_ray_sort_min(count)

Smallest active-ray count the drain bothers to sort (see wf_ray_sort). Takes effect at the next render batch.

set_wf_shadow_event_sort(enabled)

Toggle the Morton ordering of deferred shadow events (see wf_shadow_event_sort). Takes effect at the next render batch.

shadow_terminator_mode()

Live shadow-terminator mode as an int: 0 off, 1 Hanika offset + the relaxed guard (the default), 2 the diagnostic relax-only arm.

Read at call time (never imported by value) and returned as an int, because it reaches the resolve/shade kernels as a TEMPLATE value: each mode compiles its own kernel variant, so the offline cache cannot serve one mode’s kernel for another (see glossy_reflection_mode).

sparse_discovery_bytes_for_frames(num_frames)

Reserved arena bytes for the sparse-coverage discovery over num_frames frames (0 until the first discovery of the job establishes a density).

texture_opacity_in_kernel_active()

Whether primitive builds should hand opacity to the sampler.

One predicate for every decision point (Surface / TriangleMesh builds, the estimators) so a build cannot half-flip. The merge itself keys off the PRIMITIVE (texture_opacity is not None), so a setting change between a build and its merge stays coherent. Requires texture_time_flat (the opacity region rides the flattened bank’s row addressing).

texture_time_lerp_active()

Whether frame batches may describe texture windows as segments.

One predicate for the timeline gate and the estimators. The primitive build and the merge key off the DESCRIPTION instead (a stashed segment window / texture_lerp on the primitive), so a setting change mid-batch stays coherent: the batch finishes in whichever mode its materialization ran. Requires the in-kernel opacity multiply – the legacy host premultiply folds the animated opacity into the texels, which endpoint maps cannot represent.

wf_gen_fused_active()

Live effective value of the fused-generation toggle (resolves "auto" to the adaptive decision).