@woosh/meep-engine 2.109.5 → 2.109.7

package/src/engine/graphics/sh3/gi/material/MaterialTransformer.js

@@ -1,4 +1,4 @@
-import { DataTexture3D, NearestFilter, RedIntegerFormat, UnsignedIntType, Vector3 } from "three";
+import { Vector3 } from "three";
 import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
 import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
@@ -7,38 +7,29 @@ import { composeCompile } from "../../../material/composeCompile.js";
 import { AbstractMaterialTransformer } from "../../../material/manager/AbstractMaterialTransformer.js";
 import { isLitMaterial } from "../../../render/forward_plus/plugin/isLitMaterial.js";
 import { AttributeDataTexture } from "../../../texture/AttributeDataTexture.js";
-import { vector_buffer_to_attribute_texture } from "../../lpv/probe_volume_to_textures.js";
+import { octahedral_depth_to_atlas, vector_buffer_to_attribute_texture } from "../../lpv/probe_volume_to_textures.js";
 import { tetrahedral_mesh_to_texture } from "../tetrahedral_mesh_to_texture.js";
-import { build_fragment_shader } from "./build_fragment_shader.js";
-import { build_vertex_shader } from "./build_vertex_shader.js";
+import { makeLookupTexture3D } from "./makeLookupTexture3D.js";
+import { makeOctahedralDepthAtlas } from "./makeOctahedralDepthAtlas.js";
+import { space_fragment_transform_shader } from "./space_fragment/space_fragment_transform_shader.js";
+import { space_vertex_transform_shader } from "./space_vertex/space_vertex_transform_shader.js";
 
 const PROPERTY_TRANSFORMER_MARKER = '@light-probe-volume-material-transformer';
 
-
-function createLookupTexture(resolution) {
-
-    const lookup = new DataTexture3D(
-        new Uint32Array(resolution * resolution * resolution),
-        resolution,
-        resolution,
-        resolution
-    );
-
-    lookup.name = "Tetrahedron Lookup";
-
-    lookup.flipY = false;
-    lookup.generateMipmaps = false;
-    lookup.magFilter = NearestFilter;
-    lookup.minFilter = NearestFilter;
-
-    lookup.type = UnsignedIntType;
-    lookup.format = RedIntegerFormat;
-    lookup.internalFormat = "R32UI";
-
-    lookup.needsUpdate = true;
-
-    return lookup;
-}
+/**
+ * Where should probes be resolved?
+ * @enum {number}
+ */
+const ProbeResolutionSpace = {
+    /**
+     * Cheaper, but less precise
+     */
+    Vertex: 0,
+    /**
+     * More expensive, necessary for large geometries with few vertices
+     */
+    Fragment: 1
+};
 
 export class MaterialTransformer extends AbstractMaterialTransformer {
 
@@ -48,9 +39,15 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
      */
     #volume = null;
 
-    #mesh_lookup = createLookupTexture(32);
+    #mesh_lookup = makeLookupTexture3D(32);
     #mesh_bounds = new AABB3();
 
+    /**
+     *
+     * @type {ProbeResolutionSpace|number}
+     */
+    #space = ProbeResolutionSpace.Fragment
+
     #textures = {
         vertex: new AttributeDataTexture(
             AttributeSpec.fromJSON({
@@ -87,7 +84,8 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
                 normalized: false
             }),
             256, 9
-        )
+        ),
+        depth: makeOctahedralDepthAtlas()
     };
 
     #uniforms = {
@@ -107,6 +105,10 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
             type: "t",
             value: this.#textures.harmonics.texture
         },
