@woosh/meep-engine 3.60.3 → 3.60.5

package/src/shade/renderer/atmosphere/shader_multiscatter_lut.js

@@ -1,164 +1,164 @@
-import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_get_multiscatter_values } from "./chunk_get_multiscatter_values.js";
-import { chunk_multiscatter_sample_direction } from "./chunk_multiscatter_sample_direction.js";
-import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
-import {
-    MULTISCATTER_LUT_DIRECTION_COUNT,
-    MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS
-} from "./MULTISCATTER_LUT_CONFIG.js";
-import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // "float" rather than the default "unfilterable-float": rgba16float is filterable in
-    // core WebGPU, so the LUT goes through the texture unit instead of a 4-tap manual
-    // bilinear.
-    .addTexture("tSkyLutTransmittance", "float")
-    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
-    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float")
-;
-
-
-/**
- * the multiple-scattering LUT. Each pixel coordinate corresponds to a height and sun zenith angle, and
- * the value is the multiple scattering approximation (Psi_ms from the paper, Eq. 10).
- *
- * One workgroup per LUT texel, one thread per direction, mirroring Hillaire's
- * `[numthreads(1,1,64)]` `NewMultiScattCS`. The 64 directions used to be a serial loop
- * inside a fragment shader, which left the whole pass with 32*32 = 1024 threads of
- * parallelism -- a few dozen waves, one per scheduler at best, with nothing to hide the
- * latency of the transmittance fetches. Per-thread it is now a single direction's 20-step
- * march.
- *
- * The per-direction results are summed with `subgroupAdd` and then across subgroups through
- * workgroup memory; Hillaire uses a six-step groupshared log-reduction, which the subgroup
- * op collapses into one instruction plus a handful of partials.
- *
- * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {CodeChunk}
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const MULTISCATTER_DIRECTION_COUNT = ${MULTISCATTER_LUT_DIRECTION_COUNT}u;
-const MULTISCATTER_MAX_SUBGROUP_PARTIALS = ${MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS}u;
-
-var<workgroup> wg_partial_count: atomic<u32>;
-var<workgroup> wg_lum: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
-var<workgroup> wg_fms: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
-
-@compute @workgroup_size(${MULTISCATTER_LUT_DIRECTION_COUNT}, 1, 1)
-fn main(
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(local_invocation_index) thread_index: u32,
-) {
-
-    if (thread_index == 0u) {
-        atomicStore(&wg_partial_count, 0u);
-    }
-
-    // Every thread is here together anyway, so the counter's initialisation costs nothing
-    // beyond the barrier itself. WGSL does not promise workgroup variables start zeroed.
-    workgroupBarrier();
-
-    // one workgroup per texel; the dispatch is sized from the texture, so this is in range
-    let texel = workgroup_id.xy;
-
-    let lut_size = vec2<f32>(textureDimensions(tSkyLutMultiscatterOut));
-
-    // The point of each range this texel stands for: texel 0 carries the bottom and the last
-    // texel the top, which is what lets a lookup at either end read a value computed there
-    // rather than one from half a texel inside. sky_lut_uv is the other half of this.
-    let unit = sky_lut_texel_to_unit(vec2<f32>(texel), lut_size);
-
-    let sunCosTheta = 2.0*unit.x - 1.0;
-    let sunTheta = safe_acos(sunCosTheta);
-
-    let height = ATMOSPHERE_HEIGHT*unit.y;
-
-    let pos = vec3(0.0, height, 0.0);
-    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
-
-    // pos on the +y axis and sunDir with a zero x component are exactly the preconditions
-    // multiscatter_sample_direction's half-azimuth sample set needs
-    let rayDir = multiscatter_sample_direction(thread_index);
-
-    var lum:vec3<f32>;
-    var f_ms:vec3<f32>;
-
-    get_multiscatter_values(pos, sunDir, rayDir, &lum, &f_ms);
-
-    // Uniform control flow up to here, so every one of the workgroup's threads is an active
-    // lane and the subgroup sum covers all of them.
-    let lum_subgroup = subgroupAdd(lum);
-    let fms_subgroup = subgroupAdd(f_ms);
-
-    // subgroupElect picks exactly one active invocation per subgroup, and the slot it claims
-    // is whichever the counter hands out. Deriving the slot from local_invocation_index /
-    // subgroup_size instead would assume invocations are packed into subgroups in contiguous
-    // index order, which WGSL leaves unspecified: a mapping that is not contiguous blocks
-    // would collide two subgroups onto one slot and silently drop a partial sum. Which slot
-    // a subgroup lands in does not matter, only that it gets its own.
-    //
-    // Every lane holds the same subgroup sum, so letting them all store it would be a data
-    // race on one address even though the values agree.
-    if (subgroupElect()) {
-        let slot = atomicAdd(&wg_partial_count, 1u);
-
-        wg_lum[slot] = lum_subgroup;
-        wg_fms[slot] = fms_subgroup;
-    }
-
-    workgroupBarrier();
-
-    if (thread_index != 0u) {
-        return;
-    }
-
-    // WGSL pins the subgroup size to a power of two in [4, 128], so the workgroup cannot hold
-    // more subgroups than the partials array has room for. The clamp keeps a driver that
-    // broke that promise reading initialised slots rather than garbage.
-    let partial_count = min(atomicLoad(&wg_partial_count), MULTISCATTER_MAX_SUBGROUP_PARTIALS);
-
-    var lum_total = vec3(0.0);
-    var fms_total = vec3(0.0);
-
-    for (var i = 0u; i < partial_count; i++) {
-        lum_total += wg_lum[i];
-        fms_total += wg_fms[i];
-    }
-
-    // The directions carry equal solid angle, so the mean over them is the spherical average
-    // the paper's uniform phase reduces to.
-    let inv_samples = 1.0 / f32(MULTISCATTER_DIRECTION_COUNT);
-
-    lum_total *= inv_samples;
-    fms_total *= inv_samples;
-
-    // Equation 10 from the paper.
-    let psi = lum_total / (1.0 - fms_total);
-
-    textureStore(tSkyLutMultiscatterOut, texel, vec4(psi, 1.0));
-}
-    `, [
-        chunk_safe_acos,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-        chunk_multiscatter_sample_direction,
-        chunk_sky_lut_texel_to_unit,
-        chunk_get_multiscatter_values,
-    ]
-);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-export const shader_multiscatter_lut = ComputeShader.from({
-    label: "Sky / multi-scatter LUT",
-    body,
-    resources,
-});
+import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
+import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
+import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_get_multiscatter_values } from "./chunk_get_multiscatter_values.js";
+import { chunk_multiscatter_sample_direction } from "./chunk_multiscatter_sample_direction.js";
+import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
+import {
+    MULTISCATTER_LUT_DIRECTION_COUNT,
+    MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS
+} from "./MULTISCATTER_LUT_CONFIG.js";
+import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    // "float" rather than the default "unfilterable-float": rgba16float is filterable in
+    // core WebGPU, so the LUT goes through the texture unit instead of a 4-tap manual
+    // bilinear.
+    .addTexture("tSkyLutTransmittance", "float")
+    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
+    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float")
+;
+
+
+/**
+ * the multiple-scattering LUT. Each pixel coordinate corresponds to a height and sun zenith angle, and
+ * the value is the multiple scattering approximation (Psi_ms from the paper, Eq. 10).
+ *
+ * One workgroup per LUT texel, one thread per direction (64 threads per workgroup).
+ * The 64 directions used to be a serial loop
+ * inside a fragment shader, which left the whole pass with 32*32 = 1024 threads of
+ * parallelism -- a few dozen waves, one per scheduler at best, with nothing to hide the
+ * latency of the transmittance fetches. Per-thread it is now a single direction's 20-step
+ * march.
+ *
+ * The per-direction results are summed with `subgroupAdd` and then across subgroups through
+ * workgroup memory, collapsing a six-step groupshared log-reduction into one subgroup
+ * instruction plus a handful of partials.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @see https://www.shadertoy.com/view/slSXRW
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const MULTISCATTER_DIRECTION_COUNT = ${MULTISCATTER_LUT_DIRECTION_COUNT}u;
+const MULTISCATTER_MAX_SUBGROUP_PARTIALS = ${MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS}u;
+
+var<workgroup> wg_partial_count: atomic<u32>;
+var<workgroup> wg_lum: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_fms: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
+
+@compute @workgroup_size(${MULTISCATTER_LUT_DIRECTION_COUNT}, 1, 1)
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) thread_index: u32,
+) {
+
+    if (thread_index == 0u) {
+        atomicStore(&wg_partial_count, 0u);
+    }
+
+    // Every thread is here together anyway, so the counter's initialisation costs nothing
+    // beyond the barrier itself. WGSL does not promise workgroup variables start zeroed.
+    workgroupBarrier();
+
+    // one workgroup per texel; the dispatch is sized from the texture, so this is in range
+    let texel = workgroup_id.xy;
+
+    let lut_size = vec2<f32>(textureDimensions(tSkyLutMultiscatterOut));
+
+    // The point of each range this texel stands for: texel 0 carries the bottom and the last
+    // texel the top, which is what lets a lookup at either end read a value computed there
+    // rather than one from half a texel inside. sky_lut_uv is the other half of this.
+    let unit = sky_lut_texel_to_unit(vec2<f32>(texel), lut_size);
+
+    let sunCosTheta = 2.0*unit.x - 1.0;
+    let sunTheta = safe_acos(sunCosTheta);
+
+    let height = ATMOSPHERE_HEIGHT*unit.y;
+
+    let pos = vec3(0.0, height, 0.0);
+    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
+
+    // pos on the +y axis and sunDir with a zero x component are exactly the preconditions
+    // multiscatter_sample_direction's half-azimuth sample set needs
+    let rayDir = multiscatter_sample_direction(thread_index);
+
+    var lum:vec3<f32>;
+    var f_ms:vec3<f32>;
+
+    get_multiscatter_values(pos, sunDir, rayDir, &lum, &f_ms);
+
+    // Uniform control flow up to here, so every one of the workgroup's threads is an active
+    // lane and the subgroup sum covers all of them.
+    let lum_subgroup = subgroupAdd(lum);
+    let fms_subgroup = subgroupAdd(f_ms);
+
+    // subgroupElect picks exactly one active invocation per subgroup, and the slot it claims
+    // is whichever the counter hands out. Deriving the slot from local_invocation_index /
+    // subgroup_size instead would assume invocations are packed into subgroups in contiguous
+    // index order, which WGSL leaves unspecified: a mapping that is not contiguous blocks
+    // would collide two subgroups onto one slot and silently drop a partial sum. Which slot
+    // a subgroup lands in does not matter, only that it gets its own.
+    //
+    // Every lane holds the same subgroup sum, so letting them all store it would be a data
+    // race on one address even though the values agree.
+    if (subgroupElect()) {
+        let slot = atomicAdd(&wg_partial_count, 1u);
+
+        wg_lum[slot] = lum_subgroup;
+        wg_fms[slot] = fms_subgroup;
+    }
+
+    workgroupBarrier();
+
+    if (thread_index != 0u) {
+        return;
+    }
+
+    // WGSL pins the subgroup size to a power of two in [4, 128], so the workgroup cannot hold
+    // more subgroups than the partials array has room for. The clamp keeps a driver that
+    // broke that promise reading initialised slots rather than garbage.
+    let partial_count = min(atomicLoad(&wg_partial_count), MULTISCATTER_MAX_SUBGROUP_PARTIALS);
+
+    var lum_total = vec3(0.0);
+    var fms_total = vec3(0.0);
+
+    for (var i = 0u; i < partial_count; i++) {
+        lum_total += wg_lum[i];
+        fms_total += wg_fms[i];
+    }
+
+    // The directions carry equal solid angle, so the mean over them is the spherical average
+    // the paper's uniform phase reduces to.
+    let inv_samples = 1.0 / f32(MULTISCATTER_DIRECTION_COUNT);
+
+    lum_total *= inv_samples;
+    fms_total *= inv_samples;
+
+    // Equation 10 from the paper.
+    let psi = lum_total / (1.0 - fms_total);
+
+    textureStore(tSkyLutMultiscatterOut, texel, vec4(psi, 1.0));
+}
+    `, [
+        chunk_safe_acos,
+        ATMOSPHERE_HEIGHT_DECLARATION,
+        chunk_multiscatter_sample_direction,
+        chunk_sky_lut_texel_to_unit,
+        chunk_get_multiscatter_values,
+    ]
+);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+export const shader_multiscatter_lut = ComputeShader.from({
+    label: "Sky / multi-scatter LUT",
+    body,
+    resources,
+});

package/src/shade/renderer/atmosphere/shader_sky_irradiance_lut.js

@@ -116,7 +116,7 @@ fn raymarch_scattering(
         let mie_absorption = mie_density * C_MIE_ABSORPTION;
         let mie_scattering = mie_density * C_MIE_SCATTERING;
         
-        // note - taken from the Hillaire's atmosphere code: https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/RenderSkyCommon.hlsl#L248
+        // Rayleigh does not absorb
         let rayleigh_absorption = 0.0;
         let rayleigh_scattering = local_density.x * C_RAYLEIGH;
         

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts

@@ -1,117 +1,77 @@
 /**
- * Smoothed orbital camera controller — a drop-in replacement for the legacy
- * {@link ../OrbitalCameraController.js} that adds frame-rate-independent inertia
- * via meep's critically-damped springs.
+ * Orbital camera for a Shade {@link PerspectiveCamera} outside the ECS: drag to orbit, right-drag to
+ * pan, wheel to zoom, W/A/S/D to fly the target along the view.
  *
- * It is a thin FACADE over two decoupled, independently-testable layers:
- *   - {@link OrbitalCameraRig}   — pure control core (springs + goals, no DOM/clock)
- *   - {@link OrbitalCameraInput} — input adapter (events → rig intents, no kinematics)
+ * The pose is a {@link TopDownCameraController} of its own, the same one an ECS camera carries, and
+ * an {@link OrbitalCameraRig} moves it with the feel every orbital camera in the engine shares. Each
+ * {@link update} writes the pose onto the camera's transform, and a transform moved by anyone else
+ * since is adopted as the new pose instead.
  *
- * The facade owns only the things that genuinely need the outside world: device
- * lifecycle, the frame `dt`, writing the result onto the camera's transform, and
- * the "camera moved outside our control" detection contract. The public surface
- * ({@link look}, {@link from_transform}, {@link pan}, {@link update},
- * `distanceLimits`, `movement_speed_scale`, `camera`) matches the legacy
- * controller so switching is a single import change.
- *
- * @author Alex Goldring (orbital rework)
+ * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class OrbitalCameraController {
     /**
      * @param {import("../PerspectiveCamera.js").PerspectiveCamera} camera
      * @param {HTMLElement} domElement
-     * @param {Partial<import("./OrbitalCameraConfig.js").ORBITAL_CAMERA_FEEL_DEFAULTS>} [configOverrides]
      */
