@volter/editor-threejs 0.5.66 → 0.5.68

package/src/kit/reflection-probe-helper.ts

@@ -0,0 +1,142 @@
+import { EDITOR_LAYER } from '@volter/editor-threejs/viewport/editor-layers';
+import { reflectionProbeOf } from '@volter/editor-threejs/adapter/reflection-probe';
+import { setUserData } from '@volter/editor-threejs/ecs/user-data';
+import * as THREE from 'three';
+
+const INFLUENCE = new THREE.Color(0x4aa8ff);
+const INFLUENCE_SELECTED = new THREE.Color(0x75c4ff);
+const PARALLAX = new THREE.Color(0xffb84a);
+const CAPTURE = new THREE.Color(0xffffff);
+
+/**
+ * Editor-only visualization for a project-owned reflection probe. It follows
+ * the live Object3D mark but owns every line and material it draws, so no
+ * helper enters the game's JSX tree or its runtime camera.
+ */
+export class ReflectionProbeHelper extends THREE.Group {
+  private signature = '';
+  private selected = false;
+
+  constructor(readonly source: THREE.Object3D) {
+    super();
+    this.name = 'Reflection Probe Helper';
+    this.matrixAutoUpdate = false;
+    this.renderOrder = 998;
+    setUserData(this, 'editorHelper', true);
+    setUserData(this, 'editorHelperType', 'reflection-probes');
+    this.layers.set(EDITOR_LAYER);
+    this.refresh(true);
+  }
+
+  setSelected(selected: boolean): void {
+    if (this.selected === selected) return;
+    this.selected = selected;
+    this.refresh(true);
+  }
+
+  update(): void {
+    this.refresh(false);
+    this.source.updateWorldMatrix(true, false);
+    this.matrix.copy(this.source.matrixWorld);
+    this.matrixWorldNeedsUpdate = true;
+  }
+
+  dispose(): void {
+    this.clearVisuals();
+    this.removeFromParent();
+  }
+
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: each branch draws one independently meaningful probe volume.
+  private refresh(force: boolean): void {
+    const probe = reflectionProbeOf(this.source);
+    if (!probe) return;
+    const config = probe.config;
+    const next = JSON.stringify(config);
+    if (!force && next === this.signature) return;
+    this.signature = next;
+    this.clearVisuals();
+
+    const influenceColor = this.selected ? INFLUENCE_SELECTED : INFLUENCE;
+    const influenceOpacity = this.selected ? 1 : 0.62;
+    const blend = Math.max(0, config.blendDistance);
+
+    if (config.shape === 'sphere') {
+      const radius = Math.max(0.01, config.radius);
+      this.addWire(new THREE.SphereGeometry(radius, 24, 16), influenceColor, influenceOpacity);
+      if (blend > 0 && radius - blend > 0.01) {
+        this.addWire(
+          new THREE.SphereGeometry(radius - blend, 20, 12),
+          influenceColor,
+          this.selected ? 0.55 : 0.28,
+        );
+      }
+    } else {
+      const [x, y, z] = config.size.map((value) => Math.max(0.01, value)) as [
+        number,
+        number,
+        number,
+      ];
+      this.addWire(new THREE.BoxGeometry(x, y, z), influenceColor, influenceOpacity);
+      const inner = [x - blend * 2, y - blend * 2, z - blend * 2] as const;
+      if (blend > 0 && inner.every((value) => value > 0.01)) {
+        this.addWire(
+          new THREE.BoxGeometry(inner[0], inner[1], inner[2]),
+          influenceColor,
+          this.selected ? 0.55 : 0.28,
+        );
+      }
+    }
+
+    if (config.parallaxProjection) {
+      const [x, y, z] = config.parallaxSize.map((value) => Math.max(0.01, value)) as [
+        number,
+        number,
+        number,
+      ];
+      const box = this.addWire(
+        new THREE.BoxGeometry(x, y, z),
+        PARALLAX,
+        this.selected ? 0.9 : 0.45,
+      );
+      box.position.fromArray(config.parallaxOffset);
+    }
+
+    const origin = this.addWire(
+      new THREE.OctahedronGeometry(this.selected ? 0.16 : 0.11),
+      CAPTURE,
+      this.selected ? 1 : 0.72,
+    );
+    origin.position.fromArray(config.captureOffset);
+    this.traverse((object) => object.layers.set(EDITOR_LAYER));
+  }
+
+  private addWire(
+    sourceGeometry: THREE.BufferGeometry,
+    color: THREE.Color,
+    opacity: number,
+  ): THREE.LineSegments {
+    const geometry = new THREE.EdgesGeometry(sourceGeometry);
+    sourceGeometry.dispose();
+    const material = new THREE.LineBasicMaterial({
+      color,
+      depthTest: false,
+      transparent: true,
+      opacity,
+      toneMapped: false,
+    });
+    const wire = new THREE.LineSegments(geometry, material);
+    wire.renderOrder = this.renderOrder;
+    this.add(wire);
+    return wire;
+  }
+
+  private clearVisuals(): void {
+    for (const child of [...this.children]) {
+      child.removeFromParent();
+      const line = child as THREE.LineSegments;
+      line.geometry?.dispose();
+      const materials = Array.isArray(line.material) ? line.material : [line.material];
+      for (const material of materials) material?.dispose();
+    }
+  }
+}

