@flighthq/node 0.2.0 → 0.2.1-next.410.a23f189

package/src/transform2d.test.ts

@@ -1,5 +1,13 @@
 import { getEntityRuntime } from '@flighthq/entity';
-import { cloneMatrix, createMatrix, createVector2, equalsMatrix, multiplyMatrix, setMatrix } from '@flighthq/geometry';
+import {
+  cloneMatrix,
+  createMatrix,
+  createTransform2D,
+  createVector2,
+  equalsMatrix,
+  multiplyMatrix,
+  setMatrix,
+} from '@flighthq/geometry';
 import { addNodeChild, createNode } from '@flighthq/node';
 import type { HasTransform2D, HasTransform2DRuntime, Matrix, Node, NodeRuntime } from '@flighthq/types';
 
@@ -8,10 +16,13 @@ import { invalidateNodeLocalTransform } from './revision';
 import {
   convertNodeVector2GlobalToLocal,
   convertNodeVector2LocalToGlobal,
-  ensureNodeLocalTransformMatrix,
-  ensureNodeWorldTransformMatrix,
-  getNodeLocalTransformMatrix,
-  getNodeWorldTransformMatrix,
+  ensureNodeLocalMatrix,
+  ensureNodeWorldMatrix,
+  getNodeLocalMatrix,
+  getNodeTransform2D,
+  getNodeWorldMatrix,
+  setNodeLocalMatrix,
+  setNodeTransform2D,
 } from './transform2d';
 
 function createTestNode(): TestNode {
@@ -139,48 +150,48 @@ describe('convertNodeVector2LocalToGlobal', () => {
   });
 });
 
