@woosh/meep-engine 3.38.0 → 3.39.0

package/src/shade/renderer/water/surface/WATER_WAVE_PARAMETERS_STRUCT.js

@@ -0,0 +1,49 @@
+import { f32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * Most impulses one body applies in one step.
+ * @type {number}
+ */
+export const WATER_WAVE_IMPULSE_LIMIT = 16;
+
+/**
+ * Per-body, per-step inputs of the primitive wave producer: its grid, the terrain it floods, the
+ * step and the forcing.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_WAVE_PARAMETERS_STRUCT = WebGPUStruct.from({
+    /** world-space grid rectangle: min x, min z, max x, max z */
+    extent: vec4f,
+    /** terrain height texture coordinates of the grid: `uv * zw + xy` */
+    height_uv: vec4f,
+    /** wind direction x, z (unit); forcing amplitude, m/s²; forcing drift speed, m/s */
+    forcing: vec4f,
+    /** queued impulses: world x, world z, radius m, velocity kick m/s */
+    impulses: WebGPUArray.from(vec4f, WATER_WAVE_IMPULSE_LIMIT),
+    /** rest height of the surface */
+    level: f32,
+    /** distance between neighbouring vertices, m */
+    spacing: f32,
+    /** step, s */
+    dt: f32,
+    /** simulated time, s */
+    time: f32,
+    /** damping rate everywhere, 1/s */
+    damping: f32,
+    /** border band of extra damping, vertices */
+    sponge_width: f32,
+    /** damping at the border, 1/s */
+    sponge_strength: f32,
+    /** largest celerity the step stays stable at, m/s */
+    celerity_limit: f32,
+    /** slope variance of the waves the grid does not resolve */
+    unresolved_variance: f32,
+    /** vertices along each side */
+    resolution: u32,
+    impulse_count: u32,
+    /** 1 on the first write after the body's buffers were created, so `previous` starts at `position` */
+    first_write: u32,
+}, "WaterWaveParameters");

package/src/shade/renderer/water/surface/chunk_water_wave.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The primitive surface producer's physics, as pure functions so each is testable alone.
+ *
+ * A damped linear wave equation on a height field, `h_tt = c² ∇²h − γ h_t + f`, stepped by
+ * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`, so waves slow down and turn in
+ * shallows and reflect from the shore. That is right for long waves and wrong for deep-water wind
+ * waves, whose speed depends on their wavelength rather than on depth: a stated limit of a
+ * primitive simulation, which the production simulation replaces behind the surface interface
+ * (WATER_OPTICS_PLAN_2026_10_02.md §7.2).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_wave: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_wave.d.ts.map

package/src/shade/renderer/water/surface/chunk_water_wave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_wave.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_wave.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,+BAFU,SAAS,CAmChB;0BA/CuB,oCAAoC"}

package/src/shade/renderer/water/surface/chunk_water_wave.js

@@ -0,0 +1,48 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The primitive surface producer's physics, as pure functions so each is testable alone.
+ *
+ * A damped linear wave equation on a height field, `h_tt = c² ∇²h − γ h_t + f`, stepped by
+ * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`, so waves slow down and turn in
+ * shallows and reflect from the shore. That is right for long waves and wrong for deep-water wind
+ * waves, whose speed depends on their wavelength rather than on depth: a stated limit of a
+ * primitive simulation, which the production simulation replaces behind the surface interface
+ * (WATER_OPTICS_PLAN_2026_10_02.md §7.2).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_wave = CodeChunk.from(/* language=WGSL */ `
+const WATER_WAVE_GRAVITY: f32 = 9.81;
+
+// Squared celerity of a long wave over water depth metres deep, capped so an explicit step of the
+// size the producer takes stays stable (2-D CFL: c·dt/dx ≤ 1/√2).
+fn water_wave_celerity2(depth: f32, celerity_limit: f32) -> f32 {
+    return min(WATER_WAVE_GRAVITY * max(depth, 0.0), celerity_limit * celerity_limit);
+}
+
+// One leapfrog step of h_tt = c² ∇²h − γ h_t + f: the next height from the current one, the
+// previous one, the current height's Laplacian, c², the damping rate γ (1/s), the forcing f (m/s²)
+// and the step dt (s).
+fn water_wave_step(h: f32, h_previous: f32, laplacian: f32, celerity2: f32, damping: f32,
+    force: f32, dt: f32) -> f32 {
+    return h + (h - h_previous) * max(1.0 - damping * dt, 0.0) + dt * dt * (celerity2 * laplacian + force);
+}
+
+// Extra damping in a band along the grid's border, rising quadratically to strength at the edge,
+// so waves leave the domain instead of reflecting off the end of the grid.
+fn water_wave_sponge(cell: vec2<u32>, resolution: u32, width: f32, strength: f32) -> f32 {
+    let last = f32(resolution - 1u);
+    let p = vec2<f32>(cell);
+    let edge = min(min(p.x, p.y), min(last - p.x, last - p.y));
+    let s = clamp(1.0 - edge / max(width, 1.0), 0.0, 1.0);
+    return strength * s * s;
+}
+
+// Unit normal of a height field from central differences of its heights at the four neighbours,
+// spacing metres apart.
+fn water_wave_normal(left: f32, right: f32, down: f32, up: f32, spacing: f32) -> vec3<f32> {
+    let slope = vec2<f32>(right - left, up - down) / (2.0 * spacing);
+    return normalize(vec3<f32>(-slope.x, 1.0, -slope.y));
+}
+`);