package/src/kit/scene-document-viewport.ts

@@ -0,0 +1,51 @@
+/**
+ * THE SCENE'S VIEWPORT (`@volter/editor-sdk/kit/document-viewports`): the world
+ * stage draws the Scene through the session store's own camera, shading and
+ * grid, and frames the shell's selection. It keeps no selection of its own, so a
+ * view's selection is the shell's.
+ */
+import type { DocumentViewport } from '@volter/editor-sdk/kit/document-viewports';
+import type { EditorShellStore } from './editor-shell-store';
+import { viewGridVisible } from '@volter/editor-sdk/kit/viewport-presentation';
+
+type ShadingMode = Parameters<EditorShellStore['setShadingMode']>[0];
+
+const SCENE_MODES = new Set<string>(['solid', 'clay', 'unlit', 'wireframe', 'normals', 'overdraw']);
+
+export function sceneDocumentViewport(store: EditorShellStore, documentId: string): DocumentViewport {
+  return {
+    read: () => {
+      const pose = store.cameraPose;
+      if (!pose) return null;
+      const { position, target } = pose;
+      return {
+        camera: {
+          position: { x: position.x, y: position.y, z: position.z },
+          target: { x: target.x, y: target.y, z: target.z },
+          ...(pose.fov ? { fov: pose.fov } : {}),
+        },
+        diagnostic: store.shadingMode,
+        grid: viewGridVisible(documentId),
+      };
+    },
+    setDiagnostic: (diagnostic) => {
+      if (!SCENE_MODES.has(diagnostic)) return false;
+      store.setShadingMode(diagnostic as ShadingMode);
+      return true;
+    },
+    setCamera: (camera) => {
+      if (typeof camera !== 'string') {
+        store.shell.setCameraPose(camera.position, camera.target, camera.fov);
+        return true;
+      }
+      if (camera === 'isometric') return false;
+      store.shell.setViewPreset(camera);
+      return true;
+    },
+    frame: (target) => {
+      if (target === 'document') return false;
+      store.shell.focusOnSelection();
+      return true;
+    },
+  };
+}

package/src/kit/scene-framing.ts