-describe('ensureNodeLocalTransformMatrix', () => {
+describe('ensureNodeLocalMatrix', () => {
   it('computes local transform the first time', () => {
     const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
-    expect(runtime.localTransform2D).toBeNull();
-    ensureNodeLocalTransformMatrix(node);
-    expect(runtime.localTransform2D).not.toBeNull();
+    expect(runtime.localMatrix).toBeNull();
+    ensureNodeLocalMatrix(node);
+    expect(runtime.localMatrix).not.toBeNull();
   });
 
   it('recomputes if the local transform ID has changed', () => {
     const runtime = getEntityRuntime(node) as NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
-    ensureNodeLocalTransformMatrix(node);
-    const cache = cloneAndInvalidateMatrix(runtime.localTransform2D);
+    ensureNodeLocalMatrix(node);
+    const cache = cloneAndInvalidateMatrix(runtime.localMatrix);
     runtime.localTransformId++;
-    ensureNodeLocalTransformMatrix(node);
-    expect(equalsMatrix(runtime.localTransform2D, cache)).toBe(true);
+    ensureNodeLocalMatrix(node);
+    expect(equalsMatrix(runtime.localMatrix, cache)).toBe(true);
   });
 });
 
-describe('ensureNodeWorldTransformMatrix', () => {
+describe('ensureNodeWorldMatrix', () => {
   it('computes world transform the first time', () => {
     const runtime = getEntityRuntime(node) as NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
-    expect(runtime.worldTransform2D).toBeNull();
-    ensureNodeWorldTransformMatrix(node);
-    expect(runtime.worldTransform2D).not.toBeNull();
+    expect(runtime.worldMatrix).toBeNull();
+    ensureNodeWorldMatrix(node);
+    expect(runtime.worldMatrix).not.toBeNull();
   });
 
   it('computes world transform for a parent for the first time', () => {
     const parent = createTestNode();
     addNodeChild(parent, node);
     const parentState = getEntityRuntime(node) as HasTransform2DRuntime;
-    expect(parentState.worldTransform2D).toBeNull();
-    ensureNodeWorldTransformMatrix(node);
-    expect(parentState.worldTransform2D).not.toBeNull();
+    expect(parentState.worldMatrix).toBeNull();
+    ensureNodeWorldMatrix(node);
+    expect(parentState.worldMatrix).not.toBeNull();
   });
 
   it('recomputes if the local transform ID has changed', () => {
     const runtime = getEntityRuntime(node) as NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
-    ensureNodeWorldTransformMatrix(node);
-    const cache = cloneAndInvalidateMatrix(runtime.worldTransform2D);
+    ensureNodeWorldMatrix(node);
+    const cache = cloneAndInvalidateMatrix(runtime.worldMatrix);
     runtime.localTransformId++;
-    ensureNodeWorldTransformMatrix(node);
-    expect(equalsMatrix(runtime.worldTransform2D, cache)).toBe(true);
+    ensureNodeWorldMatrix(node);
+    expect(equalsMatrix(runtime.worldMatrix, cache)).toBe(true);
   });
 
   it('recomputes if the parent transform ID has changed', () => {
@@ -188,25 +199,25 @@ describe('ensureNodeWorldTransformMatrix', () => {
     addNodeChild(parent, node);
     const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
     const parentState = getEntityRuntime(parent) as NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
-    ensureNodeWorldTransformMatrix(node);
-    const cache = cloneAndInvalidateMatrix(runtime.worldTransform2D);
+    ensureNodeWorldMatrix(node);
+    const cache = cloneAndInvalidateMatrix(runtime.worldMatrix);
     parentState.worldTransformId++;
-    ensureNodeWorldTransformMatrix(node);
-    expect(equalsMatrix(runtime.worldTransform2D, cache)).toBe(true);
+    ensureNodeWorldMatrix(node);
+    expect(equalsMatrix(runtime.worldMatrix, cache)).toBe(true);
   });
 });
 
-describe('getNodeLocalTransformMatrix', () => {
+describe('getNodeLocalMatrix', () => {
   it('ensures local transform', () => {
     const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
-    expect(runtime.localTransform2D).toBeNull();
-    getNodeLocalTransformMatrix(node);
-    expect(runtime.localTransform2D).not.toBeNull();
+    expect(runtime.localMatrix).toBeNull();
+    getNodeLocalMatrix(node);
+    expect(runtime.localMatrix).not.toBeNull();
   });
 
   it('returns local transform', () => {
-    const transform = getNodeLocalTransformMatrix(node);
-    expect(transform).equals((getEntityRuntime(node) as HasTransform2DRuntime).localTransform2D);
+    const transform = getNodeLocalMatrix(node);
+    expect(transform).equals((getEntityRuntime(node) as HasTransform2DRuntime).localMatrix);
   });
 
   it('offsets translation by the pivot so the pivot point lands at (x, y)', () => {
@@ -214,7 +225,7 @@ describe('getNodeLocalTransformMatrix', () => {
     node.y = 50;
     node.pivotX = 10;
     node.pivotY = 20;
-    const transform = getNodeLocalTransformMatrix(node);
+    const transform = getNodeLocalMatrix(node);
     expect(transform.tx).toBeCloseTo(90); // 100 - 1 * 10
     expect(transform.ty).toBeCloseTo(30); // 50 - 1 * 20
   });
@@ -224,23 +235,74 @@ describe('getNodeLocalTransformMatrix', () => {
     node.scaleY = 3;
     node.pivotX = 10;
     node.pivotY = 10;
-    const transform = getNodeLocalTransformMatrix(node);
+    const transform = getNodeLocalMatrix(node);
     expect(transform.tx).toBeCloseTo(-20); // 0 - 2 * 10
     expect(transform.ty).toBeCloseTo(-30); // 0 - 3 * 10
   });
 });
 
-describe('getNodeWorldTransformMatrix', () => {
+describe('getNodeTransform2D', () => {
+  it('reads the node fields into a carrier', () => {
+    node.x = 3;
+    node.y = 4;
+    node.rotation = 30;
+    node.scaleX = 2;
+    node.skewY = 5;
+    const out = createTransform2D();
+    getNodeTransform2D(out, node);
+    expect(out).toMatchObject({ rotation: 30, scaleX: 2, skewY: 5, x: 3, y: 4 });
+  });
+});
+
+describe('getNodeWorldMatrix', () => {
   it('ensures world transform', () => {
     const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
-    expect(runtime.worldTransform2D).toBeNull();
-    getNodeWorldTransformMatrix(node);
-    expect(runtime.worldTransform2D).not.toBeNull();
+    expect(runtime.worldMatrix).toBeNull();
+    getNodeWorldMatrix(node);
+    expect(runtime.worldMatrix).not.toBeNull();
   });
 
   it('returns local transform', () => {
-    const transform = getNodeWorldTransformMatrix(node);
-    expect(transform).equals((getEntityRuntime(node) as HasTransform2DRuntime).worldTransform2D);
+    const transform = getNodeWorldMatrix(node);
+    expect(transform).equals((getEntityRuntime(node) as HasTransform2DRuntime).worldMatrix);
+  });
+});
+
+describe('setNodeLocalMatrix', () => {
+  it('round-trips the effective transform through the local matrix', () => {
+    setNodeLocalMatrix(node, createMatrix(2, 0, 0, 3, 10, 20));
+    expect(node.scaleX).toBeCloseTo(2);
+    expect(node.scaleY).toBeCloseTo(3);
+    expect(node.x).toBeCloseTo(10);
+    expect(node.y).toBeCloseTo(20);
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(2);
+    expect(m.d).toBeCloseTo(3);
+    expect(m.tx).toBeCloseTo(10);
+    expect(m.ty).toBeCloseTo(20);
+  });
+
+  it('resets pivot and absorbs its offset into translation', () => {
+    node.pivotX = 5;
+    node.pivotY = 5;
+    invalidateNodeLocalTransform(node);
+    setNodeLocalMatrix(node, createMatrix(1, 0, 0, 1, 7, 8));
+    expect(node.pivotX).toBe(0);
+    expect(node.pivotY).toBe(0);
+    expect(node.x).toBeCloseTo(7);
+    expect(node.y).toBeCloseTo(8);
+  });
+});
+
+describe('setNodeTransform2D', () => {
+  it('copies carrier fields into the node and rebuilds the matrix', () => {
+    setNodeTransform2D(node, createTransform2D(10, 20, 0, 2, 4));
+    expect(node).toMatchObject({ scaleX: 2, scaleY: 4, x: 10, y: 20 });
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(2);
+    expect(m.d).toBeCloseTo(4);
+    expect(m.tx).toBeCloseTo(10);
+    expect(m.ty).toBeCloseTo(20);
   });
 });
 
@@ -262,8 +324,8 @@ describe('skew', () => {
     withoutSkew.scaleY = 3;
     invalidateNodeLocalTransform(withoutSkew);
 
-    const mSkew = getNodeLocalTransformMatrix(withSkew);
-    const mNoSkew = getNodeLocalTransformMatrix(withoutSkew);
+    const mSkew = getNodeLocalMatrix(withSkew);
+    const mNoSkew = getNodeLocalMatrix(withoutSkew);
     expect(mSkew.a).toBeCloseTo(mNoSkew.a);
     expect(mSkew.b).toBeCloseTo(mNoSkew.b);
     expect(mSkew.c).toBeCloseTo(mNoSkew.c);
@@ -280,7 +342,7 @@ describe('skew', () => {
     node.rotation = 0;
     invalidateNodeLocalTransform(node);
 
-    const m = getNodeLocalTransformMatrix(node);
+    const m = getNodeLocalMatrix(node);
     const radX = 45 * DEG_TO_RAD;
     expect(m.a).toBeCloseTo(1);
     expect(m.b).toBeCloseTo(0);
@@ -296,7 +358,7 @@ describe('skew', () => {
     node.rotation = 0;
     invalidateNodeLocalTransform(node);
 
-    const m = getNodeLocalTransformMatrix(node);
+    const m = getNodeLocalMatrix(node);
     const radY = 30 * DEG_TO_RAD;
     expect(m.a).toBeCloseTo(Math.cos(radY));
     expect(m.b).toBeCloseTo(Math.sin(radY));
@@ -312,7 +374,7 @@ describe('skew', () => {
     node.scaleY = 1;
     invalidateNodeLocalTransform(node);
 
-    const m = getNodeLocalTransformMatrix(node);
+    const m = getNodeLocalMatrix(node);
     const radY = (45 + 20) * DEG_TO_RAD;
     const radX = (45 + 15) * DEG_TO_RAD;
     expect(m.a).toBeCloseTo(Math.cos(radY));
@@ -337,12 +399,12 @@ describe('skew', () => {
 
     addNodeChild(parent, child);
 
-    const parentLocal = getNodeLocalTransformMatrix(parent);
-    const childLocal = getNodeLocalTransformMatrix(child);
+    const parentLocal = getNodeLocalMatrix(parent);
+    const childLocal = getNodeLocalMatrix(child);
     const expected = createMatrix();
     multiplyMatrix(expected, parentLocal, childLocal);
 
-    const world = getNodeWorldTransformMatrix(child);
+    const world = getNodeWorldMatrix(child);
     expect(world.a).toBeCloseTo(expected.a);
     expect(world.b).toBeCloseTo(expected.b);
     expect(world.c).toBeCloseTo(expected.c);
@@ -363,7 +425,7 @@ describe('skew', () => {
     node.rotation = 0;
     invalidateNodeLocalTransform(node);
 
-    const m = getNodeLocalTransformMatrix(node);
+    const m = getNodeLocalMatrix(node);
     const radY = 45 * DEG_TO_RAD;
     const radX = 30 * DEG_TO_RAD;
     const a = Math.cos(radY) * 2;