@woosh/meep-engine 2.108.4 → 2.109.1

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

@@ -1,9 +1,10 @@
 export class PathTracedMesh {
+    aabb: AABB3;
     /**
      *
-     * @type {GeometryBVHBatched|null}
+     * @type {BufferedGeometryBVH|null}
      */
-    geo_bvh: GeometryBVHBatched | null;
+    geo_bvh: BufferedGeometryBVH | null;
     /**
      *
      * @type {THREE.BufferGeometry|null}
@@ -11,9 +12,9 @@ export class PathTracedMesh {
     geometry: THREE.BufferGeometry | null;
     /**
      *
-     * @type {THREE.Material|null}
+     * @type {StandardMaterial|null}
      */
-    material: THREE.Material | null;
+    material: StandardMaterial | null;
     __transform_inverse: Float32Array;
     __transform: Float32Array;
     __local_scale_inverse: number;
@@ -34,4 +35,5 @@ export class PathTracedMesh {
      */
     hit(out: number[], ray: number[], min_distance: number, max_distance: number): number;
 }
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 //# sourceMappingURL=PathTracedMesh.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAQA;IAGQ;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEf;IAEpB;;;OAGG;IACH,UAFU,MAAM,QAAQ,GAAC,IAAI,CAET;IAIpB,kCAA0D;IAC1D,0BAAuD;IACvD,8BAA8B;IAE9B;;;OAGG;IACH,IAFU,MAAM,CAEW;IAG/B,iCAYC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAqBlB;CACJ"}
+{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAcA;IACI,YAAmB;IAIf;;;OAGG;IACH,SAFU,sBAAoB,IAAI,CAEf;IAEnB;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEf;IAEpB;;;OAGG;IACH,UAFU,mBAAiB,IAAI,CAEX;IAIpB,kCAA0D;IAC1D,0BAAuD;IACvD,8BAA8B;IAE9B;;;OAGG;IACH,IAFU,MAAM,CAEW;IAG/B,iCAgBC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAuDlB;CACJ;sBApIqB,wCAAwC"}

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

@@ -1,17 +1,25 @@
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { mat4 } from "gl-matrix";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ray3_shift_origin_along_direction } from "../../../../core/geom/3d/ray/ray3_shift_origin_along_direction.js";
+import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
+import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
+import { v3_shift_along_direction } from "../../../../core/geom/vec3/v3_shift_along_direction.js";
 import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
 
 const local_ray = new Float32Array(6);
+const scratch_v3 = new Float32Array(3);
 let mesh_id_counter = 0;
 
 export class PathTracedMesh {
+    aabb = new AABB3();
+
     constructor() {
 
         /**
          *
-         * @type {GeometryBVHBatched|null}
+         * @type {BufferedGeometryBVH|null}
          */
         this.geo_bvh = null;
 
@@ -23,7 +31,7 @@ export class PathTracedMesh {
 
         /**
          *
-         * @type {THREE.Material|null}
+         * @type {StandardMaterial|null}
          */
         this.material = null;
 
@@ -51,7 +59,11 @@ export class PathTracedMesh {
         const scale_y = Math.hypot(m4[4], m4[5], m4[6]);
         const scale_z = Math.hypot(m4[8], m4[9], m4[10]);
 
-        this.__local_scale_inverse = Math.hypot(scale_x, scale_y, scale_z);
+        this.__local_scale_inverse = Math.max(scale_x, scale_y, scale_z);
+
+        // get bounds
+        this.geo_bvh.getBounds(this.aabb);
+        this.aabb.applyMatrix4(m);
     }
 
     get transform() {
@@ -69,11 +81,37 @@ export class PathTracedMesh {
     hit(out, ray, min_distance, max_distance) {
         //transform ray
         const m4 = this.__transform_inverse;
-        ray3_array_apply_matrix4(local_ray,0, ray,0, m4);
 
-        const scale_d = this.__local_scale_inverse;
 
-        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, min_distance * scale_d, max_distance * scale_d);
+        // shift ray forward by "min distance"
+        ray3_shift_origin_along_direction(local_ray, 0, ray, 0, min_distance);
+
+
+        ray3_array_apply_matrix4(local_ray, 0, local_ray, 0, m4);
+
+
+        let max_distance_local = Infinity;
+
+        if (max_distance !== Infinity) {
+            // compute position of point at max_distance along the ray
+            v3_shift_along_direction(
+                scratch_v3, 0,
+                ray[0], ray[1], ray[2],
+                ray[3], ray[4], ray[5],
+                max_distance
+            );
+
+            // move far point into local coordinate space
+            v3_matrix4_multiply(scratch_v3, 0, scratch_v3, 0, m4);
+
+            // compute far distance in local space
+            max_distance_local = v3_distance(
+                local_ray[0], local_ray[1], local_ray[2],
+                scratch_v3[0], scratch_v3[1], scratch_v3[2]
+            );
+        }
+
+        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, 0, max_distance_local);
 
         if (distance_to_hit >= 0) {
             // transform output
@@ -81,9 +119,17 @@ export class PathTracedMesh {
 
             out[10] = this.id;
 
-            distance_to_hit /= scale_d;
+            distance_to_hit = v3_distance(
+                ray[0], ray[1], ray[2],
+                out[0], out[1], out[2]
+            );
+
+            if (distance_to_hit > max_distance) {
+                return -1;
+            }
         }
 
+
         return distance_to_hit;
     }
 }

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

@@ -16,14 +16,9 @@ export class PathTracedScene {
     __lights: AbstractLight[];
     /**
      *
-     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     * @type {Map<THREE.BufferGeometry, BufferedGeometryBVH>}
      */
-    geo_cache: Map<THREE.BufferGeometry, GeometryBVHBatched>;
-    /**
-     * Maps {@link Texture.id} to relevant sampler
-     * @type {Map<number, Sampler2D>}
-     */
-    textures: Map<number, Sampler2D>;
+    geo_cache: Map<THREE.BufferGeometry, BufferedGeometryBVH>;
     /**
      *
      * @type {function}
@@ -35,9 +30,9 @@ export class PathTracedScene {
     /**
      *
      * @param {THREE.BufferGeometry} geo
-     * @return {GeometryBVHBatched}
+     * @return {BufferedGeometryBVH}
      */
-    obtainGeometryBVH(geo: THREE.BufferGeometry): GeometryBVHBatched;
+    obtainGeometryBVH(geo: THREE.BufferGeometry): BufferedGeometryBVH;
     /**
      *
      * @param {AbstractLight} light
@@ -82,9 +77,10 @@ export class PathTracedScene {
      * @returns {boolean}
      */
     sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
+    #private;
 }
 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";
+import { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
 //# sourceMappingURL=PathTracedScene.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAuBA;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,uBAqCC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAmB7B;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;oBAnWmB,mCAAmC;+BAcxB,qBAAqB;8BALtB,kDAAkD;mCAG7C,yBAAyB"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AA8BA;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,mBAAmB,CAAC,CAElC;IAatB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAMC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA8CvB;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,CAqDjB;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;oBA7VmB,mCAAmC;+BAkBxB,qBAAqB;8BALtB,kDAAkD;oCAE5C,0BAA0B"}

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

@@ -1,18 +1,22 @@
 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 { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { Cache } from "../../../../core/cache/Cache.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { strictEquals } from "../../../../core/function/strictEquals.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.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 { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.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 { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
 import { make_vector3 } from "./make_one_vector3.js";
+import { MaterialConverter } from "./material/MaterialConverter.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { sample_material } from "./texture/sample_material.js";
 
@@ -21,6 +25,9 @@ const _ray_1 = [];
 const tmp_0 = [];
 const null_output = [];
 
+const DEFAULT_CONVERTER = new MaterialConverter();
+
+
 export class PathTracedScene {
 
 
@@ -44,16 +51,20 @@ export class PathTracedScene {
 
     /**
      *
-     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     * @type {Map<THREE.BufferGeometry, BufferedGeometryBVH>}
      */
     geo_cache = new Map();
 
     /**
-     * Maps {@link Texture.id} to relevant sampler
-     * @type {Map<number, Sampler2D>}
+     *
+     * @type {Cache<THREE.Material, StandardMaterial>}
      */
-    textures = new Map();
-
+    #material_cache = new Cache({
+        keyEqualityFunction: strictEquals,
+        keyHashFunction(mat) {
+            return mat.id
+        }
+    });
 
     /**
      *
@@ -72,44 +83,13 @@ export class PathTracedScene {
         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}
+     * @return {BufferedGeometryBVH}
      */
     obtainGeometryBVH(geo) {
         const cached = this.geo_cache.get(geo);
@@ -118,7 +98,7 @@ export class PathTracedScene {
             return cached;
         }
 
-        const bvh = new GeometryBVHBatched();
+        const bvh = new BufferedGeometryBVH();
 
         const label = `bvh build ${compute_geometry_polycount(geo)}`;
         console.time(label);
@@ -151,12 +131,13 @@ export class PathTracedScene {
 
         const mesh = new PathTracedMesh();
         mesh.geometry = geo;
-        mesh.material = material;
-        mesh.transform = transform;
 
+        mesh.material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
 
         mesh.geo_bvh = this.obtainGeometryBVH(geo);
 
+        mesh.transform = transform;
+
         const bvh = this.bvh_top_level;
 
         const bvh_node_id = bvh.allocate_node();
@@ -217,7 +198,7 @@ export class PathTracedScene {
             return;
         }
 
-        sample_material(out, mesh, this.textures, primitive_id, u, v);
+        sample_material(out, mesh, primitive_id, u, v);
 
     }
 
@@ -232,7 +213,7 @@ export class PathTracedScene {
     trace(out, ray, min_distance, max_distance) {
         const bvh = this.bvh_top_level;
 
-        const hit_count = bvh_query_user_data_ray(
+        const hit_count = bvh_query_leaves_ray(
             bvh, bvh.root,
             temp_ray_results, 0,
             ray[0], ray[1], ray[2],
@@ -244,7 +225,20 @@ export class PathTracedScene {
 
 
         for (let i = 0; i < hit_count; i++) {
-            const node_user_data = temp_ray_results[i];
+            const node = temp_ray_results[i];
+
+            bvh.node_get_aabb(node, tmp_0);
+
+            if (aabb3_unsigned_distance_sqr_to_point(
+                tmp_0[0], tmp_0[1], tmp_0[2],
+                tmp_0[3], tmp_0[4], tmp_0[5],
+                ray[0], ray[1], ray[2]
+            ) > nearest_hit_distance * nearest_hit_distance) {
+                // bounds of the mesh are too far
+                continue;
+            }
+
+            const node_user_data = bvh.node_get_user_data(node);
 
             const mesh = this.meshes.get(node_user_data);
 

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.d.ts

@@ -0,0 +1,11 @@
+export class MaterialConverter {
+    /**
+     *
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    convert(material: THREE.Material): StandardMaterial;
+    #private;
+}
+import { StandardMaterial } from "./StandardMaterial.js";
+//# sourceMappingURL=MaterialConverter.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialConverter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js"],"names":[],"mappings":"AASA;IA4BI;;;;OAIG;IACH,kBAHW,MAAM,QAAQ,GACZ,gBAAgB,CA2D5B;;CAEJ;iCA/FgC,uBAAuB"}

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js

@@ -0,0 +1,102 @@
+import { Color } from "three";
+import {
+    TextureAttachmentsByMaterialType
+} from "../../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
+import { convertTexture2Sampler2D } from "../../../texture/sampler/convertTexture2Sampler2D.js";
+import { sampler_multiply_vector } from "../../../texture/sampler/sampler_multiply_vector.js";
+import { StandardMaterial } from "./StandardMaterial.js";
+import { StandardTexture } from "./StandardTexture.js";
+
+export class MaterialConverter {
+    /**
+     * Maps {@link Texture.id} to relevant sampler
+     * @type {Map<number, StandardTexture>}
+     */
+    #textures = new Map();
+
+    /**
+     *
+     * @param {THREE.Texture} texture
+     * @returns {StandardTexture}
+     */
+    #ensure_texture(texture) {
+        const existing = this.#textures.get(texture.id);
+
+        if (existing !== undefined) {
+            return existing
+        }
+
+        const sampler2D = convertTexture2Sampler2D(texture, undefined, undefined, false);
+
+        const st = StandardTexture.from(sampler2D);
+
+        this.#textures.set(texture.id, st);
+
+        return st;
+    }
+
+    /**
+     *
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    convert(material) {
+
+        const result = new StandardMaterial();
+
+        //patch textures
+        const materialType = material.type;
+
+        /**
+         *
+         * @type {TextureAttachment[]}
+         */
+        const attachments = TextureAttachmentsByMaterialType[materialType];
+
+        if (attachments !== undefined) {
+
+            for (let i = 0; i < attachments.length; i++) {
+                const attachment = attachments[i];
+
+                const texture = attachment.read(material);
+
+                if (texture === undefined || texture === null) {
+                    continue;
+                }
+
+                const sampler = this.#ensure_texture(texture);
+
+                const name = attachment.name;
+
+                if (name === "diffuse") {
+                    result.diffuse = sampler;
+                } else if (name === "normal") {
+                    result.normal = sampler;
+                } else if (name === "metalness") {
+                    result.metalness = sampler;
+                } else if (name === "roughness") {
+                    result.roughness = sampler;
+                } else if (name === "emissive") {
+                    result.emissive = sampler;
+                } else {
+                    // unused
+                }
+
+
+            }
+        }
+
+        if (material.color !== undefined && !material.color.equals(new Color(1, 1, 1))) {
+            const tinted_diffuse = result.diffuse.clone();
+
+            tinted_diffuse.sampler = tinted_diffuse.sampler.clone();
+
+            sampler_multiply_vector(tinted_diffuse.sampler, result.diffuse.sampler, material.color.toArray());
+
+            result.diffuse = tinted_diffuse;
+        }
+
+        return result;
+    }
+
+}

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts

@@ -0,0 +1,9 @@
+export class StandardMaterial {
+    diffuse: StandardTexture;
+    normal: StandardTexture;
+    emissive: StandardTexture;
+    roughness: StandardTexture;
+    metalness: StandardTexture;
+}
+import { StandardTexture } from "./StandardTexture.js";
+//# sourceMappingURL=StandardMaterial.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AASA;IACI,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;CACtD;gCAd+B,sBAAsB"}

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js

@@ -0,0 +1,17 @@
+import { one_pixel_sampler_uint8 } from "../../../texture/sampler/one_pixel_sampler_uint8.js";
+import { StandardTexture } from "./StandardTexture.js";
+
+const DEFAULT_DIFFUSE = one_pixel_sampler_uint8([255, 255, 255, 255]);
+const DEFAULT_NORMAL = one_pixel_sampler_uint8([0, 0, 255]);
+const DEFAULT_EMISSIVE = one_pixel_sampler_uint8([0, 0, 0]);
+const DEFAULT_ROUGHNESS = one_pixel_sampler_uint8([255]);
+const DEFAULT_METALNESS = one_pixel_sampler_uint8([0]);
+
+export class StandardMaterial {
+    diffuse = StandardTexture.from(DEFAULT_DIFFUSE)
+    normal = StandardTexture.from(DEFAULT_NORMAL)
+    emissive = StandardTexture.from(DEFAULT_EMISSIVE)
+    roughness = StandardTexture.from(DEFAULT_ROUGHNESS)
+    metalness = StandardTexture.from(DEFAULT_METALNESS)
+}
+

package/src/engine/graphics/sh3/path_tracer/material/StandardTexture.d.ts

@@ -0,0 +1,31 @@
+export class StandardTexture {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {StandardTexture}
+     */
+    static from(sampler: Sampler2D): StandardTexture;
+    /**
+     * @type {Sampler2D}
+     */
+    sampler: Sampler2D;
+    magFilter: number;
+    type: BinaryDataType;
+    wrapS: number;
+    wrapT: number;
+    /**
+     *
+     * @param {StandardTexture} other
+     */
+    copy(other: StandardTexture): void;
+    clone(): StandardTexture;
+    /**
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} u
+     * @param {number} v
+     */
+    sample(out: number[] | Float32Array, u: number, v: number): void;
+}
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+//# sourceMappingURL=StandardTexture.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/StandardTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardTexture.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardTexture.js"],"names":[],"mappings":"AAOA;IA8BI;;;;OAIG;IACH,iCAFa,eAAe,CAQ3B;IAxCD;;OAEG;IACH,mBAAO;IACP,kBAAsC;IACtC,qBAA2B;IAC3B,cAA2C;IAC3C,cAA2C;IAE3C;;;OAGG;IACH,YAFW,eAAe,QAQzB;IAED,yBAMC;IAeD;;;;;OAKG;IACH,YAJW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,QA6BhB;CACJ;+BAnF8B,mDAAmD"}

package/src/engine/graphics/sh3/path_tracer/material/StandardTexture.js

@@ -0,0 +1,85 @@
+import { LinearFilter, LinearMipmapLinearFilter, NearestFilter, NearestMipMapLinearFilter } from "three";
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { apply_texture_clamping_to_coordinate } from "../texture/apply_texture_clamping_to_coordinate.js";
+import { vec3_uint8_to_float } from "../vec3_uint8_to_float.js";
+import { TextureFilter } from "./TextureFilter.js";
+import { TextureWrapping } from "./TextureWrapping.js";
+
+export class StandardTexture {
+    /**
+     * @type {Sampler2D}
+     */
+    sampler
+    magFilter = TextureFilter.LinearFilter
+    type = BinaryDataType.Uint8
+    wrapS = TextureWrapping.ClampToEdgeWrapping
+    wrapT = TextureWrapping.ClampToEdgeWrapping
+
+    /**
+     *
+     * @param {StandardTexture} other
+     */
+    copy(other) {
+        this.sampler = other.sampler
+        this.magFilter = other.magFilter
+        this.type = other.type
+        this.wrapS = other.wrapS
+        this.wrapT = other.wrapT
+    }
+
+    clone() {
+        const r = new StandardTexture();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {StandardTexture}
+     */
+    static from(sampler) {
+        const texture = new StandardTexture();
+
+        texture.sampler = sampler;
+
+        return texture;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} u
+     * @param {number} v
+     */
+    sample(out, u, v) {
+
+        const _u = apply_texture_clamping_to_coordinate(this.wrapS, u);
+        const _v = apply_texture_clamping_to_coordinate(this.wrapT, v);
+
+
+        const magFilter = this.magFilter;
+
+        const sampler = this.sampler;
+
+        switch (magFilter) {
+            default:
+            case NearestFilter:
+            case NearestMipMapLinearFilter:
+                sampler.sampleNearestUV(_u, _v, out);
+                break;
+
+            case LinearFilter:
+            case LinearMipmapLinearFilter:
+
+                sampler.sampleBilinearUV(_u, _v, out);
+                break;
+        }
+
+        if (this.type === BinaryDataType.Uint8) {
+            vec3_uint8_to_float(out, out);
+        }
+    }
+}

package/src/engine/graphics/sh3/path_tracer/material/TextureFilter.d.ts

@@ -0,0 +1,14 @@
+export type TextureFilter = number;
+export namespace TextureFilter {
+    let NearestFilter: number;
+    let NearestMipmapNearestFilter: number;
+    let NearestMipMapNearestFilter: number;
+    let NearestMipmapLinearFilter: number;
+    let NearestMipMapLinearFilter: number;
+    let LinearFilter: number;
+    let LinearMipmapNearestFilter: number;
+    let LinearMipMapNearestFilter: number;
+    let LinearMipmapLinearFilter: number;
+    let LinearMipMapLinearFilter: number;
+}
+//# sourceMappingURL=TextureFilter.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/TextureFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureFilter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/TextureFilter.js"],"names":[],"mappings":"4BACU,MAAM"}

package/src/engine/graphics/sh3/path_tracer/material/TextureFilter.js

@@ -0,0 +1,17 @@
+/**
+ * @enum {number}
+ */
+export const TextureFilter = {
+
+    NearestFilter: 1003,
+    NearestMipmapNearestFilter: 1004,
+    NearestMipMapNearestFilter: 1004,
+    NearestMipmapLinearFilter: 1005,
+    NearestMipMapLinearFilter: 1005,
+    LinearFilter: 1006,
+    LinearMipmapNearestFilter: 1007,
+    LinearMipMapNearestFilter: 1007,
+    LinearMipmapLinearFilter: 1008,
+    LinearMipMapLinearFilter: 1008
+
+};