modern-canvas 0.4.15 → 0.4.17

package/dist/index.mjs

@@ -1289,6 +1289,7 @@ class Matrix extends EventEmitter {
     }
   }
   _array = [];
+  dirtyId = 0;
   get length() {
     return this.cols * this.rows;
   }
@@ -1393,6 +1394,7 @@ class Matrix extends EventEmitter {
     return this._operate("*", value, output);
   }
   _onUpdate(_array) {
+    this.dirtyId++;
   }
   toArray(transpose = false) {
     const { cols, rows, _array: array } = this;
@@ -1974,150 +1976,90 @@ class Rect2 {
 }
 
 class Transform2D extends Matrix3 {
-  constructor(autoUpdate = true) {
-    super();
-    this.autoUpdate = autoUpdate;
-  }
-  _cx = 1;
-  _sx = 0;
-  _cy = 0;
-  _sy = 1;
-  _translateX = 0;
-  _translateY = 0;
-  _translateZ = 1;
-  _scaleX = 1;
-  _scaleY = 1;
-  _skewX = 0;
-  _skewY = 0;
-  _rotate = 0;
-  dirtyId = 0;
-  _needsUpdateArray = false;
-  _needsUpdateFields = false;
-  _onUpdate(array) {
-    super._onUpdate(array);
-    this._requestUpdateFields();
-  }
-  _updateSkew() {
-    this._cx = Math.cos(this._rotate + this._skewY);
-    this._sx = Math.sin(this._rotate + this._skewY);
-    this._cy = -Math.sin(this._rotate - this._skewX);
-    this._sy = Math.cos(this._rotate - this._skewX);
-  }
-  _requestUpdateArray() {
-    if (this.autoUpdate) {
-      this._performUpdateArray();
-    } else {
-      this._needsUpdateArray = true;
-    }
-  }
-  _requestUpdateFields() {
-    if (this.autoUpdate) {
-      this._performUpdateFields();
-    } else {
-      this._needsUpdateFields = true;
-    }
-  }
-  _performUpdateArray() {
-    const a = this._cx * this._scaleX;
-    const b = this._sx * this._scaleX;
-    const c = this._cy * this._scaleY;
-    const d = this._sy * this._scaleY;
-    const tx = this._translateX;
-    const ty = this._translateY;
-    const tz = this._translateZ;
-    const array = this._array;
-    this._array = [
-      a,
-      c,
-      tx,
-      b,
-      d,
-      ty,
-      array[6],
-      array[7],
-      tz
-    ];
-    this.dirtyId++;
-  }
-  _performUpdateFields() {
-    const {
-      a,
-      c,
-      tx,
-      b,
-      d,
-      ty,
-      tz
-    } = this.toObject();
-    const skewX = -Math.atan2(-c, d);
-    const skewY = Math.atan2(b, a);
-    const delta = Math.abs(skewX + skewY);
-    if (delta < 1e-5 || Math.abs(PI_2 - delta) < 1e-5) {
-      this._rotate = skewY;
-      this._skewX = this._skewY = 0;
-    } else {
-      this._rotate = 0;
-      this._skewX = skewX;
-      this._skewY = skewY;
-    }
-    this._scaleX = Math.sqrt(a * a + b * b);
-    this._scaleY = Math.sqrt(c * c + d * d);
-    this._translateX = tx;
-    this._translateY = ty;
-    this._translateZ = tz;
-    this.dirtyId++;
-  }
-  skew(x, y) {
-    this._skewX = x;
-    this._skewY = y;
-    this._updateSkew();
-    this._requestUpdateArray();
-    return this;
+  static _t2d = /* @__PURE__ */ new Transform2D();
+  premultiply(t2d) {
+    return t2d.multiply(this, this);
   }
   skewX(x) {
-    return this.skew(x, this._skewY);
+    return this.skew(x, 1);
   }
   skewY(y) {
-    return this.skew(this._skewX, y);
+    return this.skew(1, y);
   }
-  translate(x, y, z = 1) {
-    this._translateX = x;
-    this._translateY = y;
-    this._translateZ = z;
-    this._requestUpdateArray();
+  skew(x, y) {
+    return this.premultiply(Transform2D._t2d.makeSkew(x, y));
+  }
+  makeSkew(x, y) {
+    const cx = Math.cos(y);
+    const sx = Math.sin(y);
+    const cy = -Math.sin(-x);
+    const sy = Math.cos(-x);
+    this.set([
+      cx,
+      cy,
+      0,
+      sx,
+      sy,
+      0,
+      0,
+      0,
+      1
+    ]);
     return this;
   }
   translateX(x) {
-    return this.translate(x, this._translateY);
+    return this.translate(x, 0);
   }
   translateY(y) {
-    return this.translate(this._translateX, y);
+    return this.translate(0, y);
   }
   translateZ(z) {
-    return this.translate(this._translateX, this._translateY, z);
+    return this.translate(0, 0, z);
   }
   translate3d(x, y, z) {
     return this.translate(x, y, z);
   }
-  scale(x, y, _z = 1) {
-    this._scaleX = x;
-    this._scaleY = y;
-    this._requestUpdateArray();
+  translate(x, y, z = 0) {
+    return this.premultiply(Transform2D._t2d.makeTranslation(x, y, z));
+  }
+  makeTranslation(x, y, _z = 0) {
+    this.set([
+      1,
+      0,
+      x,
+      0,
+      1,
+      y,
+      0,
+      0,
+      1
+    ]);
     return this;
   }
   scaleX(x) {
-    return this.scale(x, this._scaleY);
+    return this.scale(x, 1);
   }
   scaleY(y) {
-    return this.scale(this._scaleX, y);
+    return this.scale(1, y);
   }
-  scale3d(x, y, z) {
+  scale3d(x, y, z = 1) {
     return this.scale(x, y, z);
   }
-  rotate(rad) {
-    this._rotate = rad;
-    this._updateSkew();
-    this._requestUpdateArray();
+  scale(x, y, z = 1) {
+    return this.premultiply(Transform2D._t2d.makeScale(x, y, z));
+  }
+  makeScale(x, y, z = 1) {
+    this.set([
+      x,
+      0,
+      0,
+      0,
+      y,
+      0,
+      0,
+      0,
+      z
+    ]);
     return this;
   }
   rotateX(x) {
@@ -2129,6 +2071,9 @@ class Transform2D extends Matrix3 {
   rotateZ(z) {
     return this.rotate(z);
   }
+  rotate(rad) {
+    return this.premultiply(Transform2D._t2d.makeRotation(rad));
+  }
   rotate3d(x, y, z, rad) {
     const [rx, ry, rz] = this._rotate3d(x, y, z, rad);
     rx && this.rotateX(rx);
@@ -2162,6 +2107,22 @@ class Transform2D extends Matrix3 {
       return [rotateX, rotateY, rotateZ];
     }
   }
+  makeRotation(theta) {
+    const c = Math.cos(theta);
+    const s = Math.sin(theta);
+    this.set([
+      c,
+      -s,
+      0,
+      s,
+      c,
+      0,
+      0,
+      0,
+      1
+    ]);
+    return this;
+  }
   applyToPoint(x, y) {
     const { a, c, tx, b, d, ty } = this.toObject();
     return [
@@ -2172,20 +2133,6 @@ class Transform2D extends Matrix3 {
   inverse() {
     return this.clone().invert();
   }
-  update() {
-    let updated = false;
-    if (this._needsUpdateArray) {
-      this._needsUpdateArray = false;
-      this._performUpdateArray();
-      updated = true;
-    }
-    if (this._needsUpdateFields) {
-      this._needsUpdateFields = false;
-      this._performUpdateFields();
-      updated = true;
-    }
-    return updated;
-  }
   isIdentity() {
     const { a, b, c, d, tx, ty } = this.toObject();
     return a === 1 && b === 0 && c === 0 && d === 1 && tx === 0 && ty === 0;
@@ -4383,58 +4330,56 @@ function parseCSSFilter(filter) {
   return m;
 }
 
-function parseCSSTransform(transform, width, height) {
-  const t2d = new Transform2D(false);
+function parseCSSTransform(transform, width, height, output = new Transform2D()) {
   transform = !transform || transform === "none" ? "" : transform;
   parseCssFunctions(transform, { width, height }).forEach(({ name, args }) => {
     const values = args.map((arg) => arg.normalizedIntValue);
-    const _temp = new Transform2D();
     switch (name) {
       case "translate":
-        _temp.translate(values[0] * width, (values[1] ?? values[0]) * height);
+        output.translate(values[0] * width, (values[1] ?? values[0]) * height);
         break;
       case "translateX":
-        _temp.translateX(values[0] * width);
+        output.translateX(values[0] * width);
         break;
       case "translateY":
-        _temp.translateY(values[0] * height);
+        output.translateY(values[0] * height);
         break;
       case "translateZ":
-        _temp.translateZ(values[0]);
+        output.translateZ(values[0]);
         break;
       case "translate3d":
-        _temp.translate3d(
+        output.translate3d(
           values[0] * width,
           (values[1] ?? values[0]) * height,
           values[2] ?? values[1] ?? values[0]
         );
         break;
       case "scale":
-        _temp.scale(values[0], values[1] ?? values[0]);
+        output.scale(values[0], values[1] ?? values[0]);
         break;
       case "scaleX":
-        _temp.scaleX(values[0]);
+        output.scaleX(values[0]);
         break;
       case "scaleY":
-        _temp.scaleY(values[0]);
+        output.scaleY(values[0]);
         break;
       case "scale3d":
-        _temp.scale3d(values[0], values[1] ?? values[0], values[2] ?? values[1] ?? values[0]);
+        output.scale3d(values[0], values[1] ?? values[0], values[2] ?? values[1] ?? values[0]);
         break;
       case "rotate":
-        _temp.rotate(values[0] * PI_2);
+        output.rotate(values[0] * PI_2);
         break;
       case "rotateX":
-        _temp.rotateX(values[0] * PI_2);
+        output.rotateX(values[0] * PI_2);
         break;
       case "rotateY":
-        _temp.rotateY(values[0] * PI_2);
+        output.rotateY(values[0] * PI_2);
         break;
       case "rotateZ":
-        _temp.rotateZ(values[0] * PI_2);
+        output.rotateZ(values[0] * PI_2);
         break;
       case "rotate3d":
-        _temp.rotate3d(
+        output.rotate3d(
           values[0] * PI_2,
           (values[1] ?? values[0]) * PI_2,
           (values[2] ?? values[1] ?? values[0]) * PI_2,
@@ -4442,22 +4387,20 @@ function parseCSSTransform(transform, width, height) {
         );
         break;
       case "skew":
-        _temp.skew(values[0], values[0] ?? values[1]);
+        output.skew(values[0], values[0] ?? values[1]);
         break;
       case "skewX":
-        _temp.skewX(values[0]);
+        output.skewX(values[0]);
         break;
       case "skewY":
-        _temp.skewY(values[0]);
+        output.skewY(values[0]);
         break;
       case "matrix":
-        _temp.set(values);
+        output.set(values);
         break;
     }
-    t2d.multiply(_temp);
   });
-  t2d.update();
-  return t2d;
+  return output;
 }
 
 function parseCSSTransformOrigin(transformOrigin) {
@@ -5817,6 +5760,22 @@ let Node = class extends CoreObject {
     const tree = this._tree;
     const canRender = this.canRender();
     const canProcess = this.canProcess();
+    const childrenInBefore = [];
+    const childrenInAfter = [];
+    for (let len = this._children.length, i = 0; i < len; i++) {
+      const child = this._children[i];
+      switch (child.processSortMode) {
+        case "default":
+          childrenInAfter.push(child);
+          break;
+        case "parent_before":
+          childrenInBefore.push(child);
+          break;
+      }
+    }
+    childrenInBefore.forEach((child) => {
+      child.emit("process", delta);
+    });
     if (canProcess) {
       tree?.emit("nodeProcessing", this);
       this.emit("processing", delta);
@@ -5839,9 +5798,9 @@ let Node = class extends CoreObject {
         this.removeChild(mask);
       }
     }
-    for (let len = this._children.length, i = 0; i < len; i++) {
-      this._children[i].emit("process", delta);
-    }
+    childrenInAfter.forEach((child) => {
+      child.emit("process", delta);
+    });
     if (canRender) {
       tree.renderStack.currentCall = oldRenderCall;
     }
@@ -6109,6 +6068,9 @@ __decorateClass$I([
 __decorateClass$I([
   property({ default: "inherit" })
 ], Node.prototype, "processMode", 2);
+__decorateClass$I([
+  property({ default: "default" })
+], Node.prototype, "processSortMode", 2);
 __decorateClass$I([
   property({ default: "inherit" })
 ], Node.prototype, "renderMode", 2);
@@ -8664,7 +8626,7 @@ let Node2D = class extends CanvasItem {
   rotation = 0;
   scale = new Vector2(1, 1);
   skew = new Vector2();
-  transform = new Transform2D(false);
+  transform = new Transform2D();
   globalPosition = new Vector2();
   globalRotation = 0;
   globalScale = new Vector2();
@@ -8676,7 +8638,7 @@ let Node2D = class extends CanvasItem {
     this.setProperties(properties).append(nodes);
   }
   _updateTransform() {
-    this.transform.identity().scale(this.scale.x, this.scale.y).skew(this.skew.x, this.skew.y).translate(this.position.x, this.position.y).rotate(this.rotation).update();
+    this.transform.identity().scale(this.scale.x, this.scale.y).skew(this.skew.x, this.skew.y).rotate(this.rotation).translate(this.position.x, this.position.y);
   }
   _updateGlobalTransform() {
     const parent = this.getParent();
@@ -8879,17 +8841,13 @@ let BaseElement2D = class extends Node2D {
     this.requestRedraw();
   }
   _updateTransform() {
-    super._updateTransform();
     const { width, height } = this.size;
-    const cssTransform = parseCSSTransform(this.style.transform, width, height);
-    cssTransform.multiply(this.transform, this.transform);
-    const t3dT2dArr = this.transform.toArray();
     const [originX, originY] = parseCSSTransformOrigin(this.style.transformOrigin);
     const offsetX = originX * width;
     const offsetY = originY * height;
-    t3dT2dArr[2] += t3dT2dArr[0] * -offsetX + t3dT2dArr[1] * -offsetY + offsetX;
-    t3dT2dArr[5] += t3dT2dArr[3] * -offsetX + t3dT2dArr[4] * -offsetY + offsetY;
-    this.transform.set(t3dT2dArr);
+    this.transform.identity().translate(-offsetX, -offsetY).scale(this.scale.x, this.scale.y).skew(this.skew.x, this.skew.y).rotate(this.rotation);
+    parseCSSTransform(this.style.transform, width, height, this.transform);
+    this.transform.translate(offsetX + this.position.x, offsetY + this.position.y);
   }
   _updateGlobalTransform() {
     super._updateGlobalTransform();
@@ -10170,19 +10128,14 @@ let Animation = class extends TimelineNode {
   _stoped = false;
   constructor(properties, children = []) {
     super();
-    this._process = this._process.bind(this);
     this.setProperties(properties).append(children);
   }
-  _treeEnter(tree) {
-    tree.timeline.on("updateCurrentTime", this._process);
+  _treeEnter(_tree) {
     this._updateCachedProps();
   }
-  _treeExit(oldTree) {
-    oldTree.timeline.on("updateCurrentTime", this._process);
+  _treeExit(_oldTree) {
     this.cancel();
   }
-  _onProcess() {
-  }
   _process() {
     if (this.canProcess()) {
       this.commitStyles();
@@ -10441,6 +10394,7 @@ Animation = __decorateClass$d([
   customNode("Animation", {
     renderMode: "disabled",
     processMode: "pausable",
+    processSortMode: "parent_before",
     duration: 2e3
   })
 ], Animation);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-canvas",
   "type": "module",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "packageManager": "pnpm@9.15.1",
   "description": "A JavaScript WebGL rendering engine.",
   "author": "wxm",