@woosh/meep-engine 2.107.0 → 2.108.2

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

@@ -0,0 +1,35 @@
+/**
+ *  @abstract
+ */
+export class ProbeRenderer {
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @abstract
+     */
+    build_scene(ecd) {
+    }
+
+    /**
+     *  @abstract
+     */
+    async bake_start() {
+    }
+
+    /**
+     *  @abstract
+     */
+    bake_end() {
+    }
+
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     * @abstract
+     */
+    bake(position, position_offset, output, output_offset) {
+    }
+}

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

@@ -0,0 +1,27 @@
+export class WebGLCubeProbeRenderer extends ProbeRenderer {
+    /**
+     *
+     * @type {THREE.WebGLRenderer|null}
+     * @private
+     */
+    private __renderer;
+    render_target: WebGLCubeRenderTarget;
+    /**
+     * Used to read out GPU memory for each face
+     * @type {Uint8Array}
+     * @private
+     */
+    private __cube_face_raw;
+    __cube_camera: CubeCamera;
+    /**
+     *
+     * @type {Scene}
+     * @private
+     */
+    private __scene;
+    bake_start(): void;
+}
+import { ProbeRenderer } from "./ProbeRenderer.js";
+import { WebGLCubeRenderTarget } from "three";
+import { CubeCamera } from "three";
+//# sourceMappingURL=WebGLCubeProbeRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLCubeProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js"],"names":[],"mappings":"AAuBA;IAIQ;;;;OAIG;IACH,mBAAsB;IAEtB,qCASE;IAEF;;;;OAIG;IACH,wBAA8F;IAG9F,0BAAiE;IAEjE;;;;OAIG;IACH,gBAA0B;IA8C9B,mBAMC;CA6CJ;8BAxI6B,oBAAoB;sCAZ3C,OAAO;2BAAP,OAAO"}

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