-    constructor(camera: import("../PerspectiveCamera.js").PerspectiveCamera, domElement: HTMLElement, configOverrides?: any);
+    constructor(camera: import("../PerspectiveCamera.js").PerspectiveCamera, domElement: HTMLElement);
+    /**
+     * Zoom range, world units. Mutate `.min`/`.max` or `set()`; it applies from the next
+     * {@link look} or {@link update}.
+     * @type {NumericInterval}
+     */
+    distanceLimits: NumericInterval;
+    /**
+     * W/A/S/D speed, world units a second with the camera at the near end of {@link distanceLimits},
+     * rising to twice that at the far end.
+     * @type {number}
+     */
+    movement_speed_scale: number;
+    /**
+     * @type {TopDownCameraController}
+     */
+    pose: TopDownCameraController;
     camera: import("../PerspectiveCamera.js").PerspectiveCamera;
     domElement: HTMLElement;
-    config: Readonly<{
-        momentumEnabled: true;
-        momentumDecayHalfLife: 0.1;
-        velocityWindow: 0.1;
-        momentumStopSpeed: 0.012;
-        rotateSpeed: 1;
-        panSpeed: 1;
-        zoomStep: 0.9;
-        invertWheel: false;
-        minPolar: 0.000001;
-        maxPolar: number;
-        flyToDuration: 0.35;
-        maxDt: 0.1;
-    }>;
+    rig: OrbitalCameraRig;
     pointer: PointerDevice;
     keyboard: KeyboardDevice;
