@woosh/meep-engine 2.106.1 → 2.108.0

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"}

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.js

@@ -0,0 +1,352 @@
+import { assert } from "../../../../core/assert.js";
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { ebvh_sort_for_traversal_depth_first } from "../../../../core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js";
+import { bvh_query_user_data_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
+import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
+import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
+import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
+import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.js";
+import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
+import { make_vector3 } from "./make_one_vector3.js";
+import { PathTracedMesh } from "./PathTracedMesh.js";
+import { sample_material } from "./texture/sample_material.js";
+
+const temp_ray_results = [];
+const _ray_1 = [];
+const tmp_0 = [];
+const null_output = [];
+
+export class PathTracedScene {
+
+
+    /**
+     *
+     * @type {BVH}
+     */
+    bvh_top_level = new BVH();
+
+    /**
+     *
+     * @type {Map<number, PathTracedMesh>}
+     */
+    meshes = new Map();
+
+    /**
+     *
+     * @type {AbstractLight[]}
+     */
+    __lights = [];
+
+    /**
+     *
+     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     */
+    geo_cache = new Map();
+
+    /**
+     * Maps {@link Texture.id} to relevant sampler
+     * @type {Map<number, Sampler2D>}
+     */
+    textures = new Map();
+
+
+    /**
+     *
+     * @type {function}
+     * @private
+     */
+    __background_sampler = make_vector3(0, 0, 0);
+
+    optimize() {
+        this.bvh_top_level.trim();
+        ebvh_sort_for_traversal_depth_first(this.bvh_top_level);
+    }
+
+    async build() {
+        for (const [id, mesh] of this.meshes) {
+            const material = mesh.material;
+
+            //patch textures
+            const materialType = material.type;
+
+            /**
+             *
+             * @type {TextureAttachment[]}
+             */
+            const attachments = TextureAttachmentsByMaterialType[materialType];
+
+            if (attachments === undefined) {
+                // unsupported
+                continue;
+            }
+
+            for (let i = 0; i < attachments.length; i++) {
+                const attachment = attachments[i];
+
+                const texture = attachment.read(material);
+
+                if (texture === undefined || texture === null) {
+                    continue;
+                }
+
+                if (this.textures.has(texture.id)) {
+                    continue;
+                }
+
+                const sampler2D = convertTexture2Sampler2D(texture, undefined, undefined, false);
+
+                this.textures.set(texture.id, sampler2D);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @return {GeometryBVHBatched}
+     */
+    obtainGeometryBVH(geo) {
+        const cached = this.geo_cache.get(geo);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const bvh8 = new GeometryBVHBatched();
+
+        bvh8.build(geo);
+
+        this.geo_cache.set(geo, bvh8);
+
+        return bvh8;
+    }
+
+    /**
+     *
+     * @param {AbstractLight} light
+     */
+    addLight(light) {
+        assert.isInstanceOf(light, AbstractLight, 'light');
+
+        this.__lights.push(light);
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @param {THREE.Material} material
+     * @param {mat4|number[]} transform
+     */
+    addMesh(geo, material, transform) {
+        //meshopt_optimizeVertexCache(geo.getIndex().array, geo.getIndex().array, geo.getIndex().array.length, geo.getAttribute('position').count);
+
+        const mesh = new PathTracedMesh();
+        mesh.geometry = geo;
+        mesh.material = material;
+        mesh.transform = transform;
+
+
+        mesh.geo_bvh = this.obtainGeometryBVH(geo);
+
+        const bvh = this.bvh_top_level;
+
+        const bvh_node_id = bvh.allocate_node();
+
+        mesh.__bvh_node_id = bvh_node_id;
+
+        ensureGeometryBoundingBox(geo);
+
+        const aabb = [
+            geo.boundingBox.min.x,
+            geo.boundingBox.min.y,
+            geo.boundingBox.min.z,
+            geo.boundingBox.max.x,
+            geo.boundingBox.max.y,
+            geo.boundingBox.max.z,
+        ];
+
+        const aabb_t = [];
+
+        aabb3_matrix4_project(aabb_t, aabb, transform);
+
+        bvh.node_set_aabb(
+            bvh_node_id,
+            aabb_t
+        );
+        bvh.node_set_user_data(
+            bvh_node_id,
+            mesh.id
+        );
+        bvh.insert_leaf(bvh_node_id);
+
+        this.meshes.set(mesh.id, mesh);
+    }
+
+    /**
+     *
+     * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
+     * @param {number[]} hit
+     */
+    sample_material(out, hit) {
+        const primitive_id = hit[9];
+        const instance_id = hit[10];
+        const u = hit[7];
+        const v = hit[8];
+
+        out[0] = 1;
+        out[1] = 1;
+        out[2] = 1;
+
+        /**
+         *
+         * @type {PathTracedMesh}
+         */
+        const mesh = this.meshes.get(instance_id);
+
+        if (mesh === undefined) {
+            // instance not found
+            return;
+        }
+
+        sample_material(out, mesh, this.textures, primitive_id, u, v);
+
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @return {number}
+     */
+    trace(out, ray, min_distance, max_distance) {
+        const bvh = this.bvh_top_level;
+
+        const hit_count = bvh_query_user_data_ray(
+            bvh, bvh.root,
+            temp_ray_results, 0,
+            ray[0], ray[1], ray[2],
+            ray[3], ray[4], ray[5]
+        );
+
+        let nearest_hit_distance = max_distance;
+        let nearest_mesh = null;
+
+
+        for (let i = 0; i < hit_count; i++) {
+            const node_user_data = temp_ray_results[i];
+
+            const mesh = this.meshes.get(node_user_data);
+
+            const distance_to_hit = mesh.hit(tmp_0, ray, min_distance, nearest_hit_distance);
+
+            if (distance_to_hit >= 0) {
+                // since raycast in leaf nodes is already bound by maximum distance, any hit we get is necessarily a closer hit than before
+                nearest_hit_distance = distance_to_hit;
+                nearest_mesh = mesh;
+
+                array_copy(tmp_0, 0, out, 0, 11);
+            }
+        }
+
+        if (nearest_hit_distance !== max_distance) {
+
+            // out[6] = nearest_mesh;
+
+            return nearest_hit_distance;
+        }
+
+        return -1;
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} direction
+     * @param {number} direction_offset
+     */
+    sample_background(out, out_offset, direction, direction_offset) {
+        this.__background_sampler(out, out_offset, direction, direction_offset);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} ray
+     * @param {number} ray_address
+     * @returns {boolean}
+     */
+    sample_lights(out, out_offset, ray, ray_address) {
+        let lights_sampled = false;
+
+        const lights = this.__lights;
+        const light_count = lights.length;
+
+        for (let i = 0; i < 3; i++) {
+            // initialize contribution to 0
+            out[out_offset + i] = 0;
+        }
+
+        for (let i = 0; i < light_count; i++) {
+            const light = lights[i];
+
+            if (light.isDirectionalLight === true) {
+                const dir = light.direction;
+
+                // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
+
+                const ray_direction_x = ray[ray_address + 3];
+                const ray_direction_y = ray[ray_address + 4];
+                const ray_direction_z = ray[ray_address + 5];
+
+                const light_dir_inv_x = -dir.x;
+                const light_dir_inv_y = -dir.y;
+                const light_dir_inv_z = -dir.z;
+
+                const dotNL = v3_dot(
+                    ray_direction_x, ray_direction_y, ray_direction_z,
+                    light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
+                );
+
+                if (dotNL <= 0) {
+                    // no contribution, facing away from the light
+                    continue;
+                }
+
+                const ray_origin_x = ray[ray_address + 0];
+                const ray_origin_y = ray[ray_address + 1];
+                const ray_origin_z = ray[ray_address + 2];
+
+                ray3_array_compose(_ray_1,
+                    ray_origin_x, ray_origin_y, ray_origin_z,
+                    light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
+                );
+
+                // check if there are any obstacles in the direction of the light
+                if (this.trace(null_output, _ray_1, 0.0001, Infinity) > 0) {
+                    // light is occluded
+                    continue;
+                }
+
+
+                const intensity = dotNL * light.intensity.getValue();
+
+                for (let j = 0; j < 3; j++) {
+                    // irradiance
+                    out[out_offset + j] += light.color[j] * intensity;
+                }
+
+                lights_sampled = true;
+            }
+        }
+
+        return lights_sampled;
+    }
+}

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

@@ -1,100 +1,14 @@
-/// <reference types="gl-matrix/index.js" />
 export class PathTracer {
-    /**
-     *
-     * @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;
-    /**
-     *
-     * @param {THREE.BufferGeometry} geo
-     * @return {GeometryBVHBatched}
-     */
-    obtainGeometryBVH(geo: THREE.BufferGeometry): GeometryBVHBatched;
-    optimize(): void;
-    build(): Promise<void>;
-    /**
-     *
-     * @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
-     * @param {Texture} texture
-     * @param {number} u
-     * @param {number} v
-     */
-    sample_texture(out: number[], texture: Texture, u: number, v: 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}
+     * @param {number} min_bounce
+     * @param {number} max_bounce
+     * @param {function} random
+     * @param {PathTracedScene} scene
      */
-    sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
-    path_trace(out: any, ray: any, max_distance: any, max_bounce: any, random?: () => number): void;
+    path_trace(out: number[], ray: number[], max_distance: number, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
 }
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { PathTracedMesh } from "./PathTracedMesh.js";
-import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
-import { mat4 } from "gl-matrix";
 //# sourceMappingURL=PathTracer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":";AA2DA;IAGQ;;;OAGG;IACH,eAFU,GAAG,CAEiB;IAE9B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAEd;IAEvB;;;OAGG;IACH,UAFU,eAAe,CAEP;IAElB;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,kBAAkB,CAAC,CAE7B;IAE1B;;;OAGG;IACH,UAFU,IAAI,MAAM,YAAY,CAEP;IAEzB;;;;OAIG;IACH,6BAA8C;IAGlD;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAgB7B;IAED,iBAGC;IAED,uBAoCC;IAED;;;OAGG;IACH,qCAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,IAAI,GAAC,MAAM,EAAE,QA6CvB;IAED;;;;;;OAMG;IACH,oBALW,MAAM,EAAE,uBAER,MAAM,KACN,MAAM,QA+ChB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAmFlB;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;IAED,gGAqDC;CACJ;oBA/hBmB,mCAAmC;+BAexB,qBAAqB;mCAHjB,yBAAyB;qBAtBjC,WAAW"}
+{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":"AA2BA;IAGI;;;;;;;;;OASG;IACH,gBARW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,cACN,MAAM,cACN,MAAM,kDAgFhB;CACJ"}