kiwiengine 0.0.1-alpha

package/src/asset/preload.ts

@@ -0,0 +1,76 @@
+import { SpritesheetData } from 'pixi.js';
+import { audioLoader } from './loaders/audio';
+import { fontFamilyLoader } from './loaders/font';
+import { getCachedId, spritesheetLoader } from './loaders/spritesheet';
+import { textureLoader } from './loaders/texture';
+
+type AssetSource = string | {
+  src: string;
+  atlas: SpritesheetData;
+};
+
+function isImage(path: string): boolean {
+  return path.endsWith('.png') ||
+    path.endsWith('.jpg') ||
+    path.endsWith('.jpeg') ||
+    path.endsWith('.gif') ||
+    path.endsWith('.webp');
+}
+
+function isAudio(path: string): boolean {
+  return path.endsWith('.mp3') ||
+    path.endsWith('.wav') ||
+    path.endsWith('.ogg');
+}
+
+function isFontFamily(fontFamily: string): boolean {
+  return !fontFamily.includes('.');
+}
+
+async function preload(assets: AssetSource[], progressCallback: (progress: number) => void) {
+  const total = assets.length;
+  let loaded = 0;
+
+  await Promise.all(assets.map(async (asset) => {
+    if (typeof asset === 'string') {
+      if (isImage(asset)) {
+        await textureLoader.load(asset);
+      } else if (isAudio(asset)) {
+        await audioLoader.load(asset);
+      } else if (isFontFamily(asset)) {
+        await fontFamilyLoader.load(asset);
+      } else {
+        console.error(`Unknown asset type: ${asset}`);
+      }
+    }
+    else {
+      const id = getCachedId(asset.src, asset.atlas);
+      await spritesheetLoader.load(id, asset.src, asset.atlas);
+    }
+
+    loaded++;
+    progressCallback?.(loaded / total);
+  }));
+
+  return () => {
+    assets.forEach((asset) => {
+      if (typeof asset === 'string') {
+        if (isImage(asset)) {
+          textureLoader.release(asset);
+        } else if (isAudio(asset)) {
+          audioLoader.release(asset);
+        } else if (isFontFamily(asset)) {
+          fontFamilyLoader.release(asset);
+        } else {
+          console.error(`Unknown asset type: ${asset}`);
+        }
+      }
+      else {
+        const id = getCachedId(asset.src, asset.atlas);
+        spritesheetLoader.release(id);
+      }
+    });
+  };
+}
+
+export { AssetSource, preload };

package/src/game-object/game-object-physics.ts