+        lpv_t_probe_depth: {
+            type: "t",
+            value: this.#textures.depth
+        },
         lpv_t_mesh_lookup: {
             type: "t",
             value: this.#mesh_lookup
@@ -134,8 +136,16 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
     #onBeforeCompile = (shader) => {
         Object.assign(shader.uniforms, this.#uniforms);
 
-        shader.vertexShader = build_vertex_shader(shader.vertexShader);
-        shader.fragmentShader = build_fragment_shader(shader.fragmentShader);
+        switch (this.#space) {
+            case ProbeResolutionSpace.Vertex:
+                space_vertex_transform_shader(shader);
+                break;
+            case ProbeResolutionSpace.Fragment:
+                space_fragment_transform_shader(shader);
+                break;
+            default:
+                throw new Error(`Unsupported resolution space ${this.#space}`);
+        }
     };
 
     #materials = [];
@@ -166,6 +176,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
         super();
 
         this.#volume = volume;
+
     }
 
     update_bounds() {
@@ -250,9 +261,13 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
         tetrahedral_mesh_to_texture(
             this.#textures.vertex, this.#textures.neighbour, lpv.mesh
         );
+        octahedral_depth_to_atlas(lpv, this.#textures.depth.image.data, this.#textures.depth.image.width);
+        this.#textures.depth.needsUpdate = true;
 
         console.timeEnd('prepareTextures');
 
+        console.log(this.#textures);
+
         for (let i = 0; i < this.#materials.length; i++) {
             const material = this.#materials[i];
 

package/src/engine/graphics/sh3/gi/material/common.glsl

@@ -0,0 +1,434 @@
+#ifndef LPV_SHADER_CHUNK_COMMON
+#define LPV_SHADER_CHUNK_COMMON
+
+
+uniform usampler2D lpv_t_mesh_vertices;
+uniform usampler2D lpv_t_mesh_neighbours;
+uniform usampler3D lpv_t_mesh_lookup;
+
+uniform sampler2D lpv_t_probe_positions;
+uniform sampler2D lpv_t_probe_data;
+uniform sampler2D lpv_t_probe_depth;
+
+uniform uint lpv_u_mesh_tet_count;
+uniform vec3 lpv_v3_bounds_min;
+uniform vec3 lpv_v3_bounds_max;
+
+
+#define SEARCH_STEP_LIMIT 64u
+#define INVALID_TET 1073741823u
+
+ivec2 lpv_index_to_256_coordinate(uint index) {
+
+    uint pixel_x = index % 256u;
+    uint pixel_y = index / 256u;
+
+    return ivec2(int(pixel_x), int(pixel_y));
+}
+
+uvec4 lpv_mesh_getVertices(uint tet_index) {
+    ivec2 p = lpv_index_to_256_coordinate(tet_index);
+
+    return texelFetch(lpv_t_mesh_vertices, p, 0);
+
+}
+
+uvec4 lpv_mesh_getNeighbours(uint tet_index) {
+    ivec2 p = lpv_index_to_256_coordinate(tet_index);
+
+    return texelFetch(lpv_t_mesh_neighbours, p, 0);
+}
+
+vec3[9] lpv_probe_getData(uint probe_index) {
+
+
+    int slot = int(probe_index % 256u);
+    int column = int(probe_index / 256u);
+
+    int offset_x = int(slot * 9);
+
+    vec3[9] result;
+
+    for (int i = 0; i < 9; i++) {
+        result[i] = texelFetch(lpv_t_probe_data, ivec2(offset_x + i, column), 0).rgb;
+    }
+
+    return result;
+}
+
+vec3 sign_not_zero(vec3 x) {
+    return vec3(
+        x.x >= 0.0 ? 1.0 : -1.0,
+        x.y >= 0.0 ? 1.0 : -1.0,
+        x.z >= 0.0 ? 1.0 : -1.0
+    );
+}
+
+vec4 quadBlendWieghts(vec2 coords)
+{
+    vec4 res;
+/* 0 0 0
+    0 0 0
+    1 0 0 */
+    res.x = min(1.0f - coords.x, 1.0f - coords.y);
+/* 1 0 0
+    0 0 0
+    0 0 1 */
+    res.y = abs(coords.x - coords.y);
+/* 0 0 1
+    0 0 0
+    0 0 0 */
+    res.z = min(coords.x, coords.y);
+/* 0 0 0
+    0 0 1
+    0 1 1 */
+    res.w = ceil(coords.x - coords.y);
+    //res.xyz /= (res.x + res.y + res.z);
+    return res;
+}
+
+//vec2 VecToSphereOct(vec3 direction)
+//{
+//    vec3 octant = sign_not_zero(direction);
+//
+//    //  |x| + |y| + |z| = 1
+//    float sum = dot(direction, octant);
+//    vec3 octahedron = direction / sum;
+//
+//    if (direction.z < 0.0)
+//    {
+//        vec3 absolute = abs(octahedron);
+//
+//        octahedron.xy = octant.xy * vec2(1.0f - absolute.y, 1.0f - absolute.x);
+//    }
+//
+//    return octahedron.xy;
+//}
+
+vec2 VecToSphereOct(vec3 direction)
+{
+    vec3 octant = sign_not_zero(direction);
+
+    //  |x| + |y| + |z| = 1
+    float sum = dot(direction, octant);
+    vec3 octahedron = direction / sum;
+
+    if (direction.y < 0.0)
+    {
+        vec3 absolute = abs(octahedron);
+
+        octahedron.xz = octant.xz * vec2(1.0f - absolute.z, 1.0f - absolute.x);
+    }
+
+    return octahedron.xz;
+}
+
+float SampleBlended(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights) {
+
+    float samp0 = textureLod(tex, uv0, 0.0).r;
+    float samp1 = textureLod(tex, uv1, 0.0).r;
+    float samp2 = textureLod(tex, uv2, 0.0).r;
+
+    return samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
+}
+
+float lpv_probe_getDepth(uint probe_index, vec3 direction) {
+    // get offset
+    uint depth_tile_resolution = 24u;
+    uvec2 atlas_size = uvec2(4096u);
+
+    uint tiles_per_row = atlas_size.x / depth_tile_resolution;
+
+    uint tile_x = probe_index % tiles_per_row;
+    uint tile_y = probe_index / tiles_per_row;
+
+    vec2 tile_offset = vec2(
+        tile_x * depth_tile_resolution,
+        tile_y * depth_tile_resolution
+    );
+
+    // convert direction to UV
+    vec2 octahedral_uv = clamp(VecToSphereOct(direction) * 0.5 + 0.5, 0.0, 1.0);
+    vec2 grid = octahedral_uv * vec2(depth_tile_resolution - 1u);
+
+    vec2 gridFrac = fract(grid);
+    vec2 gridFloor = floor(grid);
+
+    vec4 weights = quadBlendWieghts(gridFrac);
+
+    //3 nearest frames
+    vec2 frame0 = gridFloor;
+    vec2 frame1 = gridFloor + mix(vec2(0, 1), vec2(1, 0), weights.w);
+    vec2 frame2 = gridFloor + vec2(1.0, 1.0);
+
+    // move frames to atlas space
+    frame0 += tile_offset;
+    frame1 += tile_offset;
+    frame2 += tile_offset;
+
+    vec2 uv0 = (frame0 + 0.5) / vec2(atlas_size);
+    vec2 uv1 = (frame1 + 0.5) / vec2(atlas_size);
+    vec2 uv2 = (frame2 + 0.5) / vec2(atlas_size);
+
+    return textureLod(lpv_t_probe_depth,uv0,0.0).r;
+
+
+    return SampleBlended(
+        lpv_t_probe_depth,
+        uv0, uv1, uv2,
+        weights
+    );
+}
+
+vec3 lpv_probe_getPosition(uint probe_index) {
+    return texelFetch(lpv_t_probe_positions, lpv_index_to_256_coordinate(probe_index), 0).rgb;
+}
+
+mat3 lpv_mesh_makeMatrix(vec3 p0, vec3 p1, vec3 p2, vec3 p3) {
+
+    return inverse(
+        mat3(
+            p0 - p3,
+            p1 - p3,
+            p2 - p3
+        )
+    );
+
+}
+
+vec4 lpv_mesh_getBarycentricCoordinates(uint tet_index, vec3 position) {
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec3 p0 = lpv_probe_getPosition(vertices[0]);
+    vec3 p1 = lpv_probe_getPosition(vertices[1]);
+    vec3 p2 = lpv_probe_getPosition(vertices[2]);
+    vec3 p3 = lpv_probe_getPosition(vertices[3]);
+
+    mat3 matrix = lpv_mesh_makeMatrix(p0, p1, p2, p3);
+
+    vec3 mult = matrix * (position - p3);
+
+    return vec4(mult, 1.0 - mult.x - mult.y - mult.z);
+}
+
+void lpv_getTetrahedron(
+in vec3 position,
+in uint tet_guess,
+out uint tet_index,
+out vec4 weights
+) {
+    uint came_from = 0u;
+
+    tet_index = tet_guess;
+
+    for (uint i = 0u; i < SEARCH_STEP_LIMIT; i++) {
+
+        weights = lpv_mesh_getBarycentricCoordinates(tet_index, position);
+
+        if (weights.x >= 0.0 && weights.y >= 0.0 && weights.z >= 0.0 && weights.w >= 0.0) {
+            return;
+        }
+
+        uvec4 neighbors = lpv_mesh_getNeighbours(tet_index);
+
+        uint next_tet;
+
+        // Otherwise find the smallest barycentric coord and move in that direction
+        if (weights.x < weights.y && weights.x < weights.z && weights.x < weights.w) {
+            next_tet = neighbors[0];
+        } else if (weights.y < weights.z && weights.y < weights.w) {
+            next_tet = neighbors[1];
+        } else if (weights.z < weights.w) {
+            next_tet = neighbors[2];
+        } else {
+            next_tet = neighbors[3];
+        }
+
+        if (next_tet == came_from) {
+            // numerical instability caused us to oscillate on the boundary
+            return;
+        }
+
+        came_from = tet_index;
+        tet_index = next_tet;
+    }
+
+    tet_index = INVALID_TET;
+}
+
+float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
+
+    vec3 probe_position = lpv_probe_getPosition(probe_index);
+
+    vec3 local_probe_offset = probe_position - position;
+
+    vec3 direction = normalize(local_probe_offset);
+
+    float depth = lpv_probe_getDepth(probe_index, direction);
+
+    return step(length(local_probe_offset), depth);
+}
+
+vec4 lvp_mask_weights_by_visibility(vec3 position, uint tet_index, vec4 weights) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec4 visibility = vec4(
+        lpv_probe_getVisibilityMask(position, vertices[0]),
+        lpv_probe_getVisibilityMask(position, vertices[1]),
+        lpv_probe_getVisibilityMask(position, vertices[2]),
+        lpv_probe_getVisibilityMask(position, vertices[3])
+    );
+
+    return visibility * weights;
+}
+
+vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint tet_index, vec4 weights) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec4 visibility;
+
+    for (int i = 0; i < 4; i++) {
+        vec3 probe_position = lpv_probe_getPosition(vertices[i]);
+
+        vec3 direction_to_probe = position - probe_position;
+
+       visibility[i] = step(dot(direction_to_probe, normal),0.0);
+    }
+
+    return visibility * weights;
+}
+
+vec3[9] lpv_interpolate_probes(vec4 weights, uint tet_index) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec3[9] probe0 = lpv_probe_getData(vertices[0]);
+    vec3[9] probe1 = lpv_probe_getData(vertices[1]);
+    vec3[9] probe2 = lpv_probe_getData(vertices[2]);
+    vec3[9] probe3 = lpv_probe_getData(vertices[3]);
+
+    vec3[9] result;
+
+    for (int i = 0; i < 9; i++) {
+
+        result[i] = probe0[i] * weights[0]
+        + probe1[i] * weights[1]
+        + probe2[i] * weights[2]
+        + probe3[i] * weights[3];
+
+    }
+
+    return result;
+}
+
+vec4 lpv_bias_weight_by_normal(const in vec3 position, const in vec3 normal, const in uint tet_index, const in vec4 weights) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec4 result = weights;
+
+    for (int i = 0; i < 4; i++) {
+        vec3 p = lpv_probe_getPosition(vertices[i]) - position;
+
+        if (dot(normal, p) <= 0.0) {
+            // behind the surface, bias to 0
+            result[i] = 0.0;
+        }
+    }
+
+    float total_weight = result.x + result.y + result.z + result.w;
+
+    // needs to add up to 1
+    result = result / total_weight;
+
+    return result;
+}
+
+uint lpv_guess_initial_tet(vec3 position) {
+
+    vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+    vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+
+    vec3 lookup_coordinates = (position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min);
+
+    return textureLod(lpv_t_mesh_lookup, lookup_coordinates, 0.0).r;
+
+}
+
+// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf
+vec3 lpv_get_irradiance_at( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+    // normal is assumed to have unit length
+    float x = normal.x, y = normal.y, z = normal.z;
+
+    // band 0
+    vec3 result = shCoefficients[ 0 ] * 0.8862269254527579;
+
+    // band 1
+    result -= shCoefficients[ 1 ] * 1.0233267079464885 * y;
+    result += shCoefficients[ 2 ] * 1.0233267079464885 * z;
+    result -= shCoefficients[ 3 ] * 1.0233267079464885 * x;
+
+    // band 2
+    result += shCoefficients[ 4 ] * 0.8580855308097834 * x * y;
+    result -= shCoefficients[ 5 ] * 0.8580855308097834 * y * z;
+    result += shCoefficients[ 6 ] * ( 0.7431238683011272 * z * z - 0.24770795610037571 );
+    result -= shCoefficients[ 7 ] * 0.8580855308097834 * x * z;
+    result += shCoefficients[ 8 ] * 0.4290427654048917 * ( x * x - y * y );
+
+    return result;
+}
+
+vec4 lpv_renormalize_weights(in vec4 source){
+
+    float sum = source.x + source.y + source.z + source.w;
+
+    return source / sum;
+
+}
+
+
+
+#define LPV_NORMAL_BIAS 0.01
+
+vec3 lpv_sample_irradiance(vec3 position, vec3 normal){
+
+    vec3 lookup_position = position + normal * LPV_NORMAL_BIAS;
+
+    // lookup nearby tet
+    vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+    vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+    vec3 lookup_coordinates = (lookup_position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min) ;
+
+
+    uint nearest_tet = lpv_guess_initial_tet( lookup_position );
+
+    uint tet;
+    vec4 weights;
+    lpv_getTetrahedron(lookup_position, nearest_tet, tet, weights);
+
+    weights = lvp_mask_weights_by_visibility(lookup_position, tet, weights);
+//    weights = lvp_mask_weights_by_visibility_by_normal(lookup_position, normal, tet, weights);
+
+    // square weights to mimic irradiance influence
+    // weights = weights * weights;
+
+    // re-normalize weights
+//    weights = normalize(weights);
+    weights = lpv_renormalize_weights(weights);
+
+    if(tet == INVALID_TET){
+        // do nothing
+        return vec3(0.0);
+
+    }else{
+
+        vec3[9] lpv_values = lpv_interpolate_probes(weights, tet);
+
+        return lpv_get_irradiance_at( normal, lpv_values  );
+
+    }
+}
+
+#endif

