@woosh/meep-engine 2.50.3 → 2.51.0

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -4,7 +4,7 @@ import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../../core/assert.js";
-import { scaleSampler2D } from "../../../../graphics/texture/sampler/scaleSampler2D.js";
+import { sampler2d_scale } from "../../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 import { array_copy } from "../../../../../core/collection/array/array_copy.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { Base64 } from "../../../../../core/binary/Base64.js";
@@ -520,7 +520,7 @@ export class SplatMapping {
                         const source = new Sampler2D(oldWeightData.subarray(d * oldLayerSize, (d + 1) * oldLayerSize), 1, oldWidth, oldHeight);
                         const target = new Sampler2D(weightImage.data.subarray(d * newLayerSize, (d + 1) * newLayerSize), 1, width, height);
 
-                        scaleSampler2D(source, target);
+                        sampler2d_scale(source, target);
                     }
                 }
 

package/src/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -11,7 +11,7 @@ import { assert } from "../../../../core/assert.js";
 import ObservedString from "../../../../core/model/ObservedString.js";
 import { ClampToEdgeWrapping, DataTexture, NearestFilter } from "three";
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
-import { scaleSampler2D } from "../../../graphics/texture/sampler/scaleSampler2D.js";
+import { sampler2d_scale } from "../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 import { uint82float } from "../../../../core/binary/uint82float.js";
 import { float2uint8 } from "../../../../core/binary/float2uint8.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
