@woosh/meep-engine 2.109.6 → 2.109.8

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {PathTracedScene} scene
+ * @param {number[]|Vector3} position
+ * @param {number} position_offset
+ * @param {number} resolution
+ * @param {number} max_depth
+ */
+export function bake_octahedral_depth_map(result: number[], result_offset: number, scene: PathTracedScene, position: number[] | Vector3, position_offset: number, resolution: number, max_depth: number): void;
+//# sourceMappingURL=bake_octahedral_depth_map.d.ts.map

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAuChB"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js

@@ -0,0 +1,58 @@
+import { array_copy } from "../../../../../../core/collection/array/array_copy.js";
+import {
+    decode_octahedron_to_unit
+} from "../../../../../../core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
+import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
+
+const scratch_ray = new Ray3();
+
+const ray_hit = [];
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {PathTracedScene} scene
+ * @param {number[]|Vector3} position
+ * @param {number} position_offset
+ * @param {number} resolution
+ * @param {number} max_depth
+ */
+export function bake_octahedral_depth_map(
+    result, result_offset,
+    scene,
+    position, position_offset,
+    resolution,
+    max_depth
+) {
+
+    scratch_ray.tMax = max_depth;
+    array_copy(position, position_offset, scratch_ray, 0, 3);
+
+    const ray_direction = scratch_ray.direction;
+
+    for (let oct_x = 0; oct_x < resolution; oct_x++) {
+        for (let oct_y = 0; oct_y < resolution; oct_y++) {
+
+            const u = (oct_x) / (resolution - 1);
+            const v = (oct_y) / (resolution - 1);
+
+            decode_octahedron_to_unit(
+                ray_direction, 0,
+                u * 2 - 1, v * 2 - 1
+            );
+
+            let distance = scene.trace(ray_hit, scratch_ray);
+
+            if (distance < 0) {
+                // no hit
+                distance = max_depth;
+            }
+
+            const pixel_index = oct_y * resolution + oct_x;
+
+            result[result_offset + pixel_index] = distance;
+        }
+    }
+
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/shader/OctahedralDepthVisualizationMaterial.d.ts

@@ -0,0 +1,11 @@
+export class OctahedralDepthVisualizationMaterial extends ShaderMaterial {
+    constructor();
+    set scale(arg: any);
+    /**
+     *
+     * @param {THREE.DataTexture} v
+     */
+    set texture(arg: import("three").DataTexture);
+}
+import { ShaderMaterial } from "three";
+//# sourceMappingURL=OctahedralDepthVisualizationMaterial.d.ts.map

package/src/engine/graphics/sh3/lpv/depth/octahedral/shader/OctahedralDepthVisualizationMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OctahedralDepthVisualizationMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/shader/OctahedralDepthVisualizationMaterial.js"],"names":[],"mappings":"AAIA;IAGI,cAmBC;IAED,oBAGC;IAED;;;OAGG;IACH,8CAKC;CAEJ;+BA5C8B,OAAO"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/shader/OctahedralDepthVisualizationMaterial.js

@@ -0,0 +1,45 @@
+import { ShaderMaterial } from "three";
+import shader_fg from './visualize.frag.glsl';
+import shader_vx from './visualize.vert.glsl';
+
+export class OctahedralDepthVisualizationMaterial extends ShaderMaterial {
+
+
+    constructor() {
+
+
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            lights: false,
+            uniforms: {
+                uResolution: {
+                    value: 1
+                },
+                fScale: { value: 1 },
+                tDepth: {
+                    value: null
+                }
+            }
+        })
+
+
+    }
+
+    set scale(v) {
+        this.uniforms.fScale.value = 1 / v;
+        this.uniformsNeedUpdate = true;
+    }
+
+    /**
+     *
+     * @param {THREE.DataTexture} v
+     */
+    set texture(v) {
+        this.uniforms.tDepth.value = v;
+        this.uniforms.uResolution.value = v.image.width;
+
+        this.uniformsNeedUpdate = true;
+    }
+
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/shader/visualize.frag.glsl