package/src/shade/renderer/water/surface/chunk_water_wave_grid.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Grid addressing, terrain lookup and forcing of the primitive wave producer. Expects `params`
+ * ({@link WATER_WAVE_PARAMETERS_STRUCT}), `terrain_height` and `height_sampler` bound.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_wave_grid: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_wave_grid.d.ts.map

package/src/shade/renderer/water/surface/chunk_water_wave_grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_wave_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_wave_grid.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,oCAFU,SAAS,CAuCG;0BA9CI,oCAAoC"}

package/src/shade/renderer/water/surface/chunk_water_wave_grid.js

@@ -0,0 +1,47 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_srdnoise2 } from "../../shader/chunk/noise/psrdnoise/chunk_srdnoise2.js";
+
+/**
+ * Grid addressing, terrain lookup and forcing of the primitive wave producer. Expects `params`
+ * ({@link WATER_WAVE_PARAMETERS_STRUCT}), `terrain_height` and `height_sampler` bound.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_wave_grid = CodeChunk.from(/* language=WGSL */ `
+// Spatial scale of the wind's pressure pattern, m.
+const WATER_WAVE_FORCING_SCALE: f32 = 6.0;
+
+fn water_wave_grid_uv(cell: vec2<u32>) -> vec2<f32> {
+    return vec2<f32>(cell) / f32(params.resolution - 1u);
+}
+
+fn water_wave_world(cell: vec2<u32>) -> vec2<f32> {
+    return mix(params.extent.xy, params.extent.zw, water_wave_grid_uv(cell));
+}
+
+fn water_wave_terrain(cell: vec2<u32>) -> f32 {
+    let uv = water_wave_grid_uv(cell) * params.height_uv.zw + params.height_uv.xy;
+    return textureSampleLevel(terrain_height, height_sampler, uv, 0.0).r;
+}
+
+// Clamped at the grid's edge, which reflects; the sponge band absorbs before waves get there.
+fn water_wave_index(cell: vec2<i32>) -> u32 {
+    let n = i32(params.resolution);
+    let c = clamp(cell, vec2<i32>(0), vec2<i32>(n - 1));
+    return u32(c.y * n + c.x);
+}
+
+// Wind: a pressure pattern drifting downwind, plus this step's impulses as velocity kicks spread
+// over one step.
+fn water_wave_force(world: vec2<f32>) -> f32 {
+    let drift = params.forcing.xy * params.forcing.w * params.time;
+    var force = params.forcing.z * srdnoise2((world - drift) / WATER_WAVE_FORCING_SCALE, 0.0).x;
+    for (var i = 0u; i < params.impulse_count; i++) {
+        let impulse = params.impulses[i];
+        let r = max(impulse.z, 1e-3);
+        let d = world - impulse.xy;
+        force += impulse.w / params.dt * exp(-dot(d, d) / (r * r));
+    }
+    return force;
+}
+`, [chunk_srdnoise2]);

package/src/shade/renderer/water/surface/shader_water_surface_write.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Writes the surface interface from the primitive producer's heights: the vertex record every
+ * water draw reads. A dry vertex sits at the rest level, under the terrain, where the opaque depth
+ * hides it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_surface_write: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_surface_write.d.ts.map

package/src/shade/renderer/water/surface/shader_water_surface_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_surface_write.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_surface_write.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,yCAFU,aAAa,CA2BpB;8BAlD2B,+BAA+B"}

package/src/shade/renderer/water/surface/shader_water_surface_write.js