package/src/engine/graphics/sh3/gi/material/makeLookupTexture3D.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Uint32
+ * @param {number} resolution
+ * @returns {DataTexture3D}
+ */
+export function makeLookupTexture3D(resolution: number): DataTexture3D;
+import { DataTexture3D } from "three";
+//# sourceMappingURL=makeLookupTexture3D.d.ts.map

package/src/engine/graphics/sh3/gi/material/makeLookupTexture3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeLookupTexture3D.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeLookupTexture3D.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,gDAHW,MAAM,GACJ,aAAa,CA6BzB;8BAlCoG,OAAO"}

package/src/engine/graphics/sh3/gi/material/makeLookupTexture3D.js

@@ -0,0 +1,35 @@
+import { ClampToEdgeWrapping, DataTexture3D, NearestFilter, RedIntegerFormat, UnsignedIntType } from "three";
+
+/**
+ * Uint32
+ * @param {number} resolution
+ * @returns {DataTexture3D}
+ */
+export function makeLookupTexture3D(resolution) {
+
+    const lookup = new DataTexture3D(
+        new Uint32Array(resolution * resolution * resolution),
+        resolution,
+        resolution,
+        resolution
+    );
+
+    lookup.name = "Tetrahedron Lookup";
+
+    lookup.flipY = false;
+    lookup.generateMipmaps = false;
+    lookup.magFilter = NearestFilter;
+    lookup.minFilter = NearestFilter;
+
+    lookup.wrapT = ClampToEdgeWrapping;
+    lookup.wrapS = ClampToEdgeWrapping;
+    lookup.wrapR = ClampToEdgeWrapping;
+
+    lookup.type = UnsignedIntType;
+    lookup.format = RedIntegerFormat;
+    lookup.internalFormat = "R32UI";
+
+    lookup.needsUpdate = true;
+
+    return lookup;
+}