@@ -0,0 +1,191 @@
+import Matter, { IChamferableBodyDefinition } from 'matter-js';
+import { debugMode } from '../utils/debug';
+import { GameObject } from './game-object';
+import { localOffsetToWorld, worldToLocalWithNewWorld } from './transform';
+
+type BaseCollider = { x?: number; y?: number; };
+type RectangleCollider = BaseCollider & { type: 'rect'; width: number; height: number };
+type CircleCollider = BaseCollider & { type: 'circle'; radius: number };
+type VerticesCollider = BaseCollider & { type: 'vert'; vertices: { x: number; y: number }[] };
+export type Collider = RectangleCollider | CircleCollider | VerticesCollider;
+
+export class GameObjectPhysics {
+  #collider?: Collider;
+  #isStatic = false;
+  #isSensor = false;
+  #velocityX = 0;
+  #velocityY = 0;
+  #fixedRotation = false;
+
+  #go: GameObject;
+  #matterBody?: Matter.Body;
+
+  constructor(go: GameObject) {
+    this.#go = go;
+  }
+
+  #removeBody() {
+    const world = this.#go._getWorld();
+    if (!world || !this.#matterBody) return;
+    world._worldPhysics.removeBody(this.#matterBody);
+  }
+
+  #lastScaleX = 1;
+  #lastScaleY = 1;
+  #initialInertia?: number;
+
+  #createBody() {
+    const world = this.#go._getWorld();
+    if (!this.#collider || !world) return;
+
+    const wt = this.#go._wt;
+    const { x: ox, y: oy } = localOffsetToWorld(wt, this.#collider?.x ?? 0, this.#collider?.y ?? 0);
+    const x = wt.x.v + ox;
+    const y = wt.y.v + oy;
+
+    const bodyOpts: IChamferableBodyDefinition = {
+      angle: wt.rotation.v,
+      isStatic: this.#isStatic,
+      isSensor: this.#isSensor,
+      velocity: { x: this.#velocityX, y: this.#velocityY },
+    };
+
+    if (this.#collider.type === 'rect') this.#matterBody = Matter.Bodies.rectangle(x, y, this.#collider.width, this.#collider.height, bodyOpts);
+    else if (this.#collider.type === 'circle') this.#matterBody = Matter.Bodies.circle(x, y, this.#collider.radius, bodyOpts);
+    else if (this.#collider.type === 'vert') this.#matterBody = Matter.Bodies.fromVertices(x, y, [this.#collider.vertices], bodyOpts);
+    else throw new Error('Invalid collider type');
+
+    this.#matterBody.plugin.owner = this.#go;
+    this.#lastScaleX = wt.scaleX.v;
+    this.#lastScaleY = wt.scaleY.v;
+    Matter.Body.scale(this.#matterBody, wt.scaleX.v, wt.scaleY.v);
+
+    this.#initialInertia = this.#matterBody.inertia;
+    if (this.#fixedRotation) {
+      Matter.Body.setInertia(this.#matterBody, Infinity);
+      Matter.Body.setAngularVelocity(this.#matterBody, 0);
+    }
+
+    world._worldPhysics.addBody(this.#matterBody);
+    this.#setDebugRenderStyle();
+  }
+
+  applyChanges() {
+    if (this.#collider && !this.#matterBody) this.#createBody();
+    if (!this.#matterBody) return;
+
+    const wt = this.#go._wt;
+    const { x: ox, y: oy } = localOffsetToWorld(wt, this.#collider?.x ?? 0, this.#collider?.y ?? 0);
+
+    if (wt.x.dirty || wt.scaleX.dirty || wt.y.dirty || wt.scaleY.dirty) {
+      if ((wt.x.dirty || wt.scaleX.dirty) && (wt.y.dirty || wt.scaleY.dirty)) Matter.Body.setPosition(this.#matterBody, { x: wt.x.v + ox, y: wt.y.v + oy });
+      else if (wt.x.dirty || wt.scaleX.dirty) Matter.Body.setPosition(this.#matterBody, { x: wt.x.v + ox, y: this.#matterBody.position.y });
+      else if (wt.y.dirty || wt.scaleY.dirty) Matter.Body.setPosition(this.#matterBody, { x: this.#matterBody.position.x, y: wt.y.v + oy });
+    }
+    if (wt.scaleX.dirty || wt.scaleY.dirty) {
+      const scaleDiffX = wt.scaleX.v / this.#lastScaleX;
+      const scaleDiffY = wt.scaleY.v / this.#lastScaleY;
+      Matter.Body.scale(this.#matterBody, scaleDiffX, scaleDiffY);
+      this.#lastScaleX = wt.scaleX.v;
+      this.#lastScaleY = wt.scaleY.v;
+    }
+    if (wt.rotation.dirty) Matter.Body.setAngle(this.#matterBody, wt.rotation.v);
+
+    const lt = this.#go._lt;
+    if (!wt.x.dirty || !wt.y.dirty || !wt.rotation.dirty) {
+      const { x, y, rotation, newWorldX, newWorldY, newWorldRotation } =
+        worldToLocalWithNewWorld(
+          wt,
+          lt,
+          this.#matterBody.position.x - ox,
+          this.#matterBody.position.y - oy,
+          this.#matterBody.angle
+        );
+      if (!wt.x.dirty) { lt.x.v = x; wt.x.v = newWorldX; }
+      if (!wt.y.dirty) { lt.y.v = y; wt.y.v = newWorldY; }
+      if (!wt.rotation.dirty) { lt.rotation.v = rotation; wt.rotation.v = newWorldRotation; }
+    }
+  }
+
+  destroy() {
+    this.#removeBody();
+  }
+
+  get collider() { return this.#collider; }
+  set collider(value: Collider | undefined) {
+    this.#removeBody();
+    this.#collider = value;
+  }
+
+  get isStatic() {
+    if (this.#matterBody) return this.#matterBody.isStatic;
+    else return this.#isStatic;
+  }
+  set isStatic(value: boolean) {
+    this.#isStatic = value;
+    if (this.#matterBody) Matter.Body.setStatic(this.#matterBody, value);
+    this.#setDebugRenderStyle();
+  }
+
+  get isSensor() {
+    if (this.#matterBody) return this.#matterBody.isSensor;
+    else return this.#isSensor;
+  }
+  set isSensor(value: boolean) {
+    this.#isSensor = value;
+    if (this.#matterBody) this.#matterBody.isSensor = value;
+    this.#setDebugRenderStyle();
+  }
+
+  get velocityX() {
+    if (this.#matterBody) return this.#matterBody.velocity.x;
+    else return this.#velocityX;
+  }
+  set velocityX(value: number) {
+    this.#velocityX = value;
+    if (this.#matterBody) Matter.Body.setVelocity(this.#matterBody, { x: value, y: this.#velocityY });
+  }
+
+  get velocityY() {
+    if (this.#matterBody) return this.#matterBody.velocity.y;
+    else return this.#velocityY;
+  }
+  set velocityY(value: number) {
+    this.#velocityY = value;
+    if (this.#matterBody) Matter.Body.setVelocity(this.#matterBody, { x: this.#velocityX, y: value });
+  }
+
+  get fixedRotation() { return this.#fixedRotation; }
+  set fixedRotation(value: boolean) {
+    this.#fixedRotation = value;
+    if (this.#matterBody) {
+      if (value) {
+        Matter.Body.setInertia(this.#matterBody, Infinity);
+        Matter.Body.setAngularVelocity(this.#matterBody, 0);
+      } else {
+        Matter.Body.setInertia(this.#matterBody, this.#initialInertia!);
+        Matter.Body.setAngularVelocity(this.#matterBody, 0);
+      }
+    }
+  }
+
+  #setDebugRenderStyle() {
+    if (!debugMode || !this.#matterBody) return;
+
+    if (this.#isSensor) {
+      this.#matterBody.render.fillStyle = 'rgba(255,255,0,0.1)';
+      this.#matterBody.render.strokeStyle = 'rgba(255,255,0,0.25)';
+      this.#matterBody.render.lineWidth = 1;
+    }
+    else if (this.#isStatic) {
+      this.#matterBody.render.fillStyle = 'rgba(255,0,0,0.1)';
+      this.#matterBody.render.strokeStyle = 'rgba(255,0,0,0.25)';
+      this.#matterBody.render.lineWidth = 1;
+    }
+    else {
+      this.#matterBody.render.fillStyle = 'rgba(0,255,0,0.1)';
+      this.#matterBody.render.strokeStyle = 'rgba(0,255,0,0.25)';
+      this.#matterBody.render.lineWidth = 1;
+    }
+  }
+}

package/src/game-object/game-object-rendering.ts

@@ -0,0 +1,27 @@
+import { Container } from 'pixi.js';
+import { LocalTransform } from './transform';
+
+export class GameObjectRendering {
+  _container = new Container({ sortableChildren: true });
+  #yBasedDrawOrder = false;
+
+  addChild(child: GameObjectRendering) { this._container.addChild(child._container); }
+  removeChild(child: GameObjectRendering) { this._container.removeChild(child._container); }
+  destroy() { this._container.destroy({ children: true }); }
+
+  applyChanges(lt: LocalTransform) {
+    if (lt.x.dirty) this._container.x = lt.x.v;
+    if (lt.y.dirty) { this._container.y = lt.y.v; if (this.#yBasedDrawOrder) this.drawOrder = lt.y.v; }
+    if (lt.pivotX.dirty) this._container.pivot.x = lt.pivotX.v;
+    if (lt.pivotY.dirty) this._container.pivot.y = lt.pivotY.v;
+    if (lt.scaleX.dirty) this._container.scale.x = lt.scaleX.v;
+    if (lt.scaleY.dirty) this._container.scale.y = lt.scaleY.v;
+    if (lt.rotation.dirty) this._container.rotation = lt.rotation.v;
+    if (lt.alpha.dirty) this._container.alpha = lt.alpha.v;
+  }
+
+  get drawOrder() { return this._container.zIndex; }
+  set drawOrder(v: number) { this._container.zIndex = v; }
+  get yBasedDrawOrder() { return this.#yBasedDrawOrder; }
+  set yBasedDrawOrder(v: boolean) { this.#yBasedDrawOrder = v; if (v) this.drawOrder = this._container.y; }
+}

package/src/game-object/game-object.ts

@@ -0,0 +1,190 @@
+import { EventEmitter, EventMap } from '@webtaku/event-emitter';
+import { Container, Sprite } from 'pixi.js';
+import { textureLoader } from '../asset/loaders/texture';
+import { World } from '../world/world';
+import { Collider, GameObjectPhysics } from './game-object-physics';
+import { GameObjectRendering } from './game-object-rendering';
+import { LocalTransform, WorldTransform } from './transform';
+
+export class GameObject<E extends EventMap = EventMap> extends EventEmitter<E & {
+  update: (dt: number) => void
+}> {
+  _lt = new LocalTransform();
+  _wt = new WorldTransform();
+
+  _rendering = new GameObjectRendering();
+  #physics = new GameObjectPhysics(this);
+
+  #world?: World;
+  #parent?: GameObject;
+  #children: GameObject[] = [];
+
+  data: Record<string, any> = {};
+
+  protected _setWorld(world: World) {
+    this.#world = world;
+    for (const child of this.#children) {
+      child._setWorld(world);
+    }
+  }
+  _getWorld() { return this.#world; }
+
+  add(...children: GameObject[]) {
+    for (const child of children) {
+      if (child.#parent) {
+        const idx = child.#parent.#children.indexOf(child);
+        if (idx !== -1) child.#parent.#children.splice(idx, 1);
+        child.#parent._rendering.removeChild(child._rendering);
+      }
+      if (this.#world) child._setWorld(this.#world);
+      child.#parent = this;
+
+      this.#children.push(child);
+      this._rendering.addChild(child._rendering);
+    }
+  }
+
+  remove() {
+    if (this.#parent) {
+      const idx = this.#parent.#children.indexOf(this);
+      if (idx !== -1) this.#parent.#children.splice(idx, 1);
+      this.#parent = undefined;
+    }
+
+    for (const child of this.#children) {
+      child.#parent = undefined;
+      child.remove();
+    }
+    this.#children.length = 0;
+
+    this._rendering.destroy();
+    this.#physics.destroy();
+  }
+
+  protected update(dt: number): void { }
+
+  protected _afterRender() { }
+  _engineUpdate(dt: number, pt: WorldTransform) {
+    this.update(dt);
+
+    this._wt.update(pt, this._lt);
+    this.#physics.applyChanges();
+    this._rendering.applyChanges(this._lt);
+    this._afterRender();
+    this._lt.markClean();
+
+    (this as any).emit('update', dt);
+
+    for (const child of this.#children) {
+      child._engineUpdate(dt, this._wt);
+    }
+    this._wt.markClean();
+  }
+
+  constructor(opts?: GameObjectOptions) {
+    super();
+    if (opts) {
+      if (opts.x !== undefined) this.x = opts.x;
+      if (opts.y !== undefined) this.y = opts.y;
+      if (opts.pivotX !== undefined) this.pivotX = opts.pivotX;
+      if (opts.pivotY !== undefined) this.pivotY = opts.pivotY;
+      if (opts.scale !== undefined) this.scale = opts.scale;
+      if (opts.scaleX !== undefined) this.scaleX = opts.scaleX;
+      if (opts.scaleY !== undefined) this.scaleY = opts.scaleY;
+      if (opts.rotation !== undefined) this.rotation = opts.rotation;
+      if (opts.alpha !== undefined) this.alpha = opts.alpha;
+
+      if (opts.drawOrder !== undefined) this.drawOrder = opts.drawOrder;
+      if (opts.yBasedDrawOrder !== undefined) this.yBasedDrawOrder = opts.yBasedDrawOrder;
+
+      if (opts.collider !== undefined) this.collider = opts.collider;
+      if (opts.isStatic !== undefined) this.isStatic = opts.isStatic;
+      if (opts.isSensor !== undefined) this.isSensor = opts.isSensor;
+      if (opts.velocityX !== undefined) this.velocityX = opts.velocityX;
+      if (opts.velocityY !== undefined) this.velocityY = opts.velocityY;
+      if (opts.fixedRotation !== undefined) this.fixedRotation = opts.fixedRotation;
+
+      if (opts.image !== undefined) this.image = opts.image;
+    }
+  }
+
+  get x() { return this._lt.x.v; }
+  set x(v: number) { this._lt.x.v = v; }
+  get y() { return this._lt.y.v; }
+  set y(v: number) { this._lt.y.v = v; }
+  get pivotX() { return this._lt.pivotX.v; }
+  set pivotX(v: number) { this._lt.pivotX.v = v; }
+  get pivotY() { return this._lt.pivotY.v; }
+  set pivotY(v: number) { this._lt.pivotY.v = v; }
+  get scale() { return this._lt.scaleX.v; }
+  set scale(v: number) { this._lt.scaleX.v = v; this._lt.scaleY.v = v; }
+  get scaleX() { return this._lt.scaleX.v; }
+  set scaleX(v: number) { this._lt.scaleX.v = v; }
+  get scaleY() { return this._lt.scaleY.v; }
+  set scaleY(v: number) { this._lt.scaleY.v = v; }
+  get rotation() { return this._lt.rotation.v; }
+  set rotation(v: number) { this._lt.rotation.v = v; }
+  get alpha() { return this._lt.alpha.v; }
+  set alpha(v: number) { this._lt.alpha.v = v; }
+
+  get drawOrder() { return this._rendering.drawOrder; }
+  set drawOrder(v: number) { this._rendering.drawOrder = v; }
+  get yBasedDrawOrder() { return this._rendering.yBasedDrawOrder; }
+  set yBasedDrawOrder(v: boolean) { this._rendering.yBasedDrawOrder = v; }
+
+  get collider() { return this.#physics.collider; }
+  set collider(v: Collider | undefined) { this.#physics.collider = v; }
+  get isStatic() { return this.#physics.isStatic; }
+  set isStatic(v: boolean) { this.#physics.isStatic = v; }
+  get isSensor() { return this.#physics.isSensor; }
+  set isSensor(v: boolean) { this.#physics.isSensor = v; }
+  get velocityX() { return this.#physics.velocityX; }
+  set velocityX(v: number) { this.#physics.velocityX = v; }
+  get velocityY() { return this.#physics.velocityY; }
+  set velocityY(v: number) { this.#physics.velocityY = v; }
+  get fixedRotation() { return this.#physics.fixedRotation; }
+  set fixedRotation(v: boolean) { this.#physics.fixedRotation = v; }
+
+  _addPixiChild(child: Container) { this._rendering._container.addChild(child); }
+
+  #image?: string;
+  get image() { return this.#image; }
+  set image(value: string | undefined) {
+    if (value) {
+      if (!textureLoader.checkLoaded(value)) {
+        console.info(`Image not preloaded. Loading now: ${value}`);
+      }
+      textureLoader.load(value).then((texture) => {
+        if (texture) this._addPixiChild(new Sprite({
+          texture,
+          anchor: { x: 0.5, y: 0.5 },
+          zIndex: -999999,
+        }));
+      });
+    }
+  }
+}
+
+export type GameObjectOptions = {
+  x?: number;
+  y?: number;
+  pivotX?: number;
+  pivotY?: number;
+  scale?: number;
+  scaleX?: number;
+  scaleY?: number;
+  rotation?: number;
+  alpha?: number;
+
+  drawOrder?: number;
+  yBasedDrawOrder?: boolean;
+
+  collider?: Collider;
+  isStatic?: boolean;
+  isSensor?: boolean;
+  velocityX?: number;
+  velocityY?: number;
+  fixedRotation?: boolean;
+
+  image?: string;
+};

package/src/game-object/transform.ts

@@ -0,0 +1,164 @@
+class DirtyNumber {
+  #v: number;
+  #dirty: boolean;
+
+  constructor(v: number) {
+    this.#v = v;
+    this.#dirty = false;
+  }
+
+  get dirty(): boolean {
+    return this.#dirty;
+  }
+
+  get v(): number {
+    return this.#v;
+  }
+
+  set v(v: number) {
+    if (this.#v !== v) this.#dirty = true;
+    this.#v = v;
+  }
+
+  markClean() {
+    this.#dirty = false;
+  }
+}
+
+export class LocalTransform {
+  x = new DirtyNumber(0);
+  y = new DirtyNumber(0);
+  pivotX = new DirtyNumber(0);
+  pivotY = new DirtyNumber(0);
+  scaleX = new DirtyNumber(1);
+  scaleY = new DirtyNumber(1);
+  rotation = new DirtyNumber(0);
+  alpha = new DirtyNumber(1);
+
+  markClean() {
+    this.x.markClean();
+    this.y.markClean();
+    this.pivotX.markClean();
+    this.pivotY.markClean();
+    this.scaleX.markClean();
+    this.scaleY.markClean();
+    this.rotation.markClean();
+    this.alpha.markClean();
+  }
+}
+
+export class WorldTransform {
+  x = new DirtyNumber(0);
+  y = new DirtyNumber(0);
+  scaleX = new DirtyNumber(1);
+  scaleY = new DirtyNumber(1);
+  rotation = new DirtyNumber(0);
+  alpha = new DirtyNumber(1);
+
+  update(parent: WorldTransform, local: LocalTransform) {
+    const rx = local.x.v * parent.scaleX.v;
+    const ry = local.y.v * parent.scaleY.v;
+    const pCos = Math.cos(parent.rotation.v);
+    const pSin = Math.sin(parent.rotation.v);
+
+    this.scaleX.v = parent.scaleX.v * local.scaleX.v;
+    this.scaleY.v = parent.scaleY.v * local.scaleY.v;
+
+    const pivotX = local.pivotX.v * this.scaleX.v;
+    const pivotY = local.pivotY.v * this.scaleY.v;
+    const cos = Math.cos(local.rotation.v);
+    const sin = Math.sin(local.rotation.v);
+
+    this.x.v = parent.x.v + (rx * pCos - ry * pSin) - (pivotX * cos - pivotY * sin);
+    this.y.v = parent.y.v + (rx * pSin + ry * pCos) - (pivotX * sin + pivotY * cos);
+
+    this.rotation.v = parent.rotation.v + local.rotation.v;
+    this.alpha.v = parent.alpha.v * local.alpha.v;
+  }
+
+  markClean() {
+    this.x.markClean();
+    this.y.markClean();
+    this.scaleX.markClean();
+    this.scaleY.markClean();
+    this.rotation.markClean();
+    this.alpha.markClean();
+  }
+}
+
+export function localOffsetToWorld(
+  world: WorldTransform,
+  ox: number,
+  oy: number
+): { x: number; y: number } {
+  const cos = Math.cos(world.rotation.v);
+  const sin = Math.sin(world.rotation.v);
+  const sx = ox * world.scaleX.v;
+  const sy = oy * world.scaleY.v;
+
+  const x = sx * cos - sy * sin;
+  const y = sx * sin + sy * cos;
+  return { x, y };
+}
+
+export function worldToLocalWithNewWorld(
+  world: WorldTransform,
+  local: LocalTransform,
+  targetWorldX: number,
+  targetWorldY: number,
+  targetWorldRotation: number
+): {
+  x: number;
+  y: number;
+  rotation: number;
+  newWorldX: number;
+  newWorldY: number;
+  newWorldRotation: number;
+} {
+  const invLocalScaleX = local.scaleX.v !== 0 ? 1 / local.scaleX.v : 0;
+  const invLocalScaleY = local.scaleY.v !== 0 ? 1 / local.scaleY.v : 0;
+
+  const parentScaleX = world.scaleX.v * invLocalScaleX;
+  const parentScaleY = world.scaleY.v * invLocalScaleY;
+  const parentRot = world.rotation.v - local.rotation.v;
+
+  const pCos = Math.cos(parentRot);
+  const pSin = Math.sin(parentRot);
+
+  const cosOld = Math.cos(local.rotation.v);
+  const sinOld = Math.sin(local.rotation.v);
+
+  const pivotX = local.pivotX.v * world.scaleX.v;
+  const pivotY = local.pivotY.v * world.scaleY.v;
+
+  const rx0 = local.x.v * parentScaleX;
+  const ry0 = local.y.v * parentScaleY;
+
+  const parentX = world.x.v - (rx0 * pCos - ry0 * pSin) + (pivotX * cosOld - pivotY * sinOld);
+  const parentY = world.y.v - (rx0 * pSin + ry0 * pCos) + (pivotX * sinOld + pivotY * cosOld);
+
+  const rotation = targetWorldRotation - parentRot;
+
+  const cosNew = Math.cos(rotation);
+  const sinNew = Math.sin(rotation);
+
+  const tx = (targetWorldX - parentX) + (pivotX * cosNew - pivotY * sinNew);
+  const ty = (targetWorldY - parentY) + (pivotX * sinNew + pivotY * cosNew);
+
+  const rx = tx * pCos + ty * pSin;
+  const ry = -tx * pSin + ty * pCos;
+
+  const invParentScaleX = parentScaleX !== 0 ? 1 / parentScaleX : 0;
+  const invParentScaleY = parentScaleY !== 0 ? 1 / parentScaleY : 0;
+
+  const x = rx * invParentScaleX;
+  const y = ry * invParentScaleY;
+
+  const newRx = x * parentScaleX;
+  const newRy = y * parentScaleY;
+  const newWorldX = parentX + (newRx * pCos - newRy * pSin) - (pivotX * cosNew - pivotY * sinNew);
+  const newWorldY = parentY + (newRx * pSin + newRy * pCos) - (pivotX * sinNew + pivotY * cosNew);
+  const newWorldRotation = parentRot + rotation;
+
+  return { x, y, rotation, newWorldX, newWorldY, newWorldRotation };
+}