@quinninc/pixi-transformer 0.0.4 → 0.0.6

package/dist/graphics.d.ts

@@ -0,0 +1,52 @@
+type Point = {
+    x: number;
+    y: number;
+};
+import { Pixi } from "./pixi";
+/**
+ *
+ * @param origin source from where distance will be calculated
+ * @param p1 point 1 - positive direction is towards this point
+ * @param p2 point 2
+ * @returns 1 for same direction, -1 if the angle is more than 90 degrees
+ */
+export declare function getDirection(origin: Point, p1: Point, p2: Point): -1 | 1;
+/**
+ *
+ * @param point point to rotate
+ * @param origin origin point
+ * @param rotation angle in radians
+ * @returns rotated point
+ */
+export declare function rotatePoint(point: Point, origin: Point, rotation: number): Point;
+/**
+ * Calculate the euclidean distance between two points.
+ */
+export declare function calcDistance(p1: Point, p2: Point): number;
+export declare function calcAngleDegrees(x: number, y: number): number;
+export declare function calcAngleRadians(x: number, y: number): number;
+/**
+ *
+ * @param p point to snap to edges and corners
+ * @param snapDistance max distance from edges and corners to trigger snap
+ * @param param2 bounds of the rectangle (0,0), (0,width), (width,height), (0, height)
+ */
+export declare function snapToEdgesAndCorners({ point, anchor, dim: { width, height }, snapDistance, }: {
+    point: Point;
+    snapDistance?: number;
+    dim: {
+        width: number;
+        height: number;
+    };
+    anchor: Point;
+}): Point;
+export declare function applyTransform(container: Pixi.Container, matrix: Pixi.Matrix): void;
+export declare function parseTransformationMatrix(matrix: Pixi.Matrix): {
+    tx: number;
+    ty: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+};
+export declare function getChildTransformRelativeToParent(child: Pixi.Container, parent: Pixi.Container): Pixi.Matrix;
+export {};

package/dist/graphics.js