@@ -0,0 +1,158 @@
+import {
+    CubeCamera,
+    LinearEncoding,
+    LinearFilter,
+    MeshStandardMaterial,
+    RGBAFormat,
+    Scene,
+    VSMShadowMap,
+    WebGLCubeRenderTarget
+} from "three";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { three_set_shadow_resolution } from "../../ecs/light/binding/three/ThreeLightBinding.js";
+import { threeMakeLight } from "../../ecs/light/binding/three/threeMakeLight.js";
+import { Light } from "../../ecs/light/Light.js";
+import { ThreeLightCache } from "../../ecs/light/three/ThreeLightCache.js";
+import { build_three_object } from "../../ecs/mesh-v2/build_three_object.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { applyTransformToThreeObject } from "../../ecs/mesh/applyTransformToThreeObject.js";
+import { WebGLRendererPool } from "../../render/RendererPool.js";
+import { fromCubeRenderTarget } from "../fromCubeRenderTarget.js";
+import { ProbeRenderer } from "./ProbeRenderer.js";
+
+export class WebGLCubeProbeRenderer extends ProbeRenderer {
+    constructor() {
+
+        super();
+        /**
+         *
+         * @type {THREE.WebGLRenderer|null}
+         * @private
+         */
+        this.__renderer = null;
+
+        this.render_target = new WebGLCubeRenderTarget(32, {
+            format: RGBAFormat,
+            minFilter: LinearFilter,
+            magFilter: LinearFilter,
+            depthBuffer: true,
+            scissorTest: false,
+            stencilBuffer: false,
+            generateMipmaps: false,
+            encoding: LinearEncoding
+        });
+
+        /**
+         * Used to read out GPU memory for each face
+         * @type {Uint8Array}
+         * @private
+         */
+        this.__cube_face_raw = new Uint8Array(this.render_target.width * this.render_target.width * 4);
+
+
+        this.__cube_camera = new CubeCamera(0.1, 100, this.render_target);
+
+        /**
+         *
+         * @type {Scene}
+         * @private
+         */
+        this.__scene = new Scene();
+        // this.__scene.autoUpdate = false;
+        // this.__scene.matrixAutoUpdate = false;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     */
+    build_scene(ecd) {
+        this.__scene.children.splice(0, this.__scene.children.length);
+        ecd.traverseEntities([ShadedGeometry, Transform], (sg, t, entity) => {
+            const object3D = build_three_object(sg);
+            const source_material = sg.material;
+            //
+            if (source_material.isMeshStandardMaterial === true) {
+                object3D.material = new MeshStandardMaterial({
+                    map: source_material.map,
+                });
+                object3D.material.color.copy(source_material.color);
+            } else {
+                object3D.material = source_material.clone();
+            }
+            applyTransformToThreeObject(object3D, t);
+            array_copy(t.matrix, 0, object3D.matrixWorld.elements, 0, 16);
+            this.__scene.add(object3D);
+        });
+        const lightCache = new ThreeLightCache();
+        ecd.traverseEntities([Light, Transform], (light, t) => {
+            /**
+             *
+             * @type {DirectionalLight|SpotLight|PointLight|AmbientLight}
+             */
+            const object = threeMakeLight(light, lightCache);
+            applyTransformToThreeObject(object, t);
+            const shadow = object.shadow;
+            if (shadow !== undefined) {
+                shadow.radius = 1;
+                shadow.blurSamples = 8;
+                three_set_shadow_resolution(shadow, 2048);
+            }
+            this.__scene.add(object);
+        });
+        // this.__scene.add(this.__cube_camera);
+    }
+
+    bake_start() {
+        const renderer = WebGLRendererPool.global.get();
+        this.__renderer = renderer;
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = VSMShadowMap;
+        // this.__renderer = this.ge.getRenderer();
+    }
+
+    bake_end() {
+        WebGLRendererPool.global.release(this.__renderer);
+        this.__renderer = null;
+    }
+
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     */
+    bake(position, position_offset, output, output_offset) {
+        // console.warn(position_offset, output_offset);
+        // const ge = this.ge;
+        const renderer = this.__renderer;
+        const _rt = renderer.getRenderTarget();
+        const _rt_active_face = renderer.getActiveCubeFace();
+        const _acc = renderer.autoClearColor;
+        const _acd = renderer.autoClearDepth;
+        const _ac = renderer.autoClear;
+        const _outputEncoding = renderer.outputEncoding;
+        renderer.outputEncoding = LinearEncoding;
+        renderer.autoClearColor = true;
+        renderer.autoClearDepth = true;
+        renderer.autoClear = true;
+        this.__cube_camera.position.fromArray(position, position_offset);
+        this.__cube_camera.children.forEach(c => {
+            c.updateProjectionMatrix();
+            c.updateMatrix();
+            c.updateMatrixWorld(true);
+        });
+        this.__cube_camera.update(renderer, this.__scene);
+        // compute coefficients from renderer
+        const probe_coefficients = fromCubeRenderTarget(this.__cube_face_raw, renderer, this.render_target);
+        array_copy(probe_coefficients, 0, output, output_offset, 27);
+        // restore state
+        renderer.setRenderTarget(_rt, _rt_active_face);
+        renderer.autoClearColor = _acc;
+        renderer.autoClearDepth = _acd;
+        renderer.autoClear = _ac;
+        renderer.outputEncoding = _outputEncoding;
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [density]
+ * @returns {Promise<LightProbeVolume>}
+ */
+export function build_probes_for_scene({ engine, ecd, bounds, density }: Engine): Promise<LightProbeVolume>;
+import { LightProbeVolume } from "./LightProbeVolume.js";
+//# sourceMappingURL=build_probes_for_scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,kFAFa,QAAQ,gBAAgB,CAAC,CA8GrC;iCAtHgC,uBAAuB"}

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

@@ -0,0 +1,127 @@
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { make_justified_point_grid } from "../../../../core/geom/3d/util/make_justified_point_grid.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { delay } from "../../../../core/process/delay.js";
+import Entity from "../../../ecs/Entity.js";
+import GUIElement from "../../../ecs/gui/GUIElement.js";
+import ViewportPosition from "../../../ecs/gui/position/ViewportPosition.js";
+import { makeSimpleTaskProgressView } from "../../../makeSimpleTaskProgressView.js";
+import { LightProbeVolume } from "./LightProbeVolume.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [density]
+ * @returns {Promise<LightProbeVolume>}
+ */
+export async function build_probes_for_scene(
+    {
+        engine,
+        ecd,
+        bounds,
+        density = 1000
+    }
+) {
+
+    const lpv = new LightProbeVolume();
+
+    // lpv.add_point(10, 5, 10);
+
+    // const desired_density = 8000;
+    const desired_frequency = Math.cbrt(density);
+
+
+    // const light_volume_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    const probe_grid_spacing_dense = Math.min(bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()) / desired_frequency;
+    const probe_grid_spacing_sparse = Math.max(bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()) / desired_frequency;
+
+    const probe_grid_spacing = (probe_grid_spacing_sparse / probe_grid_spacing_dense) < 2 ? probe_grid_spacing_dense : probe_grid_spacing_sparse * 0.5;
+    //
+    // const probe_grid_spacing =desired_density/ (mesh_asset.boundingBox.getExtentsX()* mesh_asset.boundingBox.getExtentsY()* mesh_asset.boundingBox.getExtentsZ());
+
+    const model_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    model_bounds.copy(bounds);
+    // model_bounds._translate(composition.transform.position.x, composition.transform.position.y, composition.transform.position.z);
+    model_bounds.grow(probe_grid_spacing * 1.05);
+
+
+    // sg_hierarchy_compute_bounding_box_via_parent_entity(light_volume_bounds, composition.entity.entity, ecd);
+
+    // for (let i = 0; i < 100; i++) {
+    //     lpv.add_point(
+    //         randomFloatBetween(random, light_volume_bounds.x0, light_volume_bounds.x1),
+    //         randomFloatBetween(random,  light_volume_bounds.y0, light_volume_bounds.y1),
+    //         randomFloatBetween(random,  light_volume_bounds.z0, light_volume_bounds.z1),
+    //     );
+    // }
+
+    make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
+        lpv.add_point(x, y, z);
+    });
+
+    // lpv.add_point(10, 1, -10);
+
+    await delay(2000);
+
+    //
+    // console.profile('lpv build');
+    //
+    const task = lpv.build(ecd);
+    // console.profileEnd('lpv build');
+
+    const progress = makeSimpleTaskProgressView({
+        task,
+        localization: engine.localization,
+        size: new Vector2(512, 64)
+    });
+
+    const progress_entity = new Entity();
+    progress_entity
+        .add(GUIElement.fromView(progress))
+        .add(ViewportPosition.fromJSON({
+            position: new Vector2(0, 1),
+            anchor: new Vector2(0, 1),
+            offset: new Vector2(16, -16)
+        }))
+        .build(ecd);
+
+    task.promise().finally(() => progress_entity.destroy())
+
+    engine.executor.runGroup(task);
+
+    // fill probes with random data
+    // for (let i = 0; i < lpv.__length * 27; i++) {
+    //     lpv.__probe_data[i] = random();
+    // }
+
+    // for (let i = 0; i < lpv.__length; i++) {
+    //
+    //     for (let j = 0; j < 9; j++) {
+    //         lpv.__probe_data[(i * 9 + j) * 3] = max2(0, (lpv.__positions[i * 3] + 10) / 20);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 1] = max2(0, (lpv.__positions[i * 3 + 1] - 0.5) / 10.5);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 2] = max2(0, (lpv.__positions[i * 3 + 2] + 10) / 20);
+    //     }
+    // }
+
+    // lpv.white_probe(0, [
+    //     0.7953949, 0.4405923, 0.5459412,
+    //     0.3981450, 0.3526911, 0.6097158,
+    //     -0.3424573, -0.1838151, -0.2715583,
+    //
+    //     -0.2944621, -0.0560606, 0.0095193,
+    //     -0.1123051, -0.0513088, -0.1232869,
+    //     -0.2645007, -0.2257996, -0.4785847,
+    //
+    //     -0.1569444, -0.0954703, -0.1485053,
+    //     0.5646247, 0.2161586, 0.1402643,
+    //     0.2137442, -0.0547578, -0.3061700], 0);
+
+
+    console.log(lpv);
+
+    await task.promise();
+
+    return lpv;
+}

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

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {LightProbeVolume} lpv
+ */
+export function probe_volume_to_textures(lpv: LightProbeVolume): {
+    mesh_vertices: AttributeDataTexture;
+    mesh_neighbours: AttributeDataTexture;
+    probe_positions: AttributeDataTexture;
+    probe_values: AttributeDataTexture;
+};
+import { AttributeDataTexture } from "../../texture/AttributeDataTexture.js";
+//# sourceMappingURL=probe_volume_to_textures.d.ts.map

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

@@ -0,0 +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;qCA9DoC,uCAAuC"}

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

@@ -0,0 +1,89 @@
+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
+ */
+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
+    };
+}
+
+/**
+ *
+ * @param {AttributeDataTexture} target
+ * @param {number[]} points
+ * @param {number} point_count
+ * @param {number} dimensions
+ */
+function vector_buffer_to_attribute_texture(
+    target,
+    points,
+    point_count,
+    dimensions = 3
+) {
+    if (target.spec.itemSize !== dimensions) {
+        throw new Error(`Expected spec.itemCount = ${dimensions} (number of dimensions), instead got ${target.spec.itemSize}`);
+    }
+
+    target.resize(point_count);
+    target.build();
+
+    array_copy(points, 0, target.data, 0, point_count * dimensions);
+}

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.d.ts

