@woosh/meep-engine 2.109.6 → 2.109.7

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"}

package/src/engine/graphics/sh3/gi/material/space_fragment/build_fragment_shader.js

@@ -0,0 +1,53 @@
+import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import PREAMBLE_COMMON from "../common.glsl";
+
+const PREAMBLE = `
+#ifndef LPV_SHADER_CHUNK_PREAMBLE
+#define LPV_SHADER_CHUNK_PREAMBLE
+
+precision highp usampler2D;
+precision highp usampler3D;
+
+varying vec3 vWorldPosition;
+
+uniform float lpv_f_intensity;
+
+
+#endif
+
+`;
+
+const ACCUMULATION = `
+    {
+    
+        vec3 world_normal = normalize(inverseTransformDirection( geometry.normal, viewMatrix ));
+        
+        vec3 probe_irradiance = lpv_sample_irradiance( vWorldPosition, world_normal );
+        
+        irradiance += probe_irradiance * lpv_f_intensity;
+        // irradiance += vec3(1.0) * step(probe_irradiance.r,1.0);
+        //    
+        // material.diffuseColor.rgb = vec3(1.0) ;
+    }
+
+
+`;
+
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source) {
+
+    let result = PREAMBLE + PREAMBLE_COMMON + source;
+
+
+    result = insert_after(
+        result,
+        '#include <lights_fragment_begin>',
+        ACCUMULATION
+    );
+
+    return result;
+}

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

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

package/src/engine/graphics/sh3/gi/material/space_fragment/build_vertex_shader.js

@@ -0,0 +1,29 @@
+import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+
+
+const PREAMBLE = `
+    varying vec3 vWorldPosition;
+`;
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source) {
+
+    let result = PREAMBLE + source;
+
+    result = insert_after(
+        result,
+        '#include <fog_vertex>',
+        `
+        {
+            vWorldPosition = worldPosition.xyz;
+        }
+        `
+    );
+
+    // console.log(result)
+
+    return result;
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {{vertexShader, fragmentShader}} shader
+ */
+export function space_fragment_transform_shader(shader: {
+    vertexShader;
+    fragmentShader;
+}): void;
+//# sourceMappingURL=space_fragment_transform_shader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"space_fragment_transform_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/gi/material/space_fragment/space_fragment_transform_shader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wDAFW;IAAC,YAAY,CAAC;IAAC,cAAc,CAAA;CAAC,QAMxC"}

package/src/engine/graphics/sh3/gi/material/space_fragment/space_fragment_transform_shader.js

@@ -0,0 +1,12 @@
+import { build_fragment_shader } from "./build_fragment_shader.js";
+import { build_vertex_shader } from "./build_vertex_shader.js";
+
+/**
+ *
+ * @param {{vertexShader, fragmentShader}} shader
+ */
+export function space_fragment_transform_shader(shader) {
+
+    shader.vertexShader = build_vertex_shader(shader.vertexShader);
+    shader.fragmentShader = build_fragment_shader(shader.fragmentShader);
+}

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

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source: string): string;
+//# sourceMappingURL=build_fragment_shader.d.ts.map

package/src/engine/graphics/sh3/gi/material/space_vertex/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_vertex/build_fragment_shader.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,8CAFW,MAAM,UAchB"}

package/src/engine/graphics/sh3/gi/material/space_vertex/build_fragment_shader.js

@@ -0,0 +1,26 @@
+import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+
+import PREAMBLE from "./preable.frag.glsl";
+
+const ACCUMULATION = `
+    irradiance += getLightProbeIrradiance(lpv_values, geometryNormal )* lpv_f_intensity;
+`;
+
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source) {
+
+    let result = PREAMBLE + source;
+
+
+    result = insert_after(
+        result,
+        '#include <lights_fragment_begin>',
+        ACCUMULATION
+    );
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/material/space_vertex/build_vertex_shader.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source: string): string;
+//# sourceMappingURL=build_vertex_shader.d.ts.map

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

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