@@ -0,0 +1,115 @@
+import { Pixi } from "./pixi";
+/**
+ *
+ * @param origin source from where distance will be calculated
+ * @param p1 point 1 - positive direction is towards this point
+ * @param p2 point 2
+ * @returns 1 for same direction, -1 if the angle is more than 90 degrees
+ */
+export function getDirection(origin, p1, p2) {
+    const v1 = { x: p1.x - origin.x, y: p1.y - origin.y };
+    const v2 = { x: p2.x - origin.x, y: p2.y - origin.y };
+    const dot = v1.x * v2.x + v1.y * v2.y;
+    return dot >= 0 ? 1 : -1;
+}
+/**
+ *
+ * @param point point to rotate
+ * @param origin origin point
+ * @param rotation angle in radians
+ * @returns rotated point
+ */
+export function rotatePoint(point, origin, rotation) {
+    // Translate point to origin
+    const translatedX = point.x - origin.x;
+    const translatedY = point.y - origin.y;
+    // Apply rotation
+    const rotatedX = translatedX * Math.cos(rotation) - translatedY * Math.sin(rotation);
+    const rotatedY = translatedX * Math.sin(rotation) + translatedY * Math.cos(rotation);
+    // Translate point back
+    const x = rotatedX + origin.x;
+    const y = rotatedY + origin.y;
+    return { x, y };
+}
+/**
+ * Calculate the euclidean distance between two points.
+ */
+export function calcDistance(p1, p2) {
+    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+export function calcAngleDegrees(x, y) {
+    return (calcAngleRadians(x, y) * 180) / Math.PI;
+}
+export function calcAngleRadians(x, y) {
+    return Math.atan2(y, x);
+}
+/**
+ *
+ * @param p point to snap to edges and corners
+ * @param snapDistance max distance from edges and corners to trigger snap
+ * @param param2 bounds of the rectangle (0,0), (0,width), (width,height), (0, height)
+ */
+export function snapToEdgesAndCorners({ point, anchor, dim: { width, height }, snapDistance = 10, }) {
+    const top = -height * anchor.y;
+    const bottom = height + top;
+    const left = -width * anchor.x;
+    const right = width + left;
+    // console.log(top, left, bottom, right);
+    // console.log(point);
+    const snapPoints = [
+        // corners
+        { x: left, y: top }, // top-left
+        { x: right, y: top }, // top-right
+        { x: right, y: bottom }, // bottom-right
+        { x: left, y: bottom }, // bottom-left
+        // center
+        { x: (left + right) / 2, y: (top + bottom) / 2 }, // center
+        // edges
+        { x: (left + right) / 2, y: top }, // top-edge
+        { x: (left + right) / 2, y: bottom }, // bottom-edge
+        { x: left, y: (top + bottom) / 2 }, // left-edge
+        { x: right, y: (top + bottom) / 2 }, // right-edge
+    ];
+    let minDistance = Number.MAX_VALUE;
+    let snappedPoint = point;
+    for (const snapPoint of snapPoints) {
+        const distance = calcDistance(point, snapPoint);
+        if (distance < snapDistance && distance < minDistance) {
+            minDistance = distance;
+            snappedPoint = snapPoint;
+        }
+    }
+    return snappedPoint;
+}
+export function applyTransform(container, matrix) {
+    // Extract translation
+    const { tx, ty, scaleX, scaleY, rotation } = parseTransformationMatrix(matrix);
+    3;
+    // Apply the extracted transformations to the container
+    container.position.set(tx, ty);
+    container.scale.set(scaleX, scaleY);
+    container.rotation = rotation;
+}
+export function parseTransformationMatrix(matrix) {
+    const tx = matrix.tx;
+    const ty = matrix.ty;
+    // Extract scale
+    const scaleX = Math.sqrt(matrix.a * matrix.a + matrix.b * matrix.b);
+    const scaleY = Math.sqrt(matrix.c * matrix.c + matrix.d * matrix.d);
+    // Extract rotation (in radians)
+    const rotation = Math.atan2(matrix.b, matrix.a);
+    return { tx, ty, scaleX, scaleY, rotation };
+}
+export function getChildTransformRelativeToParent(child, parent) {
+    // Get the worldTransform of the parent and child
+    const parentWorldTransform = parent.worldTransform;
+    const childWorldTransform = child.worldTransform;
+    // Invert the parent's worldTransform
+    const inverseParentWorldTransform = new Pixi.Matrix();
+    parentWorldTransform.copyTo(inverseParentWorldTransform).invert();
+    // Multiply the child's worldTransform by the inverse of the parent's worldTransform
+    const relativeTransform = new Pixi.Matrix();
+    childWorldTransform.copyTo(relativeTransform);
+    relativeTransform.append(inverseParentWorldTransform);
+    return relativeTransform;
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { Transformer } from "./FreeTransformTool";
+export { Transformer } from "./Transformer";
 export declare function hello(): void;

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Transformer } from "./FreeTransformTool";
+export { Transformer } from "./Transformer";
 export function hello() {
     console.log("🧩 Hello, from @quinninc/pixi-transformer!");
 }

package/dist/vector.d.ts

@@ -1,7 +1,4 @@
-type Point = {
-    x: number;
-    y: number;
-};
+import { Point } from "pixi.js";
 /**
  *
  * @param origin source from where distance will be calculated
@@ -24,19 +21,3 @@ export declare function rotatePoint(point: Point, origin: Point, rotation: numbe
 export declare function calcDistance(p1: Point, p2: Point): number;
 export declare function calcAngleDegrees(x: number, y: number): number;
 export declare function calcAngleRadians(x: number, y: number): number;
-/**
- *
- * @param p point to snap to edges and corners
- * @param snapDistance max distance from edges and corners to trigger snap
- * @param param2 bounds of the rectangle (0,0), (0,width), (width,height), (0, height)
- */
-export declare function snapToEdgesAndCorners({ point, anchor, dim: { width, height }, snapDistance, }: {
-    point: Point;
-    snapDistance?: number;
-    dim: {
-        width: number;
-        height: number;
-    };
-    anchor: Point;
-}): Point;
-export {};

package/dist/vector.js

@@ -1,3 +1,4 @@
+import { Point } from "pixi.js";
 /**
  *
  * @param origin source from where distance will be calculated
@@ -6,8 +7,8 @@
  * @returns 1 for same direction, -1 if the angle is more than 90 degrees
  */
 export function getDirection(origin, p1, p2) {
-    const v1 = { x: p1.x - origin.x, y: p1.y - origin.y };
-    const v2 = { x: p2.x - origin.x, y: p2.y - origin.y };
+    const v1 = new Point(p1.x - origin.x, p1.y - origin.y);
+    const v2 = new Point(p2.x - origin.x, p2.y - origin.y);
     const dot = v1.x * v2.x + v1.y * v2.y;
     return dot >= 0 ? 1 : -1;
 }
@@ -26,9 +27,9 @@ export function rotatePoint(point, origin, rotation) {
     const rotatedX = translatedX * Math.cos(rotation) - translatedY * Math.sin(rotation);
     const rotatedY = translatedX * Math.sin(rotation) + translatedY * Math.cos(rotation);
     // Translate point back
-    const x = rotatedX + origin.x;
-    const y = rotatedY + origin.y;
-    return { x, y };
+    const finalX = rotatedX + origin.x;
+    const finalY = rotatedY + origin.y;
+    return new Point(finalX, finalY);
 }
 /**
  * Calculate the euclidean distance between two points.
@@ -42,41 +43,3 @@ export function calcAngleDegrees(x, y) {
 export function calcAngleRadians(x, y) {
     return Math.atan2(y, x);
 }
-/**
- *
- * @param p point to snap to edges and corners
- * @param snapDistance max distance from edges and corners to trigger snap
- * @param param2 bounds of the rectangle (0,0), (0,width), (width,height), (0, height)
- */
-export function snapToEdgesAndCorners({ point, anchor, dim: { width, height }, snapDistance = 10, }) {
-    const top = -height * anchor.y;
-    const bottom = height + top;
-    const left = -width * anchor.x;
-    const right = width + left;
-    // console.log(top, left, bottom, right);
-    // console.log(point);
-    const snapPoints = [
-        // corners
-        { x: left, y: top }, // top-left
-        { x: right, y: top }, // top-right
-        { x: right, y: bottom }, // bottom-right
-        { x: left, y: bottom }, // bottom-left
-        // center
-        { x: (left + right) / 2, y: (top + bottom) / 2 }, // center
-        // edges
-        { x: (left + right) / 2, y: top }, // top-edge
-        { x: (left + right) / 2, y: bottom }, // bottom-edge
-        { x: left, y: (top + bottom) / 2 }, // left-edge
-        { x: right, y: (top + bottom) / 2 }, // right-edge
-    ];
-    let minDistance = Number.MAX_VALUE;
-    let snappedPoint = point;
-    for (const snapPoint of snapPoints) {
-        const distance = calcDistance(point, snapPoint);
-        if (distance < snapDistance && distance < minDistance) {
-            minDistance = distance;
-            snappedPoint = snapPoint;
-        }
-    }
-    return snappedPoint;
-}

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "@quinninc/pixi-transformer",
-  "private": false,
-  "version": "0.0.4",
-  "repository": {
-    "url": "https://github.com/Quinn-Care-Private-Limited/pixi-transformer"
-  },
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "package.json",
-    "README.md"
-  ],
-  "keywords": [
-    "pixi.js",
-    "transformer",
-    "pixi.js v8"
-  ],
-  "author": {
-    "name": "Rohit Kaushal",
-    "url": "https://github.com/RohitKaushal7"
-  },
-  "license": "MIT",
-  "scripts": {
-    "dev": "tsc -w",
-    "build": "tsc",
-    "deploy": "npm run build && npm version patch && npm publish --access public"
-  },
-  "devDependencies": {
-    "typescript": "^5.2.2",
-    "vite": "^5.3.1",
-    "pixi.js": "^8.2.1"
-  },
-  "dependencies": {},
-  "peerDependencies": {
-    "pixi.js": "^8.2.1"
-  }
-}
+{
+  "name": "@quinninc/pixi-transformer",
+  "private": false,
+  "version": "0.0.6",
+  "repository": {
+    "url": "https://github.com/Quinn-Care-Private-Limited/pixi-transformer"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "pixi.js",
+    "transformer",
+    "pixi.js v8"
+  ],
+  "author": {
+    "name": "Rohit Kaushal",
+    "url": "https://github.com/RohitKaushal7"
+  },
+  "license": "MIT",
+  "scripts": {
+    "dev": "tsc -w",
+    "build": "tsc",
+    "deploy": "npm run build && npm version patch && npm publish --access public"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.2",
+    "vite": "^5.3.1",
+    "pixi.js": "^8.2.1"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "pixi.js": "^8.2.1"
+  }
+}