-    rig: OrbitalCameraRig;
-    input: OrbitalCameraInput;
-    _lastRecorded: Transform64;
-    _lastUpdateTime: number;
-    _scratchEye: Vector3;
-    _scratchTarget: Vector3;
-    /** Zoom range, in world units (NumericInterval). Mutate `.min/.max` or `.set()`. */
-    get distanceLimits(): import("../../../../core/math/interval/NumericInterval.js").NumericInterval;
-    set movement_speed_scale(value: number);
-    /** Scene-relative WASD/keyboard move speed. */
-    get movement_speed_scale(): number;
-    /** Current smoothed orbit distance (radius). */
+    /** Orbit distance, world units. */
     get distance(): number;
-    /** Current smoothed target (shared scratch — copy if you need to retain it). */
+    /** Orbit target, live: copy it to keep it. */
     get target(): Vector3;
     /**
-     * Point the camera at `to` from `from`, immediately (no animation).
+     * Point the camera at `to` from `from`, at once, stopping any throw.
      * @param {Vector3} from
      * @param {Vector3} to
      */
     look(from: Vector3, to: Vector3): void;
     /**
-     * Eased "fly to" framing: glide to the new pose over {@link config}.flyToHalfLife
-     * instead of snapping. The normal update() loop animates it.
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    flyTo(from: Vector3, to: Vector3): void;
-    /**
-     * Adopt an external camera transform as the new orbit pose (target is placed
-     * `distance` ahead along its forward).
+     * Adopt a camera transform as the pose, the target the current orbit distance ahead of it.
      *
-     * Read component-wise rather than through `Vector3.copy`, because a
-     * {@link Transform64} answers `forward` and `translation` with raw
-     * `Float64Array`s — no `.x`, and a `copy` of one silently sets three
-     * undefineds. Those two arrays are also freshly allocated per access, so
-     * each is read once into a scratch that outlives the call.
+     * Read by component, because a {@link Transform64} answers `forward` with a raw `Float64Array`,
+     * allocated on each access.
      *
      * @param {Transform64} transform
      */
     from_transform(transform: Transform64): void;
     /**
-     * Screen-space pan of the orbit target, in pointer pixels (legacy signature).
-     * @param {number} delta_x
-     * @param {number} delta_y
-     */
-    pan(delta_x: number, delta_y: number): void;
-    /**
-     * Advance one frame and write the result onto the camera transform.
+     * Advance one frame and write the pose onto the camera transform.
      *
-     * @param {number} [dt] frame time in seconds. STRONGLY preferred — pass the
-     *   value `create_frame_loop` already hands the callback. Omit to fall back
-     *   to an internal clock (clamped, so no first-frame teleport).
+     * @param {number} [dt] frame time in seconds; `create_frame_loop` hands it to its callback. Omit
+     * it to measure the time since the last call instead.
      */
     update(dt?: number): void;