package/src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} resolution
+ * @returns {DataTexture}
+ */
+export function makeOctahedralDepthAtlas(resolution?: number): DataTexture;
+import { DataTexture } from "three";
+//# sourceMappingURL=makeOctahedralDepthAtlas.d.ts.map

package/src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeOctahedralDepthAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,GACJ,WAAW,CAsBvB;4BA3BqF,OAAO"}

package/src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js

@@ -0,0 +1,28 @@
+import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RedFormat } from "three";
+
+/**
+ *
+ * @param {number} resolution
+ * @returns {DataTexture}
+ */
+export function makeOctahedralDepthAtlas(resolution = 4096) {
+    const texture = new DataTexture(
+        new Float32Array(resolution * resolution),
+        resolution,
+        resolution,
+        RedFormat,
+        FloatType
+    );
+
+    texture.minFilter = texture.magFilter = NearestFilter;
+
+    texture.wrapT = ClampToEdgeWrapping;
+    texture.wrapS = ClampToEdgeWrapping;
+
+    texture.flipY = false;
+    texture.generateMipmaps = false;
+
+    texture.needsUpdate = true;
+
+    return texture;
+}

package/src/engine/graphics/sh3/gi/material/space_fragment/build_fragment_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/gi/material/space_fragment/build_fragment_shader.js"],"names":[],"mappings":"AAoCA;;;GAGG;AACH,8CAFW,MAAM,UAchB"}