@@ -0,0 +1,315 @@
+/**
+ * What the editor camera should look at when it adopts a world nobody authored
+ * here — the two answers behind `EditorViewport.focusOnScene`.
+ *
+ * ## The measured defect
+ *
+ * Auto-frame framed the game's ENTIRE content AABB. Measured on a Cuberun
+ * mount: a 2,000-radius BackSide skybox sphere, a sun mesh at `z = -2000` and a
+ * hyperspace prop at `z ≈ -5365` stretched that AABB to ~8,400 units deep, so
+ * the fit distance landed the camera 12,870 units away from a ~1,000-unit
+ * gameplay corridor. 93% of the Scene viewport was black, and the one visible
+ * thing was the OUTSIDE of the skybox. The same world framed at working
+ * distance is vivid and correct. (Descent measured the same looseness at a
+ * smaller scale: a camera at ~2,580 for an ~800-unit world.)
+ *
+ * The union is the wrong instrument because a backdrop is not content the
+ * reader is looking FOR — it is content that exists to be far away. One prop
+ * 5,000 units out costs the whole framing, and no amount of care in the fit
+ * math can recover it.
+ *
+ * ## The two answers, in order
+ *
+ * 1. {@link viewFromGameCamera} — a game's author already decided the
+ *    interesting view, so seeding the orbit camera from the world matrix of a
+ *    camera the game itself placed opens the Scene tab where the game looks.
+ *    {@link pickGameCamera} decides which camera that is.
+ * 2. {@link frameableContentBounds} — the fallback for a game whose camera we
+ *    cannot name. It trims outliers off the union before framing.
+ *
+ * ## Why gap-trimming and not a percentile
+ *
+ * A blanket percentile (frame the inner 90% of content) would tighten the
+ * framing of EVERY world, including the uniform ones that are framed correctly
+ * today. This trims only across a spatial GAP: a face of the bounding box moves
+ * inward only when a small share of boxes sits beyond a void spanning a large
+ * fraction of the current diagonal. A uniformly-filled world has no such gap,
+ * so it comes back byte-identical to the plain union — that identity is the
+ * first property the tests pin.
+ */
+
+import { isEditorOwnedObject } from '@volter/editor-threejs/viewport/editor-layers';
+import * as THREE from 'three';
+
+/** Tuning for {@link frameableContentBounds}. Defaults are the shipped values. */
+export interface FrameableBoundsOptions {
+  /** Largest share of the boxes all trimming together may discard. */
+  maxOutlierFraction?: number;
+  /** A gap must span this share of the current content diagonal to be a gap. */
+  minGapFraction?: number;
+  /** Below this many boxes there is no distribution to judge; nothing trims. */
+  minSampleSize?: number;
+  /** Cap on trim passes, so cost stays bounded on a huge world. */
+  maxPasses?: number;
+}
+
+const DEFAULTS: Required<FrameableBoundsOptions> = {
+  maxOutlierFraction: 0.1,
+  minGapFraction: 0.2,
+  minSampleSize: 8,
+  maxPasses: 8,
+};
+
+/** Orbit pivot distance when there is no content to measure one from. */
+const EMPTY_CONTENT_PIVOT_DISTANCE = 10;
+
+/** How far down the view axis the content must start for the pivot to mean
+ *  anything — as a share of the content's own radius. */
+const MIN_PIVOT_RADIUS_FRACTION = 0.01;
+
+type Axis = 'x' | 'y' | 'z';
+const AXES: readonly Axis[] = ['x', 'y', 'z'];
+
+function unionOf(boxes: readonly THREE.Box3[], indices: Iterable<number>): THREE.Box3 {
+  const out = new THREE.Box3();
+  for (const i of indices) out.union(boxes[i] as THREE.Box3);
+  return out;
+}
+
+/** One candidate trim: the boxes beyond the widest gap on one box face. */
+interface GapCut {
+  gap: number;
+  discard: number[];
+}
+
+/**
+ * The widest gap found scanning inward from any of the six faces, across at
+ * most `budget` boxes.
+ *
+ * Scanning from a FACE (rather than clustering centers) is what catches a
+ * skybox: its centre sits with the content, and only its extent is an outlier.
+ */
+function widestOuterGap(
+  boxes: readonly THREE.Box3[],
+  kept: ReadonlySet<number>,
+  budget: number,
+): GapCut | null {
+  let best: GapCut | null = null;
+  for (const axis of AXES) {
+    for (const side of ['min', 'max'] as const) {
+      const values: Array<{ i: number; v: number }> = [];
+      for (const i of kept) values.push({ i, v: (boxes[i] as THREE.Box3)[side][axis] });
+      // Outliers are the smallest values on a min face and the largest on a max
+      // face; sort so index 0 is always the outermost.
+      values.sort((a, b) => (side === 'min' ? a.v - b.v : b.v - a.v));
+      const reach = Math.min(budget, values.length - 1);
+      for (let k = 0; k < reach; k++) {
+        const gap = Math.abs((values[k + 1] as { v: number }).v - (values[k] as { v: number }).v);
+        if (best && gap <= best.gap) continue;
+        best = { gap, discard: values.slice(0, k + 1).map((e) => e.i) };
+      }
+    }
+  }
+  return best;
+}
+
+/**
+ * The box worth FRAMING, given one world-space box per content node.
+ *
+ * Returns the plain union whenever there is nothing defensible to trim: too few
+ * boxes to judge, no gap wide enough, or a budget of zero. Never returns an
+ * empty box for non-empty input.
+ */
+export function frameableContentBounds(
+  boxes: readonly THREE.Box3[],
+  options: FrameableBoundsOptions = {},
+): THREE.Box3 {
+  const opts = { ...DEFAULTS, ...options };
+  const content = boxes.filter((b) => !b.isEmpty());
+  const all = content.map((_, i) => i);
+  const full = unionOf(content, all);
+  if (content.length < opts.minSampleSize) return full;
+
+  let budget = Math.floor(content.length * opts.maxOutlierFraction);
+  if (budget < 1) return full;
+
+  const kept = new Set(all);
+  let bounds = full;
+  const size = new THREE.Vector3();
+  for (let pass = 0; pass < opts.maxPasses && budget > 0; pass++) {
+    const diagonal = bounds.getSize(size).length();
+    if (!(diagonal > 0)) break;
+    const cut = widestOuterGap(content, kept, budget);
+    if (!cut || cut.gap <= opts.minGapFraction * diagonal) break;
+    for (const i of cut.discard) kept.delete(i);
+    budget -= cut.discard.length;
+    bounds = unionOf(content, kept);
+  }
+  return bounds.isEmpty() ? full : bounds;
+}
+
+/** An orbit-camera pose: where the eye sits and what it orbits around. */
+export interface SeededView {
+  position: THREE.Vector3;
+  target: THREE.Vector3;
+}
+
+/**
+ * The editor orbit pose that reproduces `camera`'s own view.
+ *
+ * The eye is the game camera's world position and the view direction is its
+ * own; the only thing invented is the orbit PIVOT, which is placed at the depth
+ * of the content along that view direction — the point the reader is already
+ * looking at, so the first orbit drag turns around the world rather than
+ * around a point behind their head.
+ *
+ * Returns `null` when that pivot cannot be placed: the world sits BEHIND the
+ * camera (a view showing none of the game is not worth adopting), or it sits
+ * ON it, which leaves an orbit pivot at the eye — measured as a target
+ * 4.6e-14 units out, an orbit control that can only spin in place. Both fall
+ * back to {@link frameableContentBounds}.
+ */
+export function viewFromGameCamera(camera: THREE.Camera, content: THREE.Box3): SeededView | null {
+  const forward = camera.getWorldDirection(new THREE.Vector3());
+  const position = new THREE.Vector3().setFromMatrixPosition(camera.matrixWorld);
+  if (!Number.isFinite(position.lengthSq()) || forward.lengthSq() === 0) return null;
+  if (content.isEmpty()) {
+    return {
+      position,
+      target: position.clone().addScaledVector(forward, EMPTY_CONTENT_PIVOT_DISTANCE),
+    };
+  }
+  const sphere = content.getBoundingSphere(new THREE.Sphere());
+  const along = sphere.center.clone().sub(position).dot(forward);
+  if (!(along > sphere.radius * MIN_PIVOT_RADIUS_FRACTION)) return null;
+  return { position, target: position.clone().addScaledVector(forward, along) };
+}
+
+/**
+ * The NDC points a seeded view is sampled at: the centre plus a ring at 60% of
+ * the way to each edge/corner. Nine rays — enough that a view whose middle is
+ * blocked by one prop still reads as open, cheap enough to run on every seed
+ * attempt over a whole game graph.
+ */
+const OCCLUSION_SAMPLES: ReadonlyArray<readonly [number, number]> = [
+  [0, 0],
+  [-0.6, 0.6],
+  [0.6, 0.6],
+  [-0.6, -0.6],
+  [0.6, -0.6],
+  [0, 0.6],
+  [0, -0.6],
+  [-0.6, 0],
+  [0.6, 0],
+];
+
+/**
+ * How near a hit has to be, as a share of the view's own pivot distance, to
+ * count as "pressed against the lens" rather than "part of the world". At 2%,
+ * a camera looking 100 units into a world is blocked only by something inside
+ * 2 units of it.
+ */
+const NEAR_FIELD_FRACTION = 0.02;
+
+const _raycaster = new THREE.Raycaster();
+const _ndc = new THREE.Vector2();
+
+/** Three's raycast reports hits on invisible objects; a hidden collider proxy
+ *  in front of the lens blocks nothing a reader would see. */
+function isVisibleInWorld(object: THREE.Object3D): boolean {
+  for (let node: THREE.Object3D | null = object; node; node = node.parent) {
+    if (!node.visible) return false;
+  }
+  return true;
+}
+
+/**
+ * Does a view posed HERE show the world, or a surface pressed against the lens?
+ *
+ * The measured defect: a game's own camera is placed for the game's own moment
+ * — inside a cockpit, behind a wall it is about to drive through, under
+ * terrain that has not settled — and adopting it as the editor's opening view
+ * can hand the reader a full-bleed rectangle of rock. The view is a perfectly
+ * good gameplay camera and a useless first look, and nothing in the pose
+ * itself says which.
+ *
+ * The instrument is geometric, not pixels: nine rays through the frustum, and
+ * a view SHOWS THE WORLD when at least one of them either escapes (sky,
+ * backdrop, open space) or reaches something farther than
+ * {@link NEAR_FIELD_FRACTION} of what this view claims to be looking at. The
+ * threshold is relative to the view's own pivot distance, so it needs no
+ * world-scale constant and reads the same on a 10-unit room and a 10,000-unit
+ * canyon.
+ *
+ * Deliberately conservative: EVERY sample must be blocked in the near field
+ * before the view is refused, so an ordinary view with a prop in the middle or
+ * ground filling its lower half still passes. A refusal here costs the reader
+ * only the game's own camera — the caller falls back to
+ * {@link frameableContentBounds}, which always shows something.
+ *
+ * Three's raycast honours `material.side` exactly as the renderer does, and
+ * that alignment is the reason this instrument is honest rather than merely
+ * cheap: a camera sealed inside a front-faced solid is invisible to BOTH — the
+ * reader sees through the shell, the rays escape through it, and the view is
+ * correctly not called blocked. The failure this catches is the one that is
+ * actually on screen: front faces, filling the frame, right at the lens.
+ *
+ * (The screenshot lane measures the same failure from the other side, on
+ * PIXELS, in `composite-screenshot.ts`. That instrument needs a drawn frame
+ * and a GPU readback, and it cannot tell a legitimately flat picture from a
+ * blocked one — which is why the decision to adopt a pose is made here, before
+ * anything is drawn.)
+ */
+export function seededViewShowsWorld(
+  camera: THREE.Camera,
+  content: readonly THREE.Object3D[],
+  pivotDistance: number,
+): boolean {
+  if (!(pivotDistance > 0) || content.length === 0) return true;
+  const nearField = pivotDistance * NEAR_FIELD_FRACTION;
+  for (const [x, y] of OCCLUSION_SAMPLES) {
+    _ndc.set(x, y);
+    _raycaster.setFromCamera(_ndc, camera);
+    const hits = _raycaster.intersectObjects(content as THREE.Object3D[], true);
+    const blocker = hits.find((hit) => isVisibleInWorld(hit.object));
+    if (!blocker || blocker.distance > nearField) return true;
+  }
+  return false;
+}
+
+/** Every camera in the game's own scene, in scene order, editor furniture and
+ *  its subtrees excluded. */
+function gameCameras(node: THREE.Object3D, out: THREE.Camera[] = []): THREE.Camera[] {
+  if (isEditorOwnedObject(node)) return out;
+  if ((node as THREE.Camera).isCamera) out.push(node as THREE.Camera);
+  for (const child of node.children) gameCameras(child, out);
+  return out;
+}
+
+/**
+ * The camera whose view an ingest mount should adopt — one the game itself
+ * CREATED AND PLACED, which means one that is in the game's own scene graph.
+ *
+ * The capture's own camera (the one the first `render(scene, camera)` used) is
+ * preferred WHEN it is one of those, and is otherwise ignored, because on the
+ * first rendered frame it can be a reconciler's placeholder rather than the
+ * author's camera. Measured on Cuberun: the captured camera came back with an
+ * identity world matrix at the origin while the game's own
+ * `<PerspectiveCamera position={[0, 10, -10]}>` was sitting in the scene at
+ * (0, 8, 3.5) looking down the corridor — seeding from the capture opened on a
+ * flat wall of ground plane, seeding from the scene's camera opened on the
+ * game.
+ *
+ * Editor furniture is never adopted: the capture trap sits on the shared
+ * `WebGLRenderer.prototype`, so the editor's own cameras are the one thing
+ * that must never come back from here.
+ */
+export function pickGameCamera(
+  captured: THREE.Camera | null | undefined,
+  scene: THREE.Object3D,
+): THREE.Camera | null {
+  const cameras = gameCameras(scene);
+  if (cameras.length === 0) return null;
+  if (captured && cameras.includes(captured)) return captured;
+  return cameras[0] as THREE.Camera;
+}

