@woosh/meep-engine 2.109.6 → 2.109.8

package/src/engine/graphics/impostors/octahedral/util/build_cutout_from_atlas_by_alpha.js

@@ -1,25 +1,38 @@
 //
 
-import { renderSamplerFromTexture } from "../../../render/visibility/hiz/buildCanvasViewFromTexture.js";
+import { assert } from "../../../../../core/assert.js";
+import { array_copy } from "../../../../../core/collection/array/array_copy.js";
+import { compute_polygon_area_2d } from "../../../../../core/geom/2d/compute_polygon_area_2d.js";
 import { convex_hull_jarvis_2d } from "../../../../../core/geom/2d/convex-hull/convex_hull_jarvis_2d.js";
 import { fixed_convex_hull_relaxation } from "../../../../../core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js";
-import { array_copy } from "../../../../../core/collection/array/array_copy.js";
-import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import { max2 } from "../../../../../core/math/max2.js";
-import { sampler2d_find_pixels } from "../../../texture/sampler/search/sampler2d_find_pixels.js";
+import { renderSamplerFromTexture } from "../../../render/visibility/hiz/buildCanvasViewFromTexture.js";
+import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import {
     make_edge_condition_channel_threshold
 } from "../../../texture/sampler/search/make_edge_condition_channel_threshold.js";
-import { compute_polygon_area_2d } from "../../../../../core/geom/2d/compute_polygon_area_2d.js";
+import { sampler2d_find_pixels } from "../../../texture/sampler/search/sampler2d_find_pixels.js";
 
 /**
  * TODO For this specific use-case with octahedral impostors we can get away tracing a circular shape in general.
  *      A circle is a lot easier to quantize (as long as we make sure we place edges outside of the circle)
  * @param {ImpostorDescription} impostor
  * @param {THREE.WebGLRenderer} renderer
- * @returns {number}
+ * @param {number} vertex_limit how many vertices to use for the billboard, more vertices will provide better fit and lower area reducing overdraw at the cost of extra triangles. Prefer values between 4 and 16
+ * @returns {number[]}
  */
-export function build_cutout_from_atlas_by_alpha(impostor, renderer) {
+export function build_cutout_from_atlas_by_alpha({
+
+                                                     impostor,
+                                                     renderer,
+                                                     vertex_limit = 8
+                                                 }) {
+
+    assert.isNonNegativeInteger(vertex_limit, 'vertex_limit');
+    assert.greaterThanOrEqual(vertex_limit, 3);
+
+    assert.defined(renderer, 'renderer');
+
     // get impostor data first
 
     const ctrl = renderSamplerFromTexture({
@@ -98,23 +111,21 @@ export function build_cutout_from_atlas_by_alpha(impostor, renderer) {
         array_copy(filtered_edge_pixels, hpi * 2, hull_points, i * 2, 2);
     }
 
-    const cutout_vertex_count = 8;
-
-    const cutout_points = new Float32Array(cutout_vertex_count * 2);
+    const cutout_points = new Float32Array(vertex_limit * 2);
 
-    fixed_convex_hull_relaxation(cutout_points, 0, cutout_vertex_count, hull_points, hull_point_indices.length);
+    fixed_convex_hull_relaxation(cutout_points, 0, vertex_limit, hull_points, hull_point_indices.length);
 
     // normalize points
-    for (let i = 0; i < cutout_vertex_count; i++) {
+    for (let i = 0; i < vertex_limit; i++) {
         cutout_points[i * 2] /= frame_size;
         cutout_points[i * 2 + 1] /= frame_size;
     }
 
-    const area = compute_polygon_area_2d(cutout_points, cutout_vertex_count);
+    const area = compute_polygon_area_2d(cutout_points, vertex_limit);
 
     console.log(`Cutout area: ${area}`);
 
-    if (area >= 0.99 && cutout_vertex_count >= 4) {
+    if (area >= 0.99 && vertex_limit >= 4) {
         // default back to aligned quad, produced result is a degradation
         return new Float32Array([
             0, 0,

package/src/engine/graphics/render/visibility/hiz/buildCanvasViewFromTexture.js

@@ -287,3 +287,4 @@ export function buildCanvasViewFromTexture({
         }
     }
 }
+

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

@@ -1 +1 @@
-{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/MaterialTransformer.js"],"names":[],"mappings":"AA0CA;IAoHI;;;OAGG;IACH,0CAMC;IAlBD;;;OAGG;IACH,2BAEC;IAdD;;;OAGG;IACH,wBAEC;IAsBD,sBAIC;IAED,sBA2CC;IAED,eAuCC;IAED,4BA2BC;;CACJ;4CA5R2C,0DAA0D"}
+{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/MaterialTransformer.js"],"names":[],"mappings":"AAiCA;IA0II;;;OAGG;IACH,0CAOC;IAnBD;;;OAGG;IACH,2BAEC;IAdD;;;OAGG;IACH,wBAEC;IAuBD,sBAIC;IAED,sBA2CC;IAED,eA+CC;IAED,4BA2BC;;CACJ;4CAlT2C,0DAA0D"}

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,13 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
             type: "t",
             value: this.#textures.harmonics.texture
         },
+        lpv_t_probe_depth: {
+            type: "t",
+            value: this.#textures.depth
+        },
+        lpv_u_probe_depth_resolution: {
+            value: 1
+        },
         lpv_t_mesh_lookup: {
             type: "t",
             value: this.#mesh_lookup
@@ -134,8 +139,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 +179,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
         super();
 
         this.#volume = volume;
+
     }
 
     update_bounds() {
@@ -204,7 +218,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
                     const w_y = n_y * bounds.getExtentsY() + bounds.y0;
                     const w_z = n_z * bounds.getExtentsZ() + bounds.z0;
 
-                    const tet = volume.mesh.findTetraContainingPoint(w_x, w_y, w_z, volume.points, last_tet);
+                    const tet = volume.mesh.walkToTetraContainingPoint(w_x, w_y, w_z, volume.points, last_tet);
 
                     if (tet !== -1) {
                         last_tet = tet;
@@ -232,15 +246,19 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
 
         this.update_lookup();
 
-        this.#uniforms.lpv_u_mesh_tet_count.value = lpv.mesh.count;
+        const uniforms = this.#uniforms;
 
-        this.#uniforms.lpv_v3_bounds_min.value.set(
+        uniforms.lpv_u_mesh_tet_count.value = lpv.mesh.count;
+
+        uniforms.lpv_v3_bounds_min.value.set(
             this.#mesh_bounds.x0, this.#mesh_bounds.y0, this.#mesh_bounds.z0
         );
-        this.#uniforms.lpv_v3_bounds_max.value.set(
+        uniforms.lpv_v3_bounds_max.value.set(
             this.#mesh_bounds.x1, this.#mesh_bounds.y1, this.#mesh_bounds.z1
         );
 
+        uniforms.lpv_u_probe_depth_resolution.value = lpv.depth_map_resolution;
+
         this.#uniform_version = lpv.version;
 
         console.time('prepareTextures');
@@ -250,9 +268,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];