@@ -0,0 +1,51 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_water_wave } from "./chunk_water_wave.js";
+import { chunk_water_wave_grid } from "./chunk_water_wave_grid.js";
+import { WATER_SURFACE_VERTEX_STRUCT } from "./WATER_SURFACE_VERTEX_STRUCT.js";
+import { WATER_WAVE_PARAMETERS_STRUCT } from "./WATER_WAVE_PARAMETERS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("params", WATER_WAVE_PARAMETERS_STRUCT)
+    .addTexture("terrain_height", "float")
+    .addSampler("height_sampler")
+    .addStorageBuffer("state", WebGPUArray.from(f32), false)
+    .addStorageBuffer("vertices", WebGPUArray.from(WATER_SURFACE_VERTEX_STRUCT), true);
+
+/**
+ * Writes the surface interface from the primitive producer's heights: the vertex record every
+ * water draw reads. A dry vertex sits at the rest level, under the terrain, where the opaque depth
+ * hides it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_surface_write = ComputeShader.from({
+    label: "Water / surface write",
+    resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+fn water_surface_height_at(cell: vec2<i32>) -> f32 {
+    return params.level + state[water_wave_index(cell)];
+}
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let n = params.resolution;
+    if (any(id.xy >= vec2<u32>(n))) { return; }
+    let cell = vec2<i32>(id.xy);
+    let index = water_wave_index(cell);
+    let world = water_wave_world(id.xy);
+    let position = vec3<f32>(world.x, water_surface_height_at(cell), world.y);
+    let normal = water_wave_normal(
+        water_surface_height_at(cell - vec2<i32>(1, 0)), water_surface_height_at(cell + vec2<i32>(1, 0)),
+        water_surface_height_at(cell - vec2<i32>(0, 1)), water_surface_height_at(cell + vec2<i32>(0, 1)),
+        params.spacing);
+    let previous = select(vertices[index].position.xyz, position, params.first_write != 0u);
+    vertices[index] = WaterSurfaceVertex(vec4<f32>(position, params.unresolved_variance),
+        vec4<f32>(previous, 0.0), vec4<f32>(normal, 0.0));
+}
+`, [chunk_water_wave, chunk_water_wave_grid]),
+});

package/src/shade/renderer/water/surface/shader_water_wave_step.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One step of the primitive wave producer. Reads the current heights and overwrites the previous
+ * ones with the next: each thread reads only its own previous height, so the two buffers alternate
+ * roles step to step without a third.
+ *
+ * Dry vertices hold zero displacement, which makes the shore a reflecting boundary.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_wave_step: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_wave_step.d.ts.map

package/src/shade/renderer/water/surface/shader_water_wave_step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_wave_step.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_wave_step.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH,qCAFU,aAAa,CA6BpB;8BArD2B,+BAA+B"}

package/src/shade/renderer/water/surface/shader_water_wave_step.js

@@ -0,0 +1,54 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_water_wave } from "./chunk_water_wave.js";
+import { chunk_water_wave_grid } from "./chunk_water_wave_grid.js";
+import { WATER_WAVE_PARAMETERS_STRUCT } from "./WATER_WAVE_PARAMETERS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("params", WATER_WAVE_PARAMETERS_STRUCT)
+    .addTexture("terrain_height", "float")
+    .addSampler("height_sampler")
+    .addStorageBuffer("state_current", WebGPUArray.from(f32), false)
+    .addStorageBuffer("state_previous", WebGPUArray.from(f32), true);
+
+/**
+ * One step of the primitive wave producer. Reads the current heights and overwrites the previous
+ * ones with the next: each thread reads only its own previous height, so the two buffers alternate
+ * roles step to step without a third.
+ *
+ * Dry vertices hold zero displacement, which makes the shore a reflecting boundary.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_wave_step = ComputeShader.from({
+    label: "Water / wave step",
+    resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let n = params.resolution;
+    if (any(id.xy >= vec2<u32>(n))) { return; }
+    let cell = vec2<i32>(id.xy);
+    let index = water_wave_index(cell);
+    let depth = params.level - water_wave_terrain(id.xy);
+    if (depth <= 0.0) {
+        state_previous[index] = 0.0;
+        return;
+    }
+    let h = state_current[index];
+    let neighbours = state_current[water_wave_index(cell + vec2<i32>(1, 0))]
+        + state_current[water_wave_index(cell - vec2<i32>(1, 0))]
+        + state_current[water_wave_index(cell + vec2<i32>(0, 1))]
+        + state_current[water_wave_index(cell - vec2<i32>(0, 1))];
+    let laplacian = (neighbours - 4.0 * h) / (params.spacing * params.spacing);
+    let damping = params.damping + water_wave_sponge(id.xy, n, params.sponge_width, params.sponge_strength);
+    state_previous[index] = water_wave_step(h, state_previous[index], laplacian,
+        water_wave_celerity2(depth, params.celerity_limit), damping,
+        water_wave_force(water_wave_world(id.xy)), params.dt);
+}
+`, [chunk_water_wave, chunk_water_wave_grid]),
+});

package/src/shade/renderer/water/surface/water_surface_grid_indices.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Triangle indices of a regular `resolution × resolution` vertex grid, vertices numbered row by
+ * row (`index = y * resolution + x`). Two triangles a cell, split along the same diagonal
+ * everywhere, so neighbouring cells share their edges exactly.
+ *
+ * @param {Object} options
+ * @param {number} options.resolution vertices along each side, at least 2
+ * @returns {Uint32Array} `(resolution - 1)² · 6` indices
+ */
+export function water_surface_grid_indices({ resolution }: {
+    resolution: number;
+}): Uint32Array;
+//# sourceMappingURL=water_surface_grid_indices.d.ts.map

