@woosh/meep-engine 2.108.2 → 2.108.4

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -1,3 +1,4 @@
+import { GUI } from "dat.gui";
 import {
     ClampToEdgeWrapping,
     DataTexture,
@@ -45,10 +46,10 @@ import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { three_object_to_entity_composition } from "../ecs/mesh-v2/three_object_to_entity_composition.js";
 import { GizmoRenderingPlugin } from "../render/gizmo/GizmoRenderingPlugin.js";
+import { MaterialTransformer } from "./gi/material/MaterialTransformer.js";
 import { build_probes_for_scene } from "./lpv/build_probes_for_scene.js";
 import { LightProbeVolume } from "./lpv/LightProbeVolume.js";
 import { LightProbeVolumeSerializationAdapter } from "./lpv/LightProbeVolumeSerializationAdapter.js";
-import { probe_volume_to_textures } from "./lpv/probe_volume_to_textures.js";
 
 /**
  *
@@ -197,17 +198,22 @@ function make_test_texture(t = 1) {
  *
  * @param {Engine} engine
  * @param {string} path
+ * @param {LightProbeVolume} volume
  * @return {Promise<LightProbeVolume>}
  */
-async function getVolume({ engine, path }) {
+async function getVolume({
+                             engine,
+                             path,
+                             volume = new LightProbeVolume()
+                         }) {
+
+    volume.clear();
 
     const key = `lpv:${path}`;
 
     const adapter = new LightProbeVolumeSerializationAdapter();
 
     if (await engine.storage.promiseContains(key)) {
-        const volume = new LightProbeVolume();
-
         const data = await engine.storage.promiseLoadBinary(key);
 
         console.log(`LPV data size ${number_pretty_print(data.byteLength)} bytes`);
@@ -224,11 +230,12 @@ async function getVolume({ engine, path }) {
 
     const ecd = engine.entityManager.dataset;
 
-    const volume = await build_probes_for_scene({
+    await build_probes_for_scene({
+        volume,
         engine,
         ecd,
         bounds: mesh_bounds,
-        density: 10000
+        density: 3000
     });
 
     const buffer = new BinaryBuffer();
@@ -242,7 +249,13 @@ async function getVolume({ engine, path }) {
     return volume;
 }
 
-function createFloor({ level, ecd }) {
+/**
+ *
+ * @param {number} level
+ * @param {EntityComponentDataset} ecd
+ * @param {GraphicsEngine} graphics
+ */
+function createFloor({ level, ecd, graphics }) {
 
     const texture_frequency = 10;
     const size = 1000;
@@ -259,6 +272,15 @@ function createFloor({ level, ecd }) {
     });
 
 
+    const material = graphics.getMaterialManager().obtain(new MeshStandardMaterial({
+        map: map
+    })).getValue();
+
+    const geometry = new PlaneBufferGeometry(1, 1, 100, 100);
+
+    geometry.computeVertexNormals();
+    geometry.computeTangents();
+
     new Entity()
         .add(Transform.fromJSON({
             position: {
@@ -269,9 +291,7 @@ function createFloor({ level, ecd }) {
             rotation: Quaternion.fromEulerAngles(-Math.PI * 0.5, 0, 0),
             scale: size
         }))
-        .add(ShadedGeometry.from(new PlaneBufferGeometry(1, 1), new MeshStandardMaterial({
-            map: map
-        })))
+        .add(ShadedGeometry.from(geometry, material))
         .build(ecd);
 
 }
@@ -282,6 +302,12 @@ function createFloor({ level, ecd }) {
  * @return {Promise<void>}
  */
 async function main(engine) {
+    const volume = new LightProbeVolume();
+
+    const transformer = new MaterialTransformer({ volume });
+
+    engine.graphics.getMaterialManager().addCompileStep(transformer);
+
     await EngineHarness.buildBasics({
         engine,
         enableWater: false,
@@ -303,10 +329,11 @@ async function main(engine) {
     await EngineHarness.buildLights({
         engine,
         shadowmapResolution: 4096,
-        ambientIntensity: 0.01,
+        ambientIntensity: 0.0,
         sun: sun_color,
-        sunIntensity: 1,
-        sunDirection: new Vector3(0.5, -1, 0.3)
+        sunIntensity: 1.7,
+        // sunDirection: new Vector3(0.5, -1, 0.3)
+        sunDirection: new Vector3(1.2, -1,0.2 )
     })
 
     engine.graphics.getRenderer().setClearColor('#1e3441', 1);
@@ -318,7 +345,6 @@ async function main(engine) {
 
     // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/sibenik/2/model.gltf';
-    const path = 'data/models/sibenik/3-window-less/model.gltf';
     // const path = 'data/models/vokselia_spawn/model.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/pica_pica/pica_pica.gltf';
@@ -330,8 +356,10 @@ async function main(engine) {
     // const path = 'data/models/samples/cyberpunk_bike/scene.gltf';
     // const path = 'data/models/samples/sd_macross_city_standoff_diorama/scene.gltf';
     // const path = 'data/models/Slaughter Mech/Slaugter Mech.gltf';
-    // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    const path = 'data/models/sponza-pbr/gltf/sponza.glb';
     // const path = 'data/models/samples/gi_box_01/model.glb';
+    // const path = 'data/models/samples/gi_box_01/model-thick-1.glb';
+    // const path = 'data/models/sibenik/3-window-less/model.gltf';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
     const gltf = mesh_asset.gltf;
@@ -350,7 +378,8 @@ async function main(engine) {
 
     createFloor({
         level: mesh_asset.boundingBox.y0,
-        ecd
+        ecd,
+        graphics: engine.graphics
     });
 
     const composition = three_object_to_entity_composition(gltf.scene);
@@ -419,21 +448,21 @@ async function main(engine) {
 
     console.time('getVolume');
     // console.profile('getVolume');
-    const volume = await getVolume({ engine, path });
+    await getVolume({ engine, path, volume });
     // console.profileEnd('getVolume');
     console.timeEnd('getVolume');
 
     console.log('LPV:', volume);
 
+    transformer.update();
+
 
     volume.visualize_probes({ ecd, size: model_footprint * 0.002 });
-    // volume.visualize_mesh({ ecd , opacity: 0.2});
+    // volume.visualize_mesh({ ecd, opacity: 0.5 });
 
-    console.time('prepareTextures');
-    const textures = probe_volume_to_textures(volume);
-    console.timeEnd('prepareTextures');
+    new GUI()
+        .add(transformer, 'intensity').min(0).max(10);
 
-    console.log(textures);
 
     // mesh_entity.addEventListener(SGMeshEvents.AssetLoaded, build);
     //

package/src/engine/graphics/texture/AttributeDataTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AttributeDataTexture.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/AttributeDataTexture.js"],"names":[],"mappings":"AAYA;IAwRI;;;;;;OAMG;IACH,+CAHW,MAAM,cACN,MAAM,GAHL,oBAAoB,CAO/B;IAhSD;;;;;OAKG;IACH,+CAHW,MAAM,cACN,MAAM,EA2ChB;IA/BG;;;;OAIG;IACH,eAAkB;IAElB,mBAAoB;IAEpB;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,qBAA8B;IAKlC;;;OAGG;IACH,0BAEC;IAED,cASC;IAED,0BAGC;IAED,2BAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAwChB;IAED,cA4BC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,WACN,MAAM,EAAE,UACR,MAAM,EAAE,GACN,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,WACN,MAAM,EAAE,UACR,MAAM,EAAE,QAmClB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgBhB;IAED;;;OAGG;IACH,sCAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,oBAFY,MAAM,CAIjB;CAYJ;4BA9S0C,OAAO"}
+{"version":3,"file":"AttributeDataTexture.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/AttributeDataTexture.js"],"names":[],"mappings":"AAaA;IA6RI;;;;;;OAMG;IACH,+CAHW,MAAM,cACN,MAAM,GAHL,oBAAoB,CAO/B;IArSD;;;;;OAKG;IACH,+CAHW,MAAM,cACN,MAAM,EA2ChB;IA/BG;;;;OAIG;IACH,eAAkB;IAElB,mBAAoB;IAEpB;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,qBAA8B;IAKlC;;;OAGG;IACH,0BAEC;IAED,cASC;IAED,0BAGC;IAED,2BAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAwChB;IAED,cAiCC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,WACN,MAAM,EAAE,UACR,MAAM,EAAE,GACN,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,WACN,MAAM,EAAE,UACR,MAAM,EAAE,QAmClB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgBhB;IAED;;;OAGG;IACH,sCAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,oBAFY,MAAM,CAIjB;CAYJ;4BApT0C,OAAO"}

package/src/engine/graphics/texture/AttributeDataTexture.js

@@ -5,7 +5,8 @@ import {
 } from "../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
 import { DataTypeByteSizes } from "../../../core/binary/type/DataTypeByteSizes.js";
 import { typed_array_copy } from "../../../core/collection/array/typed/typed_array_copy.js";
-import { channelCountToThreeTextureFormat } from "./channelCountToThreeTextureFormat.js";
+
+import { computeThreeTextureFormatFromDataType } from "./computeThreeTextureFormatFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
 import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
 import { normalized_internal_format } from "./normalized_internal_format.js";
@@ -140,7 +141,7 @@ export class AttributeDataTexture {
         const width = this.computeSlotWidth() * this.__column_count;
         const height = Math.ceil(this.__capacity / this.__column_count);
 
-        const format = channelCountToThreeTextureFormat(spec.itemSize);
+        const format = computeThreeTextureFormatFromDataType(spec.type, spec.itemSize);
         const type = computeThreeTextureTypeFromDataType(spec.type);
 
         const array = new TypedArray(width * height * spec.itemSize);
@@ -151,12 +152,17 @@ export class AttributeDataTexture {
         texture.generateMipmaps = false;
         texture.minFilter = texture.magFilter = NearestFilter;
 
+        texture.format = format;
+        texture.type = type;
+
         if (spec.normalized) {
             texture.internalFormat = normalized_internal_format(spec.type, spec.itemSize);
         } else {
             texture.internalFormat = computeThreeTextureInternalFormatFromDataType(spec.type, spec.itemSize);
         }
 
+        texture.needsUpdate = true;
+
         this.__texture = texture;
 
 

package/src/engine/graphics/texture/computeThreeTextureFormat.js

@@ -1,6 +1,6 @@
 import { NumericType } from "../../../core/math/NumericType.js";
-import { channelCountToThreIntegerTextureType } from "./channelCountToThreIntegerTextureType.js";
 import { channelCountToThreeTextureFormat } from "./channelCountToThreeTextureFormat.js";
+import { channelCountToThreIntegerTextureType } from "./channelCountToThreIntegerTextureType.js";
 
 /**
  *
@@ -16,3 +16,4 @@ export function computeThreeTextureFormat(type, channel_count) {
         throw new Error(`Unsupported numeric type '${type}'`);
     }
 }
+

package/src/engine/graphics/texture/computeThreeTextureFormatFromDataType.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @param {number} channel_count
+ */
+export function computeThreeTextureFormatFromDataType(dt: BinaryDataType, channel_count: number): number | import("three").PixelFormat;
+//# sourceMappingURL=computeThreeTextureFormatFromDataType.d.ts.map

package/src/engine/graphics/texture/computeThreeTextureFormatFromDataType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeThreeTextureFormatFromDataType.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/computeThreeTextureFormatFromDataType.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,yFAFW,MAAM,wCAMhB"}

package/src/engine/graphics/texture/computeThreeTextureFormatFromDataType.js

@@ -0,0 +1,13 @@
+import { computeThreeTextureFormat } from "./computeThreeTextureFormat.js";
+import { numericTypeFromBinaryDataType } from "./numericTypeFromBinaryDataType.js";
+
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @param {number} channel_count
+ */
+export function computeThreeTextureFormatFromDataType(dt, channel_count) {
+    const numeric_type = numericTypeFromBinaryDataType(dt);
+
+    return computeThreeTextureFormat(numeric_type, channel_count);
+}

package/src/engine/graphics/texture/formatToChannelCount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatToChannelCount.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/formatToChannelCount.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,CAgBlB"}
+{"version":3,"file":"formatToChannelCount.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/formatToChannelCount.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,CAgBlB"}

package/src/engine/graphics/texture/formatToChannelCount.js

@@ -1,4 +1,11 @@
-import { RedFormat, RedIntegerFormat, RGBAFormat, RGBFormat, RGFormat } from "three";
+import { RedFormat, RedIntegerFormat, RGBAFormat, RGFormat } from "three";
+
+
+/**
+ * WebGL constant, declared explicitly to avoid issues with later THREE.js versions where it is absent
+ * @type {number}
+ */
+const RGBFormat = 1022;
 
 /**
  *

package/src/engine/graphics/texture/numericTypeFromBinaryDataType.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @returns {NumericType}
+ */
+export function numericTypeFromBinaryDataType(dt: BinaryDataType): NumericType;
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { NumericType } from "../../../core/math/NumericType.js";
+//# sourceMappingURL=numericTypeFromBinaryDataType.d.ts.map

package/src/engine/graphics/texture/numericTypeFromBinaryDataType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numericTypeFromBinaryDataType.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/numericTypeFromBinaryDataType.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,kDAHW,cAAc,GACZ,WAAW,CAwBvB;+BA9B8B,6CAA6C;4BAChD,mCAAmC"}

package/src/engine/graphics/texture/numericTypeFromBinaryDataType.js

@@ -0,0 +1,31 @@
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { NumericType } from "../../../core/math/NumericType.js";
+
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @returns {NumericType}
+ */
+export function numericTypeFromBinaryDataType(dt) {
+
+    switch (dt) {
+        case BinaryDataType.Uint8:
+        case BinaryDataType.Uint16:
+        case BinaryDataType.Uint32:
+            return NumericType.Uint
+
+        case BinaryDataType.Int8:
+        case BinaryDataType.Int16:
+        case BinaryDataType.Int32:
+            return NumericType.Int;
+
+        case BinaryDataType.Float16:
+        case BinaryDataType.Float32:
+        case BinaryDataType.Float64:
+            return NumericType.Float;
+
+        default:
+            throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+}

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -396,8 +396,8 @@ export class Sampler2D {
         const clamped_x = clamp(x, 0, x_max);
         const clamped_y = clamp(y, 0, y_max);
 
-        const x0 = clamped_x | 0;
-        const y0 = clamped_y | 0;
+        const x0 = clamped_x >>> 0;
+        const y0 = clamped_y >>> 0;
 
         //
         const row0 = y0 * rowSize;

package/src/engine/graphics/texture/sampler/convertTexture2Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertTexture2Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,mEALW,MAAM,WACN,MAAM,UACN,OAAO,GACN,SAAS,CAyEpB;0BArFyB,gBAAgB"}
+{"version":3,"file":"convertTexture2Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,mEALW,MAAM,WACN,MAAM,UACN,OAAO,GACN,SAAS,CAkGpB;0BA/GyB,gBAAgB"}

package/src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js

@@ -1,8 +1,11 @@
-import { flipArrayInPlace } from "../../filter/FlipArrayInPlace.js";
 import ImageFilter from "../../filter/ImageFilter.js";
+import { sampler2d_flipY_in_place } from "../../filter/sampler2d_flipY_in_place.js";
 import CopyShader from "../../postprocess/threejs/shaders/CopyShader.js";
 import { WebGLRendererPool } from "../../render/RendererPool.js";
+import { formatToChannelCount } from "../formatToChannelCount.js";
+import { sampler2d_scale } from "./resize/sampler2d_scale.js";
 import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_ensure_uint8_RGBA } from "./sampler2d_ensure_uint8_RGBA.js";
 
 
 const DEFAULT_TEXTURE_WIDTH = 512;
@@ -25,6 +28,8 @@ export function convertTexture2Sampler2D(
     let _height = height;
     let _width = width;
 
+    const channel_count = formatToChannelCount(texture.format);
+
     // TODO take channel count into account
 
     if (_width === undefined || _height === undefined) {
@@ -59,32 +64,55 @@ export function convertTexture2Sampler2D(
 
     }
 
-    // TODO add special case for DataTexture
 
-    const built = WebGLRendererPool.global.use(renderer => {
+    let data;
 
-        const ctx = renderer.getContext();
+    if (texture.isDataTexture === true) {
 
-        //support for compressed textures
-        ctx.getExtension("WEBGL_compressed_texture_s3tc");
+        // special case
+
+        const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
+
+        let converted = sampler2d_ensure_uint8_RGBA(source);
+
+        if (converted.width !== _width || converted.height !== _height) {
+            const target = Sampler2D.uint8(4, _width, _height);
+
+            sampler2d_scale(converted, target);
+
+            converted = target;
+        }
+
+        data = converted.data;
+
+    } else {
+        const built = WebGLRendererPool.global.use(renderer => {
+
+            const ctx = renderer.getContext();
+
+            //support for compressed textures
+            ctx.getExtension("WEBGL_compressed_texture_s3tc");
+
+            return ImageFilter(renderer, _width, _height, {
+                vertexShader: CopyShader.vertexShader,
+                fragmentShader: CopyShader.fragmentShader,
+                uniforms: {
+                    tDiffuse: {
+                        value: texture,
+                        type: 't'
+                    },
+                    opacity: { value: 1.0 }
+                }
+            });
 
-        return ImageFilter(renderer, _width, _height, {
-            vertexShader: CopyShader.vertexShader,
-            fragmentShader: CopyShader.fragmentShader,
-            uniforms: {
-                tDiffuse: {
-                    value: texture,
-                    type: 't'
-                },
-                opacity: { value: 1.0 }
-            }
         });
 
-    });
+        data = built.array;
+    }
 
     if (flipY) {
-        flipArrayInPlace(built.array, _width, _height);
+        sampler2d_flipY_in_place(data, _width, _height);
     }
 
-    return new Sampler2D(built.array, 4, _width, _height);
+    return new Sampler2D(data, 4, _width, _height);
 }

package/src/engine/graphics/texture/sampler/debug/prototypeSamplerFiltering.js

@@ -16,6 +16,7 @@ import { sampler2d_scale_down_lanczos } from "../resize/sampler2d_scale_down_lan
 import { sampler2d_scale_down_mipmap } from "../resize/sampler2d_scale_down_mipmap.js";
 import { sampler2d_scale_generic } from "../resize/sampler2d_scale_generic.js";
 import { Sampler2D } from "../Sampler2D.js";
+import { sampler2d_copy_rectangle } from "../sampler2d_copy_rectangle.js";
 import { debug_draw_sampler } from "./debug_draw_sampler.js";
 import { debug_draw_sampler_grid } from "./debug_draw_sampler_grid.js";
 
@@ -35,40 +36,11 @@ function setup_zoom_preview({ engine, sampler }) {
 
     const preview_container = debug_draw_sampler(engine, preview, 0, sampler.height);
     preview_container.transformOrigin.set(0, 0);
-    // preview_container.scale.setScalar(20);
-
-    /**
-     *
-     * @param {Sampler2D} source
-     * @param {Sampler2D} target
-     * @param {number} u0
-     * @param {number} v0
-     * @param {number} u1
-     * @param {number} v1
-     */
-    function update_preview(
-        source, target,
-        u0, v0, u1, v1
-    ) {
-
-        const sample = [];
-
-        for (let y = 0; y < target.height; y++) {
-            for (let x = 0; x < target.width; x++) {
-
-                const local_u = x / target.width;
-                const local_v = y / target.height;
 
-                source.sampleBilinearUV(local_u * (u1 - u0) + u0, local_v * (v1 - v0) + v0, sample);
-
-                target.write(x, y, sample);
-
-            }
-        }
+    // preview_container.scale.setScalar(20);
 
-    }
 
-    function setPreviewPosition(x,y){
+    function setPreviewPosition(x, y) {
         const window_size = 0.1;
 
 
@@ -81,7 +53,7 @@ function setup_zoom_preview({ engine, sampler }) {
         const center_v = clamp(v, w_2, 1 - w_2);
 
 
-        update_preview(
+        sampler2d_copy_rectangle(
             sampler, preview,
             center_u - w_2, center_v - w_2,
             center_u + w_2, center_v + w_2
@@ -89,7 +61,7 @@ function setup_zoom_preview({ engine, sampler }) {
 
         preview_container.$redraw();
 
-        console.log(x,y);
+        console.log(x, y);
     }
 
     // setPreviewPosition(366,420);

package/src/engine/graphics/texture/sampler/sampler2d_copy_rectangle.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {Sampler2D} source
+ * @param {Sampler2D} target
+ * @param {number} u0
+ * @param {number} v0
+ * @param {number} u1
+ * @param {number} v1
+ */
+export function sampler2d_copy_rectangle(source: Sampler2D, target: Sampler2D, u0: number, v0: number, u1: number, v1: number): void;
+//# sourceMappingURL=sampler2d_copy_rectangle.d.ts.map

package/src/engine/graphics/texture/sampler/sampler2d_copy_rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_copy_rectangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_copy_rectangle.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mFALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAiChB"}

package/src/engine/graphics/texture/sampler/sampler2d_copy_rectangle.js

@@ -0,0 +1,41 @@
+/**
+ *
+ * @param {Sampler2D} source
+ * @param {Sampler2D} target
+ * @param {number} u0
+ * @param {number} v0
+ * @param {number} u1
+ * @param {number} v1
+ */
+export function sampler2d_copy_rectangle(
+    source, target,
+    u0, v0, u1, v1
+) {
+
+    const sample = [];
+
+    const target_height = target.height;
+    const target_width = target.width;
+
+    const v_span = v1 - v0;
+    const u_span = u1 - u0;
+
+    const v_multiplier = v_span / target_height;
+    const u_multiplier = u_span / target_width;
+
+    for (let y = 0; y < target_height; y++) {
+
+        const source_v = y * v_multiplier + v0;
+
+        for (let x = 0; x < target_width; x++) {
+
+            const source_u = x * u_multiplier + u0;
+
+            source.sampleBilinearUV(source_u, source_v, sample);
+
+            target.write(x, y, sample);
+
+        }
+    }
+
+}

package/src/engine/graphics/texture/virtual/VirtualTextureUsage.d.ts

@@ -25,10 +25,6 @@ export class VirtualTextureUsage {
      * @param {number} bias added to the ancestor tiles to make them more likely to be loaded
      */
     promoteAncestors(bias?: number): void;
-    /**
-     * Sort occupancy list in descending order
-     */
-    sortOccupancy(): void;
     sortOccupancyByLOD(): void;
     /**
      *

package/src/engine/graphics/texture/virtual/VirtualTextureUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureUsage.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureUsage.js"],"names":[],"mappings":"AAOA;IAcI,0BAEC;IAKD,+BAIC;IAED,4BAEC;IAGD,6BAEC;IAED,8BAEC;IAkBD;;;;OAIG;IACH,mCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED,cAGC;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAsChB;IAWD;;OAEG;IACH,sBAiBC;IAED,2BAqBC;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAsCpB;;CACJ"}
+{"version":3,"file":"VirtualTextureUsage.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureUsage.js"],"names":[],"mappings":"AAMA;IAcI,0BAEC;IAKD,+BAIC;IAED,4BAEC;IAGD,6BAEC;IAED,8BAEC;IAkBD;;;;OAIG;IACH,mCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED,cAGC;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAsChB;IAWD,2BAiCC;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAsCpB;;CACJ"}

package/src/engine/graphics/texture/virtual/VirtualTextureUsage.js

@@ -1,6 +1,5 @@
-import { array_quick_sort_by_comparator, arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
+import { array_quick_sort_by_comparator } from "../../../../core/collection/array/array_quick_sort_by_comparator.js";
 import { compose_tile_address } from "./tile/compose_tile_address.js";
-import { decompose_finger_print } from "./tile/decompose_finger_print.js";
 import { finger_print_to_tile_address } from "./tile/finger_print_to_tile_address.js";
 import { tile_address_to_finger_print } from "./tile/tile_address_to_finger_print.js";
 
@@ -142,36 +141,21 @@ export class VirtualTextureUsage {
         this.#occupancy_cursor++;
     }
 
-    /**
-     * Sort occupancy list in descending order
-     */
-    sortOccupancy() {
-        // array_quick_sort_by_comparator(this.#occupancy, (a, b) => {
-        //
-        //     return a-b;
-        //
-        //
-        // }, null, 0, this.#occupancy_cursor - 1);
-
-        //
-        // arrayQuickSort(this.#occupancy, v => -v, null, 0, this.#occupancy_cursor - 1);
-        arrayQuickSort(
-            this.#occupancy,
-            (index) => {
-                return -this.#counts_intrinsic[index]
-            }, null,
-            0, this.#occupancy_cursor - 1
-        );
-    }
-
     sortOccupancyByLOD() {
-        array_quick_sort_by_comparator(this.#occupancy, (a, b) => {
+        /**
+         *
+         * @param {number} a
+         * @param {number} b
+         * @return {number}
+         */
+        const compare = (a, b) => {
 
             const fingerprint_a = tile_address_to_finger_print(a);
             const fingerprint_b = tile_address_to_finger_print(b);
 
-            const { mip: mip_a } = decompose_finger_print(fingerprint_a);
-            const { mip: mip_b } = decompose_finger_print(fingerprint_b);
+            // read MIP levels
+            const mip_a = (fingerprint_a >> 24) & 0xFF;
+            const mip_b = (fingerprint_b >> 24) & 0xFF;
 
             const mip_delta = mip_a - mip_b;
 
@@ -179,11 +163,16 @@ export class VirtualTextureUsage {
                 return mip_delta;
             }
 
-            const count_a = this.#counts_intrinsic[a];
-            const count_b = this.#counts_intrinsic[b];
+            const intrinsic = this.#counts_intrinsic;
+
+            const count_a = intrinsic[a];
+            const count_b = intrinsic[b];
+
             return count_b - count_a;
 
-        }, null, 0, this.#occupancy_cursor - 1);
+        };
+
+        array_quick_sort_by_comparator(this.#occupancy, compare, null, 0, this.#occupancy_cursor - 1);
 
     }