-    /** Detach input subscriptions and stop the devices. */
+    /** Detach input and stop the devices. */
     dispose(): void;
-    /**
-     * Resolve and sanitize the frame dt. Prefers the supplied value; otherwise
-     * derives it from an internal clock. Always clamped to [0, maxDt] so a tab
-     * refocus / GC hitch can't make the springs jump.
-     * @param {number} [dt]
-     * @returns {number}
-     */
-    _resolveDt(dt?: number): number;
+    #private;
 }
+import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import TopDownCameraController from "../../../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+import { OrbitalCameraRig } from "../../../../engine/graphics/camera/orbital/OrbitalCameraRig.js";
 import { PointerDevice } from "../../../../engine/input/devices/PointerDevice.js";
 import KeyboardDevice from "../../../../engine/input/devices/KeyboardDevice.js";
-import { OrbitalCameraRig } from "./OrbitalCameraRig.js";
-import { OrbitalCameraInput } from "./OrbitalCameraInput.js";
-import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
+import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=OrbitalCameraController.d.ts.map

package/src/shade/renderer/camera/orbital/OrbitalCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH,oBAJW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,yBAwCrB;IApCG,4DAAoB;IACpB,wBAA4B;IAE5B;;;;;;;;;;;;;OAAwD;IAGxD,uBAA4C;IAI5C,yBAA8C;IAK9C,sBAAwD;IAExD,0BAOE;IAIF,2BAAsC;IAEtC,wBAAgD;IAChD,qBAAgC;IAChC,wBAAmC;IAUvC,oFAAoF;IACpF,kGAEC;IAOD,wCAEC;IAPD,+CAA+C;IAC/C,mCAEC;IAMD,gDAAgD;IAChD,uBAEC;IAED,gFAAgF;IAChF,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;OAKG;IACH,YAHW,OAAO,MACP,OAAO,QAUjB;IAED;;;;;;;;;;;OAWG;IACH,0BAFW,WAAW,QAoBrB;IAED;;;;OAIG;IACH,aAHW,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,YAJW,MAAM,QAuBhB;IAED,uDAAuD;IACvD,gBAIC;IAMD;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAelB;CACJ;8BArO6B,mDAAmD;2BADtD,oDAAoD;iCAE9C,uBAAuB;mCACrB,yBAAyB;4BALhC,iDAAiD;oBAFzD,kCAAkC"}
+{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraController.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH;IAwCI;;;OAGG;IACH,oBAHW,OAAO,yBAAyB,EAAE,iBAAiB,cACnD,WAAW,EA4BrB;IArED;;;;OAIG;IACH,gBAFU,eAAe,CAEuB;IAEhD;;;;OAIG;IACH,sBAFU,MAAM,CAES;IAEzB;;OAEG;IACH,MAFU,uBAAuB,CAEI;IA2BjC,4DAAoB;IACpB,wBAA4B;IAK5B,sBAME;IAEF,uBAA4C;IAO5C,yBAA8C;IAMlD,mCAAmC;IACnC,uBAEC;IAED,8CAA8C;IAC9C,sBAEC;IAED;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QAiBjB;IAED;;;;;;;OAOG;IACH,0BAFW,WAAW,QAoBrB;IAED;;;;;OAKG;IACH,YAHW,MAAM,QAsBhB;IAED,yCAAyC;IACzC,gBAQC;;CAgFJ;gCA5R+B,mDAAmD;oCAW5E,2EAA2E;iCAJjD,gEAAgE;8BAOnE,mDAAmD;2BAFtD,oDAAoD;oBAb3D,kCAAkC;4BAO1B,iDAAiD"}