@truelab/truengine 6.0.0 → 7.0.0

package/dist/browserAll-chunk.js

@@ -1,7 +1,7 @@
-import { e as a, A as e, C as i, a as s, D as t, E as n, F as d } from "./pixi-chunk.js";
+import { e as i, A as e, C as a, b as s, D as t, E as n, c as d } from "./pixi-chunk.js";
 import "./webworkerAll-chunk.js";
-a.add(e);
-a.mixin(i, s);
-a.add(t);
-a.add(n);
-a.mixin(i, d);
+i.add(e);
+i.mixin(a, s);
+i.add(t);
+i.add(n);
+i.mixin(a, d);

package/dist/index-chunk2.js

@@ -0,0 +1,190 @@
+import { F as a, O as c, d as m, G as v, a as y } from "./pixi-chunk.js";
+import { w as p, v as S } from "./index-chunk3.js";
+var x = `precision highp float;
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform vec2 uVelocity;
+uniform int uKernelSize;
+uniform float uOffset;
+
+uniform vec4 uInputSize;
+
+const int MAX_KERNEL_SIZE = 2048;
+
+// Notice:
+// the perfect way:
+//    int kernelSize = min(uKernelSize, MAX_KERNELSIZE);
+// BUT in real use-case , uKernelSize < MAX_KERNELSIZE almost always.
+// So use uKernelSize directly.
+
+void main(void)
+{
+    vec4 color = texture(uTexture, vTextureCoord);
+
+    if (uKernelSize == 0)
+    {
+        finalColor = color;
+        return;
+    }
+
+    vec2 velocity = uVelocity / uInputSize.xy;
+    float offset = -uOffset / length(uVelocity) - 0.5;
+    int k = uKernelSize - 1;
+
+    for(int i = 0; i < MAX_KERNEL_SIZE - 1; i++) {
+        if (i == k) {
+            break;
+        }
+        vec2 bias = velocity * (float(i) / float(k) + offset);
+        color += texture(uTexture, vTextureCoord + bias);
+    }
+    finalColor = color / float(uKernelSize);
+}
+`, h = `struct MotionBlurUniforms {
+  uVelocity: vec2<f32>,
+  uKernelSize: i32,
+  uOffset: f32,
+};
+
+struct GlobalFilterUniforms {
+  uInputSize:vec4<f32>,
+  uInputPixel:vec4<f32>,
+  uInputClamp:vec4<f32>,
+  uOutputFrame:vec4<f32>,
+  uGlobalFrame:vec4<f32>,
+  uOutputTexture:vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms;
+
+@group(0) @binding(1) var uTexture: texture_2d<f32>; 
+@group(0) @binding(2) var uSampler: sampler;
+@group(1) @binding(0) var<uniform> motionBlurUniforms : MotionBlurUniforms;
+
+@fragment
+fn mainFragment(
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv : vec2<f32>
+) -> @location(0) vec4<f32> {
+  let uVelocity = motionBlurUniforms.uVelocity;
+  let uKernelSize = motionBlurUniforms.uKernelSize;
+  let uOffset = motionBlurUniforms.uOffset;
+
+  let velocity: vec2<f32> = uVelocity / gfu.uInputSize.xy;
+  let offset: f32 = -uOffset / length(uVelocity) - 0.5;
+  let k: i32 = min(uKernelSize - 1, MAX_KERNEL_SIZE - 1);
+
+  var color: vec4<f32> = textureSample(uTexture, uSampler, uv);
+
+  for(var i: i32 = 0; i < k; i += 1) {
+    let bias: vec2<f32> = velocity * (f32(i) / f32(k) + offset);
+    color += textureSample(uTexture, uSampler, uv + bias);
+  }
+  
+  return select(color / f32(uKernelSize), textureSample(uTexture, uSampler, uv), uKernelSize == 0);
+}
+
+const MAX_KERNEL_SIZE: i32 = 2048;`, z = Object.defineProperty, g = (n, e, t) => e in n ? z(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, i = (n, e, t) => (g(n, typeof e != "symbol" ? e + "" : e, t), t);
+const r = class o extends a {
+  /** @ignore */
+  constructor(...e) {
+    let t = e[0] ?? {};
+    if (Array.isArray(t) || "x" in t && "y" in t || t instanceof c) {
+      m("6.0.0", "MotionBlurFilter constructor params are now options object. See params: { velocity, kernelSize, offset }");
+      const s = "x" in t ? t.x : t[0], f = "y" in t ? t.y : t[1];
+      t = { velocity: { x: s, y: f } }, e[1] !== void 0 && (t.kernelSize = e[1]), e[2] !== void 0 && (t.offset = e[2]);
+    }
+    t = { ...o.DEFAULT_OPTIONS, ...t };
+    const u = v.from({
+      vertex: {
+        source: p,
+        entryPoint: "mainVertex"
+      },
+      fragment: {
+        source: h,
+        entryPoint: "mainFragment"
+      }
+    }), l = y.from({
+      vertex: S,
+      fragment: x,
+      name: "motion-blur-filter"
+    });
+    super({
+      gpuProgram: u,
+      glProgram: l,
+      resources: {
+        motionBlurUniforms: {
+          uVelocity: { value: { x: 0, y: 0 }, type: "vec2<f32>" },
+          uKernelSize: { value: Math.trunc(t.kernelSize ?? 5), type: "i32" },
+          uOffset: { value: t.offset, type: "f32" }
+        }
+      }
+    }), i(this, "uniforms"), i(this, "_kernelSize"), this.uniforms = this.resources.motionBlurUniforms.uniforms, Object.assign(this, t);
+  }
+  /**
+   * Sets the velocity of the motion for blur effect
+   * This should be a size 2 array or an object containing `x` and `y` values, you cannot change types
+   * once defined in the constructor
+   * @default {x:0,y:0}
+   */
+  get velocity() {
+    return this.uniforms.uVelocity;
+  }
+  set velocity(e) {
+    Array.isArray(e) && (e = { x: e[0], y: e[1] }), this.uniforms.uVelocity = e, this._updateDirty();
+  }
+  /**
+   * Sets the velocity of the motion for blur effect on the `x` axis
+   * @default 0
+   */
+  get velocityX() {
+    return this.velocity.x;
+  }
+  set velocityX(e) {
+    this.velocity.x = e, this._updateDirty();
+  }
+  /**
+   * Sets the velocity of the motion for blur effect on the `x` axis
+   * @default 0
+   */
+  get velocityY() {
+    return this.velocity.y;
+  }
+  set velocityY(e) {
+    this.velocity.y = e, this._updateDirty();
+  }
+  /**
+   * The kernelSize of the blur filter. Must be odd number >= 5
+   * @default 5
+   */
+  get kernelSize() {
+    return this._kernelSize;
+  }
+  set kernelSize(e) {
+    this._kernelSize = e, this._updateDirty();
+  }
+  /**
+   * The offset of the blur filter
+   * @default 0
+   */
+  get offset() {
+    return this.uniforms.uOffset;
+  }
+  set offset(e) {
+    this.uniforms.uOffset = e;
+  }
+  _updateDirty() {
+    this.padding = (Math.max(Math.abs(this.velocityX), Math.abs(this.velocityY)) >> 0) + 1, this.uniforms.uKernelSize = this.velocityX !== 0 || this.velocityY !== 0 ? this._kernelSize : 0;
+  }
+};
+i(r, "DEFAULT_OPTIONS", {
+  velocity: { x: 0, y: 0 },
+  kernelSize: 5,
+  offset: 0
+});
+let b = r;
+export {
+  b as MotionBlurFilter
+};