@@ -0,0 +1,90 @@
+export class PathTracedScene {
+    /**
+     *
+     * @type {BVH}
+     */
+    bvh_top_level: BVH;
+    /**
+     *
+     * @type {Map<number, PathTracedMesh>}
+     */
+    meshes: Map<number, PathTracedMesh>;
+    /**
+     *
+     * @type {AbstractLight[]}
+     */
+    __lights: AbstractLight[];
+    /**
+     *
+     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     */
+    geo_cache: Map<THREE.BufferGeometry, GeometryBVHBatched>;
+    /**
+     * Maps {@link Texture.id} to relevant sampler
+     * @type {Map<number, Sampler2D>}
+     */
+    textures: Map<number, Sampler2D>;
+    /**
+     *
+     * @type {function}
+     * @private
+     */
+    private __background_sampler;
+    optimize(): void;
+    build(): Promise<void>;
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @return {GeometryBVHBatched}
+     */
+    obtainGeometryBVH(geo: THREE.BufferGeometry): GeometryBVHBatched;
+    /**
+     *
+     * @param {AbstractLight} light
+     */
+    addLight(light: AbstractLight): void;
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @param {THREE.Material} material
+     * @param {mat4|number[]} transform
+     */
+    addMesh(geo: THREE.BufferGeometry, material: THREE.Material, transform: mat4 | number[]): void;
+    /**
+     *
+     * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
+     * @param {number[]} hit
+     */
+    sample_material(out: number[], hit: number[]): void;
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @return {number}
+     */
+    trace(out: number[], ray: number[], min_distance: number, max_distance: number): number;
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} direction
+     * @param {number} direction_offset
+     */
+    sample_background(out: number[], out_offset: number, direction: number[], direction_offset: number): void;
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} ray
+     * @param {number} ray_address
+     * @returns {boolean}
+     */
+    sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
+}
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { PathTracedMesh } from "./PathTracedMesh.js";
+import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
+import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
+//# sourceMappingURL=PathTracedScene.d.ts.map

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAsBA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAE1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,kBAAkB,CAAC,CAEjC;IAEtB;;;OAGG;IACH,UAFU,IAAI,MAAM,YAAY,CAEX;IAGrB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAoCC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAgB7B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA6CvB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACL,MAAM,CAwCjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;CACJ;oBA9VmB,mCAAmC;+BAaxB,qBAAqB;8BALtB,kDAAkD;mCAG7C,yBAAyB"}