package/src/kit/scene-view-fog.ts

@@ -0,0 +1,89 @@
+import type * as THREE from 'three';
+
+/**
+ * Why the Scene viewport draws a world's fog OUT.
+ *
+ * ## The measured defect
+ *
+ * Fog is calibrated in metres from THE GAME'S OWN CAMERA. The racing-game
+ * mount declares `<fog args={['white', 0, 500]}>`, which is exactly right at
+ * its chase camera 20 units behind the car and meaningless anywhere else: its
+ * world is ~800 units across, so the editor framing that shows the whole track
+ * sits ~700 units back, and every visible surface is past the fog's far plane.
+ * Measured on that mount (2026-08-15): the framed Scene view is a featureless
+ * white blob — the track, the canyon and the horizon are all the same white.
+ *
+ * The Scene camera is not the game's camera. It is placed by framing, by a
+ * seed, or by the reader's own orbit, at whatever distance the world needs —
+ * so a distance-calibrated effect authored for another camera is not a look,
+ * it is an erasure.
+ *
+ * ## Why a view policy and not fog-aware framing
+ *
+ * The alternative was to have the framing respect the fog range — pick a
+ * distance inside it. It cannot work, and the numbers say so rather than an
+ * argument: this world's content diagonal is ~1,100 units against a fog far
+ * plane of 500, so no distance both shows the track and stays readable. Any
+ * fog-aware framing would have to stop showing the world to keep the fog,
+ * which is backwards — the first look exists to show the world.
+ *
+ * So the fog goes, as a VIEW POLICY, in the same class as the shading modes:
+ * presentation-only, restored before anything else can observe it, and applied
+ * only to the editor's own draw. This is also the established answer in the
+ * genre — Unity's Scene view renders fog OFF by default and offers it as a
+ * scene-view effect toggle, for exactly this reason.
+ *
+ * The game's own look is not touched anywhere it belongs: the Game tab, play
+ * mode and every exported build render the game's camera through the game's
+ * fog. Only the authoring camera is exempted, and there is deliberately no
+ * toggle for it — a Scene view that can be washed white by a setting is a
+ * fault the reader has to diagnose, and nothing here is worth that.
+ *
+ * ## Why the parameters and not `scene.fog = null`
+ *
+ * `!!scene.fog` is part of three's shader-program cache key, so nulling it for
+ * one draw and restoring it for the next compiles and keeps a SECOND program
+ * variant for every material in the world. Neutralising the fog's own numbers
+ * leaves the program identical and the fog term at zero.
+ */
+
+/** Far enough that no real depth reaches it; `near < far` keeps the linear
+ *  fog's `smoothstep(near, far, depth)` well-defined. */
+const NEUTRAL_FOG_NEAR = 1e20;
+const NEUTRAL_FOG_FAR = 2e20;
+
+type LinearFog = THREE.Fog & { isFog: true };
+type ExpFog = THREE.FogExp2 & { isFogExp2: true };
+
+/**
+ * Run `draw` with `scene`'s fog contributing nothing, then put it back exactly
+ * as it was — including when `draw` throws.
+ *
+ * A scene with no fog costs one property read.
+ */
+export function withSceneFogNeutralized(scene: THREE.Scene, draw: () => void): void {
+  const fog = scene.fog;
+  if (!fog) {
+    draw();
+    return;
+  }
+  const linear = (fog as LinearFog).isFog ? (fog as LinearFog) : null;
+  const exponential = (fog as ExpFog).isFogExp2 ? (fog as ExpFog) : null;
+  const near = linear?.near;
+  const far = linear?.far;
+  const density = exponential?.density;
+  if (linear) {
+    linear.near = NEUTRAL_FOG_NEAR;
+    linear.far = NEUTRAL_FOG_FAR;
+  }
+  if (exponential) exponential.density = 0;
+  try {
+    draw();
+  } finally {
+    if (linear && near !== undefined && far !== undefined) {
+      linear.near = near;
+      linear.far = far;
+    }
+    if (exponential && density !== undefined) exponential.density = density;
+  }
+}