@@ -0,0 +1,126 @@
+vec3 inverseTransformDirection(in vec3 normal, in mat4 matrix) {
+    // matrix is assumed to be orthogonal
+    return normalize((vec4(normal, 0.0) * matrix).xyz);
+}
+
+vec3 OctaSphereEnc(vec2 coord)
+{
+    coord = (coord - 0.5) * 2.0;
+    vec3 position = vec3(coord.x, 0.0, coord.y);
+    vec2 absolute = abs(position.xz);
+    position.y = 1.0 - absolute.x - absolute.y;
+
+    if (position.y < 0.0)
+    {
+        position.xz = sign(position.xz) * vec2(1.0 - absolute.y, 1.0 - absolute.x);
+    }
+
+    return position;
+}
+
+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
+    );
+}
+
+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;
+}
+
+
+vec4 TriangleInterpolate(vec2 uv) {
+    uv = fract(uv);
+
+    vec2 omuv = vec2(1.0, 1.0) - uv.xy;
+
+    vec4 res = vec4(0, 0, 0, 0);
+    //frame 0
+    res.x = min(omuv.x, omuv.y);
+    //frame 1
+    res.y = abs(dot(uv, vec2(1.0, -1.0)));
+    //frame 2
+    res.z = min(uv.x, uv.y);
+    //mask
+    res.w = clamp(ceil(uv.x - uv.y), 0.0, 1.0);
+
+    return res;
+}
+
+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;
+}
+
+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;
+}
+
+
+
+
+uniform sampler2D tDepth; // octahedron-encoded texture
+uniform float fScale; // depth visualisation space
+uniform float uResolution; // texture resulution
+varying vec3 vNormal;
+
+void main() {
+    vec3 normal = normalize(vNormal);
+    vec3 worldNormal = normalize(inverseTransformDirection(normal, viewMatrix));
+
+    vec2 octahedral_uv = clamp(VecToSphereOct(worldNormal) * 0.5 + 0.5, 0.0, 1.0);
+    vec2 grid = octahedral_uv * vec2(uResolution - 1.0);
+
+    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);
+
+    float value = SampleBlended(tDepth, (frame0+0.5) / uResolution, (frame1+0.5) / uResolution, (frame2+0.5) / uResolution, weights) * fScale;
+
+    gl_FragColor = vec4(vec3(value), 1.0);
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/shader/visualize.vert.glsl

@@ -0,0 +1,10 @@
+varying vec3 vNormal;
+
+void main() {
+
+    vNormal = normalize( normalMatrix * normal );
+
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.d.ts

@@ -0,0 +1,13 @@
+export class VLPDepthMapVisualisation {
+    /**
+     *
+     * @param {LightProbeVolume} lpv
+     * @returns {VLPDepthMapVisualisation}
+     */
+    static from(lpv: LightProbeVolume): VLPDepthMapVisualisation;
+    set volume(arg: any);
+    build(): Entity;
+    #private;
+}
+import Entity from "../../../../../../ecs/Entity.js";
+//# sourceMappingURL=VLPDepthMapVisualisation.d.ts.map

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VLPDepthMapVisualisation.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js"],"names":[],"mappings":"AA6EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAzIkB,iCAAiC"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js

@@ -0,0 +1,149 @@
+import {
+    Box3,
+    InstancedBufferAttribute,
+    InstancedBufferGeometry,
+    OctahedronBufferGeometry,
+    ShaderMaterial,
+    Sphere
+} 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";
+import Entity from "../../../../../../ecs/Entity.js";
+import { Transform } from "../../../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../../../../../ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../../../../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { AttributeSpec } from "../../../../../geometry/AttributeSpec.js";
+import { geometry_copy } from "../../../../../geometry/instancing/geometry_copy.js";
+import { AttributeDataTexture } from "../../../../../texture/AttributeDataTexture.js";
+import { makeOctahedralDepthAtlas } from "../../../../gi/material/makeOctahedralDepthAtlas.js";
+import { octahedral_depth_to_atlas, vector_buffer_to_attribute_texture } from "../../../probe_volume_to_textures.js";
+import fragment from './visualise.frag.glsl'
+import vertex from './visualise.vert.glsl'
+
+/**
+ *
+ * @param {LightProbeVolume} lpv
+ */
+function makeMaterial(lpv) {
+    const depth_atlas = makeOctahedralDepthAtlas();
+    const positions = new AttributeDataTexture(
+        AttributeSpec.fromJSON({
+            name: "positions",
+            type: BinaryDataType.Float32,
+            itemSize: 3,
+            normalized: false
+        }),
+        256, 1
+    );
+    vector_buffer_to_attribute_texture(positions, lpv.points, lpv.count, 3);
+    octahedral_depth_to_atlas(lpv, depth_atlas.image.data, depth_atlas.image.width);
+
+    const material = new ShaderMaterial({
+        fragmentShader: [fragment].join('\n'),
+        vertexShader: vertex,
+        lights: false,
+        uniforms: {
+            lpv_t_probe_positions: {
+                value: positions.texture
+            },
+            lpv_t_probe_depth: {
+                value: depth_atlas
+            },
+            lpv_u_probe_depth_resolution:{
+                value: lpv.depth_map_resolution
+            }
+        }
+    });
+
+    return material;
+}
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @param {AABB3} bounds
+ */
+function buffer_geometry_set_bounds_by_aabb3(geometry, bounds) {
+    geometry.boundingBox = new Box3()
+    geometry.boundingSphere = new Sphere()
+
+    geometry.boundingBox.min.set(bounds.x0, bounds.y0, bounds.z0);
+    geometry.boundingBox.max.set(bounds.x1, bounds.y1, bounds.z1);
+
+    bounds.getCenter(geometry.boundingSphere.center);
+    geometry.boundingSphere.radius = Math.hypot(bounds.getHalfExtentsX(), bounds.getHalfExtentsY(), bounds.getHalfExtentsZ());
+}
+
+export class VLPDepthMapVisualisation {
+
+    /**
+     * @type {LightProbeVolume}
+     */
+    #volume
+
+
+    set volume(lpv) {
+        this.#volume = lpv;
+    }
+
+    /**
+     *
+     * @param {LightProbeVolume} lpv
+     * @returns {VLPDepthMapVisualisation}
+     */
+    static from(lpv) {
+        const r = new VLPDepthMapVisualisation();
+
+        r.volume = lpv;
+
+        return r;
+    }
+
+    build() {
+
+        const geometry = new InstancedBufferGeometry();
+
+        const volume = this.#volume;
+
+        geometry.instanceCount = volume.count;
+
+        geometry_copy(geometry, new OctahedronBufferGeometry(0.4, 4));
+
+        const positions_attribute = new InstancedBufferAttribute(new Float32Array(volume.points), 3);
+        geometry.setAttribute("instancePosition", positions_attribute);
+
+        const bounds = new AABB3();
+
+        aabb3_from_v3_array(bounds, volume.points, volume.points.length);
+
+        const instance_bounds = new AABB3();
+
+        const geo_position_data = geometry.getAttribute('position').array;
+        aabb3_from_v3_array(instance_bounds, geo_position_data, geo_position_data.length);
+
+        // extend by bounds of a single instance
+        bounds.x0 += instance_bounds.x0;
+        bounds.y0 += instance_bounds.y0;
+        bounds.z0 += instance_bounds.z0;
+
+        bounds.x1 += instance_bounds.x1;
+        bounds.y1 += instance_bounds.y1;
+        bounds.z1 += instance_bounds.z1;
+
+        buffer_geometry_set_bounds_by_aabb3(geometry, bounds);
+
+        const sg = ShadedGeometry.from(geometry, makeMaterial(volume));
+
+        sg.setFlag(ShadedGeometryFlags.DrawMethodLocked);
+
+        const entity = new Entity();
+
+        entity.add(new Transform());
+        entity.add(sg);
+
+        return entity;
+
+    }
+
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/visualise.frag.glsl

@@ -0,0 +1,161 @@
+
+
+vec3 inverseTransformDirection(in vec3 normal, in mat4 matrix) {
+    // matrix is assumed to be orthogonal
+    return normalize((vec4(normal, 0.0) * matrix).xyz);
+}
+
+
+precision highp usampler2D;
+precision highp usampler3D;
+
+uniform sampler2D lpv_t_probe_positions;
+uniform sampler2D lpv_t_probe_depth;
+
+uniform uint lpv_u_probe_depth_resolution;
+
+#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));
+}
+
+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.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 = 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;
+
+    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 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;
+}
+
+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(depth, length(local_probe_offset));
+    return step(depth, 20.0);
+}
+
+varying vec3 vNormal;
+flat varying uint instance_index;
+
+void main() {
+    vec3 normal = normalize(vNormal);
+    vec3 worldNormal = normalize(inverseTransformDirection(normal, viewMatrix));
+
+    float depth = lpv_probe_getDepth(instance_index , worldNormal) / 7.0;
+
+    gl_FragColor = vec4(vec3(depth), 1.0);
+//    gl_FragColor = vec4( 1.0);
+}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/visualise.vert.glsl

@@ -0,0 +1,13 @@
+varying vec3 vNormal;
+
+attribute vec3 instancePosition;
+flat varying uint instance_index;
+
+void main() {
+
+    vNormal = normalize( normalMatrix * normal );
+    instance_index = uint(gl_InstanceID);
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4( position + instancePosition, 1.0 );
+
+}

package/src/engine/graphics/sh3/lpv/depth/sh3_bake_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_bake_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpv/depth/sh3_bake_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,uCATW,MAAM,EAAE,iBACR,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,eACN,MAAM,QAsDhB"}

package/src/engine/graphics/sh3/lpv/{sh3_bake_depth.js → depth/sh3_bake_depth.js}

@@ -1,10 +1,10 @@
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
-import { sh3_basis_at } from "../../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
-import { sh3_vector_accumulate } from "../../../../core/geom/3d/sphere/harmonics/sh3_vector_accumulate.js";
-import { vector_scale_array } from "../../../../core/geom/vec/vector_scale_array.js";
-import { clamp01 } from "../../../../core/math/clamp01.js";
-import { OctahedralUvEncoder } from "../../impostors/octahedral/grid/OctahedralUvEncoder.js";
+import { array_copy } from "../../../../../core/collection/array/array_copy.js";
+import { Ray3 } from "../../../../../core/geom/3d/Ray3.js";
+import { sh3_basis_at } from "../../../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
+import { sh3_vector_accumulate } from "../../../../../core/geom/3d/sphere/harmonics/sh3_vector_accumulate.js";
+import { vector_scale_array } from "../../../../../core/geom/vec/vector_scale_array.js";
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+import { OctahedralUvEncoder } from "../../../impostors/octahedral/grid/OctahedralUvEncoder.js";
 
 /**
  *

package/src/engine/graphics/sh3/lpv/find_max_depth_radius_for_point.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} vertex_index
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points
+ */
+export function find_max_depth_radius_for_point(vertex_index: number, mesh: TetrahedralMesh, points: number[]): number;
+//# sourceMappingURL=find_max_depth_radius_for_point.d.ts.map

package/src/engine/graphics/sh3/lpv/find_max_depth_radius_for_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find_max_depth_radius_for_point.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/find_max_depth_radius_for_point.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,8DAJW,MAAM,iCAEN,MAAM,EAAE,UAiClB"}