Frame settings & post-processing

Shade has one frame, and it is configured by plain fields on the Renderer rather than by composing effects. There is no post-process stack to build and nothing to register: every stage below already exists in the frame and is switched on or off where it stands. Reach the renderer from an application as engine.graphics.renderer, or hold the Renderer you constructed yourself.

const renderer = engine.graphics.renderer;   // null before Engine.start(), null again after stop()

renderer.feature_motion_blur_enabled = true;
renderer.motion_blur.strength = 2.0;

renderer.feature_dof_enabled = true;
renderer.dof.applyPreset("cinematic");
renderer.dof.focusOnNearest();

GraphicsEngine deliberately exposes almost none of this itself - renderer is the escape hatch, and it is null outside a started engine, so check it. See Rendering overview for the facade.

Feature switches

Every one is a boolean on Renderer, readable and writable at any time. Defaults are read from shade/renderer/Renderer.js.

Non-boolean knobs on the same object:

Transparency itself cannot be switched off - that flag is private and always on. What is public is which order-independent technique draws it:

GPU particles draw as a side channel of the AVBOIT pass - through the same volume and the same accumulators as the transparent meshes, which is what makes them composite correctly against those meshes and against the opaque scene without a depth sort of their own. Under MBOIT they are simulated and not drawn.

Order in the frame

The post chain is fixed. Reading Renderer.render_to_target top to bottom, after the scene is complete and transparency has been composited:

AfterTransparency   extensions run here; HDR, internal resolution
  path tracer override      feature_path_tracing_enabled
  velocity debug view       feature_velocity_debug_view
  TAA  or  NSS              feature_taa_enabled + upscale_type   <-- resolution changes here
  depth of field            feature_dof_enabled + dof_algorithm
  motion blur               feature_motion_blur_enabled
  RCAS sharpen              feature_sharpening_enabled
  bloom + auto-exposure     feature_bloom_enabled / feature_automatic_exposure_enabled
BeforePresent       extensions run here; HDR, output resolution
  tone map                  always
Overlay             extensions run here; display space, drawing onto the canvas

Ambient occlusion, reflections, ReSTIR DI, shadows and the indirect-lighting mode all act earlier, during the deferred resolve, and so are not in this list. The phases named on the left are where render extensions attach.

Resolution

The two derivations, verbatim:

output_resolution   = clamp(ceil(css_size * pixel_ratio),          1,  maxTextureDimension2D)
internal_resolution = clamp(floor(output_resolution * scale),     16,  maxTextureDimension2D)

The floor of 16 px is not arbitrary: depth and G-buffer textures carry 5 mip levels, and allocation fails below 2^4.

Both a resize and an internal-resolution change call indicate_view_change(), which resets TAA, NSS, SSR and path-tracer history - resizing destroys the ping-pong depth textures, including the one holding last frame’s depth, and reprojection would otherwise read zeros. indicate_view_change() is public: call it yourself after teleporting a camera or swapping a scene.

Under Engine, do not call resize directly. engine.graphics.updateSize() passes the viewport size to renderer.resize(), and is already wired to the viewport’s size.onChanged. There is no engine-level pixel ratio: render scale is internal_resolution_scale, which renders the frame smaller and lets TAA upscale it, rather than the browser stretching a smaller canvas.

Dynamic resolution scaling

DynamicResolutionScaling (shade/renderer/DynamicResolutionScaling.js) is not owned by the renderer. It reads and writes internal_resolution_scale through two assignable functions, and is fed one number per frame.

Under Engine it is already built and wired:

const drs = engine.graphics.dynamic_resolution;

drs.enabled = false;        // e.g. for a benchmark that wants a fixed resolution
drs.target_frame_rate = 60; // the engine sets 30

It is a floor-holder, not a frame-rate governor: at the engine’s default target of 30 fps it does nothing at all until a frame costs more than 33 ms, and sits at full resolution on hardware that clears the budget.

Standalone, wire it yourself:

import { DynamicResolutionScaling } from "@woosh/meep-engine/src/shade/renderer/DynamicResolutionScaling.js";

const drs = new DynamicResolutionScaling();

drs.get_scale = () => renderer.internal_resolution_scale;
drs.set_scale = v => { renderer.internal_resolution_scale = v; };

// once per frame
drs.notify_frame(frame_time_seconds);

Also reset() and notify_frame(frame_time_s).

The upscaler

Both upscalers consume the jittered, internal-resolution scene colour and produce an output-resolution image; they differ only in how the resolve is computed.

The upscale is a phase boundary, and it is the one thing about the frame you cannot assume away. AfterTransparency is at internal resolution; BeforePresent and Overlay are at output resolution. The G-buffer stays readable to BeforePresent and is therefore a different size from the colour beside it there. Never write a resolution down as a constant - ask frame.resolution, or frame.describe(handle) for the ratio between two of them.

Two consequences worth stating:

• With feature_taa_enabled === false there is no upscale at all. The two sides of the boundary are the same size, which is correct only while internal_resolution_scale is 1; with TAA off and the scale below 1, the frame is presented at internal resolution rather than upscaled.
• The jitter sequence length is derived from the upscale ratio at every resolution change, for whichever upscaler is selected. Nothing to set.

renderer.nss is constructed lazily on first access, which is also when the bundled weights blob decodes - so selecting NSS costs one frame and no setup. Its constructor installs the shipped weights; nss.weights = NSSWeights.from(...) replaces them with trained weights from elsewhere. Tuning fields include jitter_sequence_size, alpha_blend_scale, reset_history and debug_view, plus a dozen network-tuning scalars.

Sub-objects

Seven settings objects hang off the renderer. All are constructed for you; nss and path_tracer are lazy, the rest are built in initialize().

Screen-space reflections

SSR traces screen-space depth, resolves against the selected indirect-lighting source, filters spatially and reprojects history. Configure it after the renderer initializes:

import { SSRReprojectionMode }
    from "@woosh/meep-engine/src/shade/renderer/postprocess/ssr/SSRReprojectionMode.js";

renderer.feature_ssr_enabled = true;
renderer.ssr.reprojection_mode = SSRReprojectionMode.Parallax;
renderer.ssr.spatial_denoising_enabled = true;

Changing either mode or spatial filtering resets history. History is also invalidated when the resolution, view or indirect-lighting mode changes, or frames are skipped. A recorded frame becomes reusable history only after successful submission.

MotionBlur

One knob: strength, default 1.0. 1.0 is physically plausible, 2.0-3.0 reads as cinematic.

DepthOfField and DepthOfFieldU

Two implementations behind one interface. DepthOfField is a screen-space ray-march (the Tiny Glade model: aperture sub-rays marched through a half-res depth/CoC buffer, plus tilt-shift); DepthOfFieldU is an Unreal-style Diaphragm/Cinematic gather with a foreground coverage bleed. They share every field below.

DepthOfField adds march_mode; DepthOfFieldU adds near_blur_gain (default 1.0).

Focus is set through helpers rather than by writing focus directly: focusAuto(), focusAtDistance(d), focusOnWorldPoint(x, y, z), focusOnScreenPoint(x, y), focusOnNearest(), focusOnObject(node).

applyPreset(name) takes one of subtle, portrait, cinematic, miniature, dreamy (exported as DOF_PRESETS / DOF_PRESET_NAMES from postprocess/dof/DOF_PRESETS.js).

ReSTIRDI

AccumulatingPathTracer

Tone mapping and exposure

Tone mapping is the last pass before the canvas and there is no operator to choose. Which of the two shaders runs is decided by the display, through matchMedia("(dynamic-range: high)"), and re-decided whenever that query changes.

Peak brightness is assumed rather than queried (1000 nits on an HDR display, 80 on SDR) because the browser does not report it, and it is not settable.

Exposure is a single scalar multiplied into the colour just before the curve:

• With feature_automatic_exposure_enabled on (the default), it comes from a luminance histogram built over the bloom chain’s downsampled image and adapted over time.
• With it off, the value is 2 ^ exposure_compensation - f-stops, default 0.0 - so a bare feature_automatic_exposure_enabled = false leaves exposure at a fixed 1x. Anything comparing two renders wants adaptation off and this pinned, because eye adaptation keeps drifting for seconds after a change.

exposure_compensation asserts that the renderer has been initialized, so set it after initialize() / Engine.start().

Frame counter and profiling

renderer.frame_count is a read-only counter, incremented after each submitted frame. It indexes the temporal history and drives the TAA/NSS jitter sequence. renderer.onFrameFinished is a Signal carrying the same number.

renderer.profile_session is null and the renderer never makes one - the profiler is a leaf nothing else imports, so an application that does not mention it does not carry it. Assigning a session and the null checks around it are the whole integration:

import { GPUProfileSession } from "@woosh/meep-engine/src/shade/device/timing/profile/GPUProfileSession.js";
import { GPUProfileLevel } from "@woosh/meep-engine/src/shade/device/timing/profile/GPUProfileLevel.js";

const session = new GPUProfileSession({ level: GPUProfileLevel.TIMING });

renderer.profile_session = session;
session.start();
// ... frames ...
const bytes = session.stop();
renderer.profile_session = null;

GPU timings need the optional timestamp-query adapter feature. Shade takes it when offered and never requires it, so on a browser that withholds it the timers go quiet rather than the renderer refusing to start.

Present in the tree, absent from the frame

Several directories under src/shade/renderer/postprocess/ ship and are reachable by import, but nothing in the frame calls them. They are not features, and a switch for them does not exist.

Also unused: postprocess/velocity/graph_add_camera_velocity.js - only the per-object velocity variant is called, and that one runs every frame regardless of any switch.

See also

• Rendering overview - the GraphicsEngine facade and the device floor
• Render extensions - putting your own passes into the frame
• Global illumination - indirect_lighting_mode in full
• Lights & shadows - what the shadow switches govern
• Virtual texturing - what feature_virtual_textures gates