@woosh/meep-engine 2.109.6 → 2.109.8

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

@@ -0,0 +1,484 @@
+#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_probe_depth_resolution;
+
+uniform uint lpv_u_mesh_tet_count;
+uniform vec3 lpv_v3_bounds_min;
+uniform vec3 lpv_v3_bounds_max;
+
+
+const float lpv_min_thickness = 0.03; // in Meters
+const float lpv_max_thickness = 0.50; // in Meters
+
+
+#define SEARCH_STEP_LIMIT 32u
+#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;
+}
+
+vec2 lpv_probe_getDepth(uint probe_index, vec3 direction) {
+    // get offset
+    uint depth_tile_resolution = lpv_u_probe_depth_resolution;
+    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;
+
+    float samp0 = texelFetch(lpv_t_probe_depth, ivec2(frame0), 0).r;
+    float samp1 = texelFetch(lpv_t_probe_depth, ivec2(frame1), 0).r;
+    float samp2 = texelFetch(lpv_t_probe_depth, ivec2(frame2), 0).r;
+
+    float mean = samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
+    float mean2 = samp0 * samp0 * weights.x + samp1 * samp1 * weights.y + samp2 * samp2 * weights.z;
+
+    return vec2(mean, mean2);
+}
+
+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_walk_to_tetrahedron(
+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;
+
+    float distToProbe = length(local_probe_offset);
+
+    vec3 direction = normalize(local_probe_offset);
+
+    vec2 temp = lpv_probe_getDepth(probe_index, direction);
+
+    float mean = temp.x;
+    float variance = abs(mean * mean - temp.y);
+
+    // http://www.punkuser.net/vsm/vsm_paper.pdf; equation 5
+    // Need the max in the denominator because biasing can cause a negative displacement
+    float distance_delta = max(distToProbe - mean, 0.0);
+
+    float chebyshevWeight = variance / (variance + distance_delta * distance_delta);
+
+    // Increase contrast in the weight
+//    chebyshevWeight = max(chebyshevWeight*chebyshevWeight*chebyshevWeight, 0.0);
+
+    return (distToProbe <= mean) ? 1.0 : chebyshevWeight;
+}
+
+vec4 lvp_mask_weights_by_visibility_by_depth(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;
+}
+
+float lpv_probe_visibility_weight(uint probe_index, vec3 position, vec3 normal) {
+    float weight = 1.0;
+
+    vec3 probe_position = lpv_probe_getPosition(probe_index);
+
+    vec3 direction_to_probe = normalize(probe_position - position);
+
+    // Smooth backface test
+
+
+    // The naive soft backface weight would ignore a probe when
+    // it is behind the surface. That's good for walls. But for small details inside of a
+    // room, the normals on the details might rule out all of the probes that have mutual
+    // visibility to the point. So, we instead use a "wrap shading" test below inspired by
+    // NPR work.
+    // weight *= max(0.0001, dot(direction_to_probe, normal));
+
+    // The small offset at the end reduces the "going to zero" impact
+    // where this is really close to exactly opposite
+    float backface_term = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
+    weight *= backface_term * backface_term + 0.2;
+
+    weight *= lpv_probe_getVisibilityMask(position, probe_index);
+
+    // Avoid zero weight
+    weight = max(0.000001, weight);
+
+    return weight;
+}
+
+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;
+}
+
+vec4 lvp_mask_weights_by_visibility(vec3 position, vec3 normal, uint tet_index) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec4 visibility;
+
+    for (int i = 0; i < 4; i++) {
+        visibility[i] = lpv_probe_visibility_weight(vertices[i], position, normal);
+    }
+
+    return visibility;
+}
+
+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;
+}
+
+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;
+
+    if (sum <= 0.0) {
+        return vec4(1.0);
+    }
+
+    return source / sum;
+
+}
+
+
+
+/** Slightly bump the location of the shadow test point away from the shadow casting surface.
+    The shadow casting surface is the boundary for shadow, so the nearer an imprecise value is
+    to it the more the light leaks.
+*/
+#define LPV_NORMAL_BIAS 0.01f
+
+vec3 lpv_sample_irradiance(vec3 position, vec3 normal, vec3 view_direction) {
+
+    // Bias the position at which visibility is computed; this
+    // avoids performing a shadow test *at* a surface, which is a
+    // dangerous location because that is exactly the line between
+    // shadowed and unshadowed. If the normal bias is too small,
+    // there will be light and dark leaks. If it is too large,
+    // then samples can pass through thin occluders to the other
+    // side (this can only happen if there are MULTIPLE occluders
+    // near each other, a wall surface won't pass through itself.)
+    vec3 lookup_position = position + (normal + view_direction * 3.0) * 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_walk_to_tetrahedron(lookup_position, nearest_tet, tet, weights);
+
+    // apply visibility term
+    //    weights = lvp_mask_weights_by_visibility_by_depth(lookup_position, tet, weights);
+    //    weights = lvp_mask_weights_by_visibility_by_normal(lookup_position,normal, tet, weights);
+    weights *= lvp_mask_weights_by_visibility(lookup_position, normal, tet);
+
+    // re-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":"AAkCA;;;GAGG;AACH,8CAFW,MAAM,UAchB"}

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

@@ -0,0 +1,51 @@
+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, geometry.viewDir );
+        
+        irradiance += probe_irradiance * lpv_f_intensity;
+        
+    }
+
+
+`;
+
+
+/**
+ *
+ * @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