package/src/shade/renderer/water/surface/water_surface_grid_indices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"water_surface_grid_indices.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/water_surface_grid_indices.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAH2B,UAAU,EAA1B,MAAM;IACJ,WAAW,CA6BvB"}

package/src/shade/renderer/water/surface/water_surface_grid_indices.js

@@ -0,0 +1,39 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Triangle indices of a regular `resolution × resolution` vertex grid, vertices numbered row by
+ * row (`index = y * resolution + x`). Two triangles a cell, split along the same diagonal
+ * everywhere, so neighbouring cells share their edges exactly.
+ *
+ * @param {Object} options
+ * @param {number} options.resolution vertices along each side, at least 2
+ * @returns {Uint32Array} `(resolution - 1)² · 6` indices
+ */
+export function water_surface_grid_indices({ resolution }) {
+    assert.isInteger(resolution, 'resolution');
+    assert.greaterThanOrEqual(resolution, 2, 'resolution');
+
+    const cells = resolution - 1;
+    const indices = new Uint32Array(cells * cells * 6);
+
+    let cursor = 0;
+
+    for (let y = 0; y < cells; y++) {
+        for (let x = 0; x < cells; x++) {
+            const a = y * resolution + x;
+            const b = a + 1;
+            const c = a + resolution;
+            const d = c + 1;
+
+            indices[cursor++] = a;
+            indices[cursor++] = c;
+            indices[cursor++] = b;
+
+            indices[cursor++] = b;
+            indices[cursor++] = c;
+            indices[cursor++] = d;
+        }
+    }
+
+    return indices;
+}

package/src/shade/renderer/water/water_missing_receiver_path.d.ts

@@ -0,0 +1,17 @@
+/**
+ * How far the water passes integrate a body where nothing is seen through it on screen — the sky, the
+ * screen edge, a trace that failed: to where its clearest channel's beam transmittance has fallen to a
+ * thousandth, so the water's own light has stopped changing, bounded by the trace distance. A missing
+ * receiver is missing visibility; assuming nothing about the geometry that is not there, the water
+ * reads as deep.
+ *
+ * @param {Object} options
+ * @param {import("../medium/ParticipatingMedium.js").ParticipatingMedium} options.medium
+ * @param {number} options.max_distance the trace distance, m
+ * @returns {number} m
+ */
+export function water_missing_receiver_path({ medium, max_distance }: {
+    medium: import("../medium/ParticipatingMedium.js").ParticipatingMedium;
+    max_distance: number;
+}): number;
+//# sourceMappingURL=water_missing_receiver_path.d.ts.map

package/src/shade/renderer/water/water_missing_receiver_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"water_missing_receiver_path.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_missing_receiver_path.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IAJmF,MAAM,EAA9E,OAAO,kCAAkC,EAAE,mBAAmB;IAC9C,YAAY,EAA5B,MAAM;IACJ,MAAM,CA2BlB"}

package/src/shade/renderer/water/water_missing_receiver_path.js

@@ -0,0 +1,40 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * How far the water passes integrate a body where nothing is seen through it on screen — the sky, the
+ * screen edge, a trace that failed: to where its clearest channel's beam transmittance has fallen to a
+ * thousandth, so the water's own light has stopped changing, bounded by the trace distance. A missing
+ * receiver is missing visibility; assuming nothing about the geometry that is not there, the water
+ * reads as deep.
+ *
+ * @param {Object} options
+ * @param {import("../medium/ParticipatingMedium.js").ParticipatingMedium} options.medium
+ * @param {number} options.max_distance the trace distance, m
+ * @returns {number} m
+ */
+export function water_missing_receiver_path({ medium, max_distance }) {
+    assert.defined(medium, 'medium');
+    assert.isFinite(max_distance, 'max_distance');
+    assert.greaterThan(max_distance, 0, 'max_distance');
+
+    const lobes = medium.lobes;
+
+    let clearest = Infinity;
+
+    for (let c = 0; c < 3; c++) {
+        let extinction = medium.absorption[c];
+
+        for (let i = 0; i < lobes.length; i++) {
+            extinction += lobes[i].scattering[c];
+        }
+
+        clearest = Math.min(clearest, extinction);
+    }
+
+    if (!(clearest > 0)) {
+        // a channel the water never attenuates: as far as the trace goes
+        return max_distance;
+    }
+
+    return Math.min(Math.log(1000) / clearest, max_distance);
+}

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAuiBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAnkBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAkmBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UA9nBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}