@@ -314,7 +314,7 @@ export class TerrainOverlay {
 
         // rescale source if needed
         const scaled_source = Sampler2D.uint8(4, dWidth, dHeight);
-        scaleSampler2D(source, scaled_source);
+        sampler2d_scale(source, scaled_source);
 
         this.sampler.paint(scaled_source, 0, 0, dx, dy, dWidth, dHeight);
 

package/src/engine/ecs/terrain/util/paintTerrainOverlayViaLookupTable.js

@@ -2,7 +2,7 @@ import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { ParameterLookupTable } from "../../../graphics/particles/particular/engine/parameter/ParameterLookupTable.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { clamp01 } from "../../../../core/math/clamp01.js";
-import { scaleSampler2D } from "../../../graphics/texture/sampler/scaleSampler2D.js";
+import { sampler2d_scale } from "../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 
 
 const heatmap_lut = new ParameterLookupTable(4);
@@ -43,7 +43,7 @@ export function paintTerrainOverlayViaLookupTable({
     // rescale source
     const scaled_sampler = sampler.clone();
     scaled_sampler.resize(w, h);
-    scaleSampler2D(sampler, scaled_sampler);
+    sampler2d_scale(sampler, scaled_sampler);
 
     for (j = 0; j < h; j++) {
 

package/src/engine/graphics/copy_transform_to_threejs_object.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {Object3D} m
+ * @param {Transform} t
+ */
+export function copy_transform_to_threejs_object(m, t) {
+    m.position.copy(t.position);
+
+    t.rotation.toEulerAnglesXYZ(m.rotation);
+
+    m.scale.copy(t.scale);
+}

package/src/engine/graphics/debug/VisualSymbolLine.js

@@ -1,5 +1,5 @@
 import { BufferGeometry, Float32BufferAttribute, Line, LineBasicMaterial } from "three";
-import Renderable from "../../ecs/components/Renderable.js";
+import Renderable from "../../ecs/renderable/Renderable.js";
 
 export class VisualSymbolLine {
 

package/src/engine/graphics/ecs/decal/DecalSystem.js

@@ -5,7 +5,7 @@ import { System } from '../../../ecs/System.js';
 import { Euler as ThreeEuler, MaterialLoader, Mesh as ThreeMesh, Vector3 as ThreeVector3 } from 'three';
 import { Transform } from '../../../ecs/transform/Transform.js';
 import Mesh from '../mesh/Mesh.js';
-import Renderable from '../../../ecs/components/Renderable.js';
+import Renderable from '../../../ecs/renderable/Renderable.js';
 import LoadMaterial from "../../material/LoadMaterial.js";
 
 import Decal from "./Decal.js";

package/src/engine/graphics/ecs/highlight/renderer/makeGaussianBlurShader.js

@@ -1,8 +1,5 @@
 import LineBuilder from "../../../../../core/codegen/LineBuilder.js";
-
-function gaussian(s, v) {
-    return Math.exp(-(v * v) / (2.0 * s * s));
-}
+import { gaussian } from "../../../../../core/math/gaussian.js";
 
 /**
  * Pre-build kernel internally, no branches in convolution code, everything is inlined

package/src/engine/graphics/ecs/highlight/system/RenderableHighlightSystem.d.ts

@@ -1,7 +1,7 @@
 import {System} from "../../../../ecs/System";
 import Engine from "../../../../Engine";
 import Highlight from "../Highlight";
-import Renderable from "../../../../ecs/components/Renderable";
+import Renderable from "../../../../ecs/renderable/Renderable";
 
 export class RenderableHighlightSystem extends System<Highlight, Renderable> {
     constructor(engine: Engine)

package/src/engine/graphics/ecs/highlight/system/RenderableHighlightSystem.js

@@ -1,7 +1,7 @@
 import { System } from "../../../../ecs/System.js";
 import { HighlightRenderElementSource } from "../plugin/HighlightRenderElementSource.js";
-import Renderable from "../../../../ecs/components/Renderable.js";
-import { RenderableFlags } from "../../../../ecs/components/RenderableFlags.js";
+import Renderable from "../../../../ecs/renderable/Renderable.js";
+import { RenderableFlags } from "../../../../ecs/renderable/RenderableFlags.js";
 import Highlight from "../Highlight.js";
 import { OutlineRenderPlugin } from "../plugin/OutlineRenderPlugin.js";
 

package/src/engine/graphics/ecs/mesh/applyTransformToThreeObject.js

@@ -1,4 +1,5 @@
 import { rootObject3DFastMatrixUpdate } from "./rootObject3DFastMatrixUpdate.js";
+import { copy_transform_to_threejs_object } from "../../copy_transform_to_threejs_object.js";
 
 /**
  *
@@ -6,11 +7,7 @@ import { rootObject3DFastMatrixUpdate } from "./rootObject3DFastMatrixUpdate.js"
  * @param {Transform} t
  */
 export function applyTransformToThreeObject(m, t) {
-    m.position.copy(t.position);
-
-    t.rotation.toEulerAnglesXYZ(m.rotation);
-
-    m.scale.copy(t.scale);
+    copy_transform_to_threejs_object(m, t);
 
     rootObject3DFastMatrixUpdate(m);
 }

package/src/engine/graphics/ecs/path/ribbon/RibbonPathBuilder.js

@@ -4,8 +4,8 @@ import {
     RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
 } from "../../../trail/x/ribbon_attributes_spec.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
-import Renderable from "../../../../ecs/components/Renderable.js";
-import { RenderableFlags } from "../../../../ecs/components/RenderableFlags.js";
+import Renderable from "../../../../ecs/renderable/Renderable.js";
+import { RenderableFlags } from "../../../../ecs/renderable/RenderableFlags.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import ThreeFactory from "../../../three/ThreeFactory.js";

package/src/engine/graphics/geometry/optimization/merge/prototypeGeometryMerge.js

@@ -8,7 +8,7 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import EntityBuilder from "../../../../ecs/EntityBuilder.js";
-import Renderable from "../../../../ecs/components/Renderable.js";
+import Renderable from "../../../../ecs/renderable/Renderable.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { merge_geometry_hierarchy } from "./merge_geometry_hierarchy.js";
 import {

package/src/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -65,7 +65,7 @@ import { ShadedGeometry } from "../../../../../ecs/mesh-v2/ShadedGeometry.js";
 import { DrawMode } from "../../../../../ecs/mesh-v2/DrawMode.js";
 import { makeHelperBoxGeometry } from "../../../../../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
 import { LineBasicMaterial } from "three";
-import Renderable from "../../../../../../ecs/components/Renderable.js";
+import Renderable from "../../../../../../ecs/renderable/Renderable.js";
 import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
 import { threeUpdateTransform } from "../../../../../util/threeUpdateTransform.js";
 import InputController from "../../../../../../input/ecs/components/InputController.js";

package/src/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -65,7 +65,7 @@ import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/Behavio
 import { Light } from "../../../ecs/light/Light.js";
 import { LightType } from "../../../ecs/light/LightType.js";
 import { parseColor } from "../../../../../core/color/parseColor.js";
-import Renderable from "../../../../ecs/components/Renderable.js";
+import Renderable from "../../../../ecs/renderable/Renderable.js";
 import { makeHelperSphereGeometry } from "../../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
 import TopDownCameraController from "../../../ecs/camera/topdown/TopDownCameraController.js";
 import ThreeFactory from "../../../three/ThreeFactory.js";

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

@@ -18,7 +18,7 @@ import { float2uint8 } from "../../../../core/binary/float2uint8.js";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { Camera } from "../../ecs/camera/Camera.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
-import { scaleSampler2D } from "../../texture/sampler/scaleSampler2D.js";
+import { sampler2d_scale } from "../../texture/sampler/resize/sampler2d_scale.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { mat4, vec3 } from "gl-matrix";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
@@ -595,7 +595,7 @@ async function start_renderer(camera) {
         vContainer.removeChild(vProgress);
 
         if (scaled_rt !== rt) {
-            scaleSampler2D(scaled_rt, rt);
+            sampler2d_scale(scaled_rt, rt);
         }
 
         sampler2D2Canvas(rt, 1, 0, vCanvas.el);

package/src/engine/graphics/shaders/SoftOutlineShader.js

@@ -2,11 +2,9 @@
  * Created by Alex on 02/10/2015.
  */
 import * as THREE from 'three';
+import { gaussian } from "../../../core/math/gaussian.js";
 
 let SoftOutlineShader = function (edge, sigma, hardPixels) {
-    function gaussian(s, v) {
-        return Math.exp(-(v * v) / (2.0 * s * s));
-    }
 
     function makeFragmentBody() {
         const kernel = [];
@@ -110,4 +108,4 @@ let SoftOutlineShader = function (edge, sigma, hardPixels) {
     }
 };
 
-export default GaussianGlowShader;
+export default GaussianGlowShader;

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.spec.js

@@ -0,0 +1,24 @@
+import { TextureAtlas } from "./TextureAtlas.js";
+import { CachingTextureAtlas } from "./CachingTextureAtlas.js";
+import { Sampler2D } from "../sampler/Sampler2D.js";
+
+test("constructor does not throw", () => {
+
+    const atlas = new TextureAtlas();
+
+    expect(() => new CachingTextureAtlas({ atlas })).not.toThrow();
+
+});
+
+test("add one", () => {
+
+    const atlas = new TextureAtlas();
+    const cached = new CachingTextureAtlas({ atlas });
+
+    const s = Sampler2D.uint8(4, 1, 1);
+
+    const patch = cached.add(s, 0);
+
+    expect(atlas.contains(patch)).toBe(true);
+
+});

package/src/engine/graphics/texture/atlas/TextureAtlas.spec.js

@@ -122,6 +122,52 @@ test("contains method works correctly", () => {
     expect(atlas.contains(patch)).toBe(false);
 });
 
+test("remove method", () => {
+
+    const atlas = new TextureAtlas();
+
+    const s = Sampler2D.uint8(4, 1, 1);
+
+    s.writeChannel(0, 0, 0, 1);
+    s.writeChannel(0, 0, 1, 2);
+    s.writeChannel(0, 0, 2, 3);
+    s.writeChannel(0, 0, 3, 5);
+
+    const patch_a = atlas.add(s, 0);
+
+    expect(atlas.remove(patch_a)).toBe(true);
+
+    expect(atlas.remove(patch_a)).toBe(false);
+
+    // removed patch is erased
+    const patch_b = atlas.add(s, 0);
+
+    atlas.update();
+
+    atlas.remove(patch_b);
+
+    const p = patch_b.position;
+
+    expect(atlas.sampler.readChannel(p.x, p.y, 0)).toEqual(0);
+    expect(atlas.sampler.readChannel(p.x, p.y, 1)).toEqual(0);
+    expect(atlas.sampler.readChannel(p.x, p.y, 2)).toEqual(0);
+    expect(atlas.sampler.readChannel(p.x, p.y, 3)).toEqual(0);
+});
+
+test("reset", () => {
+    const atlas = new TextureAtlas();
+
+    expect(() => atlas.reset()).not.toThrow();
+
+    const s = Sampler2D.uint8(4, 1, 1);
+
+    const patch = atlas.add(s, 0);
+
+    atlas.reset();
+
+    expect(atlas.contains(patch)).toBe(false);
+});
+
 /**
  *
  * @param {AtlasPatch} patch

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

@@ -2,7 +2,7 @@
  * Created by Alex on 30/10/2014.
  */
 import QuadTree from '../../../../core/geom/2d/quad-tree/PointQuadTree.js';
-import AABB2 from '../../../../core/geom/AABB2.js';
+import AABB2 from '../../../../core/geom/2d/aabb/AABB2.js';
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { makeRangedRandom } from "../../../../core/math/random/makeRangedRandom.js";
 

package/src/engine/graphics/texture/sampler/bicubic.spec.js

@@ -0,0 +1,13 @@
+import { bicubic } from "./bicubic.js";
+
+test("sanity", () => {
+
+    expect(bicubic(
+        0.5, 0.5,
+        3, 3, 3, 3,
+        3, 3, 3, 3,
+        3, 3, 3, 3,
+        3, 3, 3, 3,
+    )).toBeCloseTo(3);
+
+});

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

@@ -3,7 +3,7 @@ import { vector_nd_normalize } from "../../../../core/math/vector_nd_normalize.j
 import { vector_nd_dot } from "../../../../core/math/vector_nd_dot.js";
 
 /**
- *
+ * NOTE: treats samplers as normal maps
  * @param {Sampler2D} sampler0
  * @param {Sampler2D} sampler1
  * @returns {Sampler2D}

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.js

@@ -8,7 +8,11 @@ import { BitSet } from "../../../../../core/binary/BitSet.js";
  * @param {Sampler2D} destination
  * @param {number} emptyValue
  */
-export function computeSignedDistanceField_NaiveFlood(source, destination, emptyValue) {
+export function computeSignedDistanceField_NaiveFlood(
+    source,
+    destination,
+    emptyValue
+) {
     assert.equal(source.itemSize, 1, `unsupported source.itemSize, expected 1, got '${source.itemSize}'`);
     assert.typeOf(emptyValue, 'number', 'emptyValue');
 

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.spec.js

@@ -0,0 +1,183 @@
+import { Sampler2D } from "../Sampler2D.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
+import { computeSignedDistanceField_NaiveFlood } from "./computeSignedDistanceField_NaiveFlood.js";
+
+test('empty', () => {
+    const source = Sampler2D.uint8(1, 0, 0);
+    const target = Sampler2D.uint8(1, 0, 0);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+});
+
+test('1 pixel empty source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(255);
+});
+
+test('1 pixel filled source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+});
+
+test('3x3 pixel source with filled middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.set(1, 1, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with empty middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(1, 1, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x3 pixel source with empty corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(0, 0, [0]);
+    source.set(2, 0, [0]);
+    source.set(0, 2, [0]);
+    source.set(2, 2, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with filled corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+    source.set(2, 0, [255]);
+    source.set(0, 2, [255]);
+    source.set(2, 2, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x1 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 1);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 1);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+});
+
+test('3x3 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(2);
+
+    expect(target.readChannel(0, 2, 0)).toBe(2);
+    expect(target.readChannel(1, 2, 0)).toBe(2);
+    expect(target.readChannel(2, 2, 0)).toBe(2);
+});
+
+test.skip('performance', () => {
+
+    const sizeX = 100;
+    const sizeY = 100;
+
+    const source = Sampler2D.uint8(1, sizeX, sizeY);
+
+    const random = seededRandom(42);
+    source.data.fill(0);
+    for (let i = 0; i < source.data.length * 0.1; i++) {
+        const x = randomIntegerBetween(random, 0, sizeX);
+        const y = randomIntegerBetween(random, 0, sizeY);
+        source.set(x, y, [255]);
+    }
+
+    const target = Sampler2D.uint8(1, sizeX, sizeY);
+
+    console.time('p');
+    computeSignedDistanceField_NaiveFlood(source, target, 0);
+    console.timeEnd('p');
+
+});

package/src/engine/graphics/texture/sampler/filter/filter_lanczos3.js

@@ -0,0 +1,20 @@
+export function filter_lanczos3(x) {
+    // assume the input is positive
+
+    // if (x < 0) {
+    //     x = -x;
+    // }
+
+    if (x > 3) {
+        return 0;
+    }
+
+    if (x < 1.1920929e-7) {
+        return 1;
+    }
+
+    return (3 * Math.sin(Math.PI * x) * Math.sin(Math.PI * x / 3)) / (Math.PI * Math.PI * x * x);
+
+}
+
+filter_lanczos3.support = 3;

package/src/engine/graphics/texture/sampler/filter/mitchell.js

@@ -1,5 +1,3 @@
-import { assert } from "../../../../../core/assert.js";
-
 const b = 1.0 / 3.0;
 const c = 1.0 / 3.0;
 
@@ -38,22 +36,3 @@ export function mitchell(x) {
 
 mitchell.support = 2;
 
-/**
- * Hand-optimized mitchell function with c = 0.3333333 and b = 0.3333333
- * NOTE: assumes non-negative values only
- * @param {number} x
- * @returns {number}
- */
-export function mitchell_v1(x) {
-    assert.greaterThanOrEqual(x, 0);
-
-    if (x < 1.0) {
-        return 0.8888888888888888 + x * x * (-2 + x * 1.1666666666666667);
-    }
-    if (x < 2.0) {
-        return 1.7777777777777777 + x * (-3.3333333333333335 + x * (2 + x * -0.3888888888888889));
-    }
-    return 0.0;
-}
-
-mitchell_v1.support = 2;

package/src/engine/graphics/texture/sampler/filter/mitchell_v1.js

@@ -0,0 +1,21 @@
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ * Hand-optimized mitchell function with c = 0.3333333 and b = 0.3333333
+ * NOTE: assumes non-negative values only
+ * @param {number} x
+ * @returns {number}
+ */
+export function mitchell_v1(x) {
+    assert.greaterThanOrEqual(x, 0);
+
+    if (x < 1.0) {
+        return 0.8888888888888888 + x * x * (-2 + x * 1.1666666666666667);
+    }
+    if (x < 2.0) {
+        return 1.7777777777777777 + x * (-3.3333333333333335 + x * (2 + x * -0.3888888888888889));
+    }
+    return 0.0;
+}
+
+mitchell_v1.support = 2;