@woosh/meep-engine 2.109.6 → 2.109.7

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":"AA0EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAtIkB,iCAAiC"}

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

@@ -0,0 +1,146 @@
+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
+            }
+        }
+    });
+
+    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,159 @@
+
+
+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;
+
+#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 = 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 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) / 10.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/probe_volume_to_textures.d.ts

@@ -1,13 +1,10 @@
 /**
  *
  * @param {LightProbeVolume} lpv
+ * @param {number[]} atlas_data
+ * @param {number} atlas_width
  */
-export function probe_volume_to_textures(lpv: LightProbeVolume): {
-    mesh_vertices: AttributeDataTexture;
-    mesh_neighbours: AttributeDataTexture;
-    probe_positions: AttributeDataTexture;
-    probe_values: AttributeDataTexture;
-};
+export function octahedral_depth_to_atlas(lpv: LightProbeVolume, atlas_data: number[], atlas_width: number): void;
 /**
  *
  * @param {AttributeDataTexture} target

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

@@ -1 +1 @@
-{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH;;;;;EAuDC;AAED;;;;;;GAMG;AACH,2DALW,oBAAoB,UACpB,MAAM,EAAE,eACR,MAAM,eACN,MAAM,QAiBhB;qCAtFoC,uCAAuC"}
+{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6EAHW,MAAM,EAAE,eACR,MAAM,QAiChB;AAGD;;;;;;GAMG;AACH,2DALW,oBAAoB,UACpB,MAAM,EAAE,eACR,MAAM,eACN,MAAM,QAiBhB;qCAhEoC,uCAAuC"}

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.js

@@ -1,70 +1,46 @@
-import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { AttributeSpec } from "../../geometry/AttributeSpec.js";
 import { AttributeDataTexture } from "../../texture/AttributeDataTexture.js";
-import { tetrahedral_mesh_to_texture } from "../gi/tetrahedral_mesh_to_texture.js";
 
 /**
  *
  * @param {LightProbeVolume} lpv
+ * @param {number[]} atlas_data
+ * @param {number} atlas_width
  */
-export function probe_volume_to_textures(lpv) {
-
-    const tex_vertices = new AttributeDataTexture(
-        AttributeSpec.fromJSON({
-            name: "vertex",
-            type: BinaryDataType.Uint16,
-            itemSize: 4,
-            normalized: false
-        }),
-        256, 1
-    );
-
-    const tex_neighbours = new AttributeDataTexture(
-        AttributeSpec.fromJSON({
-            name: "neighbour",
-            type: BinaryDataType.Uint32,
-            itemSize: 4,
-            normalized: false
-        }),
-        256, 1
-    );
-
-    const tex_positions = new AttributeDataTexture(
-        AttributeSpec.fromJSON({
-            name: "positions",
-            type: BinaryDataType.Float32,
-            itemSize: 3,
-            normalized: false
-        }),
-        256, 1
-    );
-
-    const tex_harmonics = new AttributeDataTexture(
-        AttributeSpec.fromJSON({
-            name: "harmonics",
-            type: BinaryDataType.Float32,
-            itemSize: 3,
-            normalized: false
-        }),
-        256, 9
-    );
-
-    vector_buffer_to_attribute_texture(tex_positions, lpv.points, lpv.count, 3);
-    vector_buffer_to_attribute_texture(tex_harmonics, lpv.harmonics, lpv.count * 9, 3);
-    tetrahedral_mesh_to_texture(
-        tex_vertices, tex_neighbours, lpv.mesh
-    );
-
-    return {
-        mesh_vertices: tex_vertices,
-        mesh_neighbours: tex_neighbours,
-
-        probe_positions: tex_positions,
-        probe_values: tex_harmonics
-    };
+export function octahedral_depth_to_atlas(lpv, atlas_data, atlas_width) {
+    const tile_resolution = lpv.depth_map_resolution;
+    const probe_count = lpv.count;
+    const probe_depth = lpv.depth;
+
+    const tiles_per_row = Math.floor(atlas_width / tile_resolution);
+
+    // populate atlas
+    for (let i = 0; i < probe_count; i++) {
+
+        const tile_x = i % tiles_per_row;
+        const tile_y = (i / tiles_per_row) >>> 0;
+
+        for (let pixel_y = 0; pixel_y < tile_resolution; pixel_y++) {
+            for (let pixel_x = 0; pixel_x < tile_resolution; pixel_x++) {
+
+                const source_offset = i * tile_resolution * tile_resolution;
+
+                const tile_pixel_index = pixel_y * tile_resolution + pixel_x;
+
+                const source_value = probe_depth[source_offset + tile_pixel_index];
+
+                const target_pixel_x = tile_x * tile_resolution + pixel_x;
+                const target_pixel_y = tile_y * tile_resolution + pixel_y;
+
+                const target_pixel_index = target_pixel_y * atlas_width + target_pixel_x;
+
+                atlas_data[target_pixel_index] = source_value;
+            }
+        }
+    }
 }
 
+
 /**
  *
  * @param {AttributeDataTexture} target

package/src/engine/graphics/sh3/lpv/serialization/LightProbeVolumeSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolumeSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpv/serialization/LightProbeVolumeSerializationAdapter.js"],"names":[],"mappings":"AAGA;IAEI,+BAAwB;IAGxB;;;;OAIG;IACH,8BAFW,gBAAgB,QAY1B;IAED;;;;OAIG;IACH,gCAFW,gBAAgB,QAc1B;CACJ;gDA3C+C,mEAAmE;iCAClF,wBAAwB"}
+{"version":3,"file":"LightProbeVolumeSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpv/serialization/LightProbeVolumeSerializationAdapter.js"],"names":[],"mappings":"AAGA;IAEI,+BAAwB;IAGxB;;;;OAIG;IACH,8BAFW,gBAAgB,QAiB1B;IAED;;;;OAIG;IACH,gCAFW,gBAAgB,QAiB1B;CACJ;gDAnD+C,mEAAmE;iCAClF,wBAAwB"}