@safe-engine/pixi 8.4.6 → 8.5.1

package/dist/spine/lib/assets/atlasLoader.js

@@ -0,0 +1,122 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority, path, Resolver, TextureSource } from 'pixi.js';
+import { SpineTexture } from '../SpineTexture.js';
+import { TextureAtlas } from '@esotericsoftware/spine-core';
+const spineTextureAtlasLoader = {
+    extension: ExtensionType.Asset,
+    resolver: {
+        test: (value) => checkExtension(value, ".atlas"),
+        parse: (value) => {
+            var _a, _b, _c;
+            const split = value.split('.');
+            return {
+                resolution: parseFloat((_c = (_b = (_a = Resolver.RETINA_PREFIX) === null || _a === void 0 ? void 0 : _a.exec(value)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : '1'),
+                format: split[split.length - 2],
+                src: value,
+            };
+        },
+    },
+    loader: {
+        extension: {
+            type: ExtensionType.LoadParser,
+            priority: LoaderParserPriority.Normal,
+            name: 'spineTextureAtlasLoader',
+        },
+        test(url) {
+            return checkExtension(url, '.atlas');
+        },
+        load(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield DOMAdapter.get().fetch(url);
+                const txt = yield response.text();
+                return txt;
+            });
+        },
+        testParse(asset, options) {
+            const isExtensionRight = checkExtension(options.src, '.atlas');
+            const isString = typeof asset === 'string';
+            return Promise.resolve(isExtensionRight && isString);
+        },
+        unload(atlas) {
+            atlas.dispose();
+        },
+        parse(asset, options, loader) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const metadata = options.data || {};
+                let basePath = path.dirname(options.src);
+                if (basePath && basePath.lastIndexOf('/') !== basePath.length - 1) {
+                    basePath += '/';
+                }
+                // Retval is going to be a texture atlas. However we need to wait for it's callback to resolve this promise.
+                const retval = new TextureAtlas(asset);
+                // If the user gave me only one texture, that one is assumed to be the "first" texture in the atlas
+                if (metadata.images instanceof TextureSource || typeof metadata.images === 'string') {
+                    const pixiTexture = metadata.images;
+                    metadata.images = {};
+                    metadata.images[retval.pages[0].name] = pixiTexture;
+                }
+                // we will wait for all promises for the textures at the same time at the end.
+                const textureLoadingPromises = [];
+                // fill the pages
+                for (const page of retval.pages) {
+                    const pageName = page.name;
+                    const providedPage = (metadata === null || metadata === void 0 ? void 0 : metadata.images) ? metadata.images[pageName] : undefined;
+                    if (providedPage instanceof TextureSource) {
+                        page.setTexture(SpineTexture.from(providedPage));
+                    }
+                    else {
+                        // eslint-disable-next-line max-len
+                        const url = providedPage !== null && providedPage !== void 0 ? providedPage : path.normalize([...basePath.split(path.sep), pageName].join(path.sep));
+                        const assetsToLoadIn = {
+                            src: url,
+                            data: Object.assign(Object.assign({}, metadata.imageMetadata), { alphaMode: page.pma ? 'premultiplied-alpha' : 'premultiply-alpha-on-upload' })
+                        };
+                        const pixiPromise = loader.load(assetsToLoadIn).then((texture) => {
+                            page.setTexture(SpineTexture.from(texture.source));
+                        });
+                        textureLoadingPromises.push(pixiPromise);
+                    }
+                }
+                yield Promise.all(textureLoadingPromises);
+                return retval;
+            });
+        },
+    },
+};
+extensions.add(spineTextureAtlasLoader);

package/{src/spine/lib/darktint/DarkTintShader.ts → dist/spine/lib/assets/skeletonLoader.d.ts}

@@ -1,4 +1,4 @@
-/******************************************************************************
+/** ****************************************************************************
  * Spine Runtimes License Agreement
  * Last updated July 28, 2023. Replaces all prior versions.
  *
@@ -26,49 +26,5 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
  * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-
-import {
-	colorBit,
-	colorBitGl,
-	compileHighShaderGlProgram,
-	compileHighShaderGpuProgram,
-	generateTextureBatchBit,
-	generateTextureBatchBitGl,
-	getBatchSamplersUniformGroup,
-	roundPixelsBit,
-	roundPixelsBitGl,
-	Shader
-} from 'pixi.js';
-import { darkTintBit, darkTintBitGl } from './darkTintBit.js';
-
-export class DarkTintShader extends Shader {
-	constructor (maxTextures: number) {
-		const glProgram = compileHighShaderGlProgram({
-			name: 'dark-tint-batch',
-			bits: [
-				colorBitGl,
-				darkTintBitGl,
-				generateTextureBatchBitGl(maxTextures),
-				roundPixelsBitGl,
-			]
-		});
-
-		const gpuProgram = compileHighShaderGpuProgram({
-			name: 'dark-tint-batch',
-			bits: [
-				colorBit,
-				darkTintBit,
-				generateTextureBatchBit(maxTextures),
-				roundPixelsBit,
-			]
-		});
-
-		super({
-			glProgram,
-			gpuProgram,
-			resources: {
-				batchSamplers: getBatchSamplersUniformGroup(maxTextures),
-			}
-		});
-	}
-}
+export {};
+//# sourceMappingURL=skeletonLoader.d.ts.map

package/dist/spine/lib/assets/skeletonLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonLoader.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/assets/skeletonLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E"}

package/dist/spine/lib/assets/skeletonLoader.js

@@ -0,0 +1,70 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority } from 'pixi.js';
+function isJson(resource) {
+    return Object.prototype.hasOwnProperty.call(resource, 'bones');
+}
+function isBuffer(resource) {
+    return resource instanceof Uint8Array;
+}
+const spineLoaderExtension = {
+    extension: ExtensionType.Asset,
+    loader: {
+        extension: {
+            type: ExtensionType.LoadParser,
+            priority: LoaderParserPriority.Normal,
+            name: 'spineSkeletonLoader',
+        },
+        test(url) {
+            return checkExtension(url, '.skel');
+        },
+        load(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield DOMAdapter.get().fetch(url);
+                const buffer = new Uint8Array(yield response.arrayBuffer());
+                return buffer;
+            });
+        },
+        testParse(asset, options) {
+            const isJsonSpineModel = checkExtension(options.src, '.json') && isJson(asset);
+            const isBinarySpineModel = checkExtension(options.src, '.skel') && isBuffer(asset);
+            return Promise.resolve(isJsonSpineModel || isBinarySpineModel);
+        },
+    },
+};
+extensions.add(spineLoaderExtension);

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@safe-engine/pixi",
-  "version": "8.4.6",
+  "version": "8.5.1",
   "description": "safex pixi plugin",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "@types"
+  ],
   "scripts": {
     "export": "safex build -p ios",
     "start": "parcel src/index.html -p 8080",
     "dev": "parcel src/index.html -p 8080 --no-cache",
-    "build": "tsc & copyfiles -f ./src/@types/* ./dist/@types",
+    "build": "tsc",
     "fix": "eslint ./src --ext .ts --fix"
   },
   "keywords": [],

package/.github/workflows/npm-publish.yml

@@ -1,35 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Publish NPM Package
-
-on:
-  release:
-    types: [created]
-  workflow_dispatch: # Allows you to run this workflow manually
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm run build
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm run build
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/dist/@types/safex.d.ts

@@ -1,15 +0,0 @@
-import { NodeComp } from "..";
-
-interface BaseComponentProps {
-  $ref?: object;
-  $refNode?: NodeComp<any>
-  $push?: object[];
-  node?: Partial<NodeComp>;
-}
-
-interface NodeCompProps {
-  nodeName?: string
-}
-
-interface LoadingBarProps {
-}

package/src/@types/index.d.ts

@@ -1,2 +0,0 @@
-type Float = number
-type Integer = number

package/src/app.ts

@@ -1,91 +0,0 @@
-import { actionManager } from 'pixi-action-ease'
-import { Application, AssetsClass, Renderer } from 'pixi.js'
-
-import { GameWorld } from './base'
-import { CollideSystem } from './collider'
-import { GUISystem } from './gui/GUISystem'
-import { NoRenderSystem } from './norender/NoRenderSystem'
-import { RenderSystem } from './render/RenderSystem'
-
-export async function startGame(
-  defaultFont,
-  designedResolution = { width: 720, height: 1280 },
-  assetManager: AssetsClass,
-  id = 'gameCanvas',
-): Promise<Application<Renderer>> {
-  const app = new Application()
-  await app.init({
-    antialias: true,
-    resolution: window.devicePixelRatio,
-    resizeTo: window,
-    eventFeatures: {
-      move: true,
-      /** disables the global move events which can be very expensive in large scenes */
-      globalMove: false,
-      click: true,
-      wheel: false,
-    },
-    canvas: document.getElementById(id) as HTMLCanvasElement,
-  })
-  // GameWorld.Instance.setup(NodeComp, app.stage)
-  Object.assign(app.canvas.style, {
-    width: `${window.innerWidth}px`,
-    height: `${window.innerHeight}px`,
-    overflow: 'visible',
-  })
-  const { width, height } = designedResolution
-  app.renderer.resize(width, height)
-  // app.stage.position.y = app.renderer.height / app.renderer.resolution
-  // app.stage.scale.y = -1
-  GameWorld.Instance.app = app
-  GameWorld.Instance.assetManager = assetManager
-  initWorld(defaultFont)
-  startGameLoop(GameWorld.Instance)
-  return app
-}
-
-function startGameLoop(world: GameWorld) {
-  // Listen for frame updates
-  world.app.ticker.add(() => {
-    const dt = world.app.ticker.deltaMS * 0.001
-    actionManager.update(dt)
-    world.update(dt)
-  })
-  // app.ticker.speed = 0.5
-}
-
-// const systemsList = [RenderSystem, GUISystem, SpineSystem, DragonBonesSystem, CollideSystem, NoRenderSystem]
-// export function startGameSystems(list = []) {
-//   const world = GameWorld.Instance
-//   systemsList.forEach(system => {
-//     world.systems.add(system)
-//     world.systems.configureOnce(system)
-//   })
-//   world.listUpdate.push(CollideSystem)
-//   // world.listUpdate.push(PhysicsSystem)
-//   list.forEach(system => {
-//     world.systems.add(system)
-//     world.systems.configureOnce(system)
-//     world.listUpdate.push(system)
-//   })
-//   startGameLoop(world)
-//   // console.log('startGameLoop', world.listUpdate)
-// }
-
-function initWorld(defaultFont?: string) {
-  const world = GameWorld.Instance
-  world.systems.add(RenderSystem)
-  world.systems.add(CollideSystem)
-  world.systems.add(GUISystem)
-  world.systems.add(NoRenderSystem)
-  world.listUpdate.push(CollideSystem)
-  world.systems.configureOnce(RenderSystem)
-  world.systems.configureOnce(CollideSystem)
-  world.systems.configureOnce(GUISystem)
-  world.systems.configureOnce(NoRenderSystem)
-  if (defaultFont) {
-    const guiSystem = world.systems.get(GUISystem)
-    guiSystem.defaultFont = defaultFont
-  }
-  // startGameLoop(world, app)
-}

package/src/base/EnhancedComponent.ts

@@ -1,38 +0,0 @@
-import { Constructor } from 'entityx-ts'
-import { BaseComponentProps } from '..'
-import { NodeComp } from '../components/NodeComp'
-
-export class EnhancedComponent<Props = {}, N extends NodeComp<any> = NodeComp<any>> {
-  props: Props = {} as any
-  enabled = true
-  constructor(data?: BaseComponentProps<EnhancedComponent> & Props) {
-    this.init(data)
-  }
-  init(data?: Props) {
-    if (data) {
-      // console.log('constructor', this.constructor.name, data)
-      Object.keys(data).forEach((key) => {
-        this.props[key] = data[key]
-      })
-    }
-  }
-  node: N
-
-  addComponent<T extends EnhancedComponent>(instance): T {
-    return this.node.addComponent(instance)
-  }
-  getComponent<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponent(component)
-  }
-  getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[] {
-    return this.node.getComponentsInChildren(component)
-  }
-  getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T {
-    return this.node.getComponentInChildren(component)
-  }
-  isEqual(other: EnhancedComponent) {
-    return this.node.entity.id === other.node.entity.id
-  }
-}
-
-export type ComponentType = EnhancedComponent | NodeComp

package/src/base/gworld.ts

@@ -1,20 +0,0 @@
-import { Constructor, System, World } from 'entityx-ts'
-import { Application, AssetsClass } from 'pixi.js'
-
-export class GameWorld extends World {
-  listUpdate: (System | Constructor<System>)[] = []
-  app: Application
-  assetManager: AssetsClass
-  update(dt: number) {
-    this.listUpdate.forEach((system: any) => {
-      this.systems.update(system, dt)
-    })
-  }
-
-  private static _instance: GameWorld
-
-  public static get Instance() {
-    // Do you need arguments? Make it a regular static method instead.
-    return this._instance || (this._instance = new this())
-  }
-}

package/src/base/index.ts

@@ -1,14 +0,0 @@
-import { NodeComp } from '../components/NodeComp'
-
-export * from './EnhancedComponent'
-export * from './gworld'
-export * from './utils'
-
-export interface BaseComponentProps<T> {
-  $ref?: T
-  $push?: T[]
-  $refNode?: NodeComp
-  $pushNode?: NodeComp[]
-  node?: Partial<NodeComp>
-  // [$key: `$${string}`]: string
-}

package/src/base/utils.ts

@@ -1,23 +0,0 @@
-import { Constructor } from 'entityx-ts'
-
-import { GameWorld } from '..'
-import { ComponentX, NoRenderComponentX } from '../components/BaseComponent'
-
-export type GetProps<T> = T extends ComponentX<infer P> ? P : T extends NoRenderComponentX<infer Q> ? Q : never
-
-export function instantiate<T extends ComponentX>(ComponentType: Constructor<T>, data?: GetProps<T>): T {
-  const instance = new ComponentType()
-  instance.init(data)
-  // console.log(ComponentType.name, data, instance)
-  if (!instance.render) {
-    return instance
-  }
-  return instance.render()
-}
-
-export function loadScene<T extends ComponentX>(ComponentType: Constructor<T>) {
-  const world = GameWorld.Instance
-  world.entities.reset()
-  const instance = new ComponentType()
-  instance.render()
-}

package/src/box2d-wasm/ContactListener.ts

@@ -1,66 +0,0 @@
-import { NodeComp } from "..";
-import { ColliderPhysics } from "./PhysicsComponent";
-type Meta = { [key: number]: NodeComp }
-export const makeContactListener = (world: Box2D.b2World, metadata: Meta, box2D: typeof Box2D) => {
-  const { JSContactListener, getPointer, NULL } = box2D
-  function getContactById(contact: number) {
-    for (let contactList = world.GetContactList(); getPointer(contactList) !== getPointer(NULL); contactList = contactList.GetNext()) {
-      if (getPointer(contactList) === contact) {
-        console.log('contactBegin', contact, getPointer(contactList), getPointer(NULL));
-        return contactList
-      }
-    }
-  }
-  const listener = Object.assign(new JSContactListener(), {
-    BeginContact(contact: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = metadata[getPointer(contact.GetFixtureB().GetBody())]
-      // world.addPostStepCallback(() => {
-      //   // log('addPostStepCallback');
-      //   listRemoveShape.forEach((s) => world.removeShape(s))
-      //   listRemoveBody.forEach((b) => world.removeBody(b))
-      //   listRemoveBody = []
-      //   listRemoveShape = []
-      // })
-      const phys1 = ett1.getComponent(ColliderPhysics)
-      const phys2 = ett2.getComponent(ColliderPhysics)
-      if (phys1 && phys2) {
-        if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionEnter')) {
-          phys1.props.onCollisionEnter(phys2)
-        }
-        if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionEnter')) {
-          phys2.props.onCollisionEnter(phys1)
-        }
-      }
-    },
-    EndContact(contact: Box2D.b2Contact | number): void {
-      if (typeof contact === 'number') {
-        contact = getContactById(contact)
-      }
-      const ett1: NodeComp = metadata[getPointer(contact.GetFixtureA().GetBody())]
-      const ett2: NodeComp = metadata[getPointer(contact.GetFixtureB().GetBody())]
-      // const event1 = ett1.getComponent(NodeComp)
-      const phys1 = ett1.getComponent(ColliderPhysics)
-      const phys2 = ett2.getComponent(ColliderPhysics)
-      // const event2 = ett2.getComponent(NodeComp)
-      if (phys1 && phys2) {
-        if (Object.prototype.hasOwnProperty.call(phys1, 'onCollisionExit')) {
-          phys1.props.onCollisionExit(phys2)
-        }
-        if (Object.prototype.hasOwnProperty.call(phys2, 'onCollisionExit')) {
-          phys2.props.onCollisionExit(phys1)
-        }
-      }
-    },
-    PreSolve(contact: Box2D.b2Contact | number, oldManifold: Box2D.b2Manifold | number): void {
-      console.log('collisionSeparate');
-    },
-    PostSolve(contact: Box2D.b2Contact | number, impulse: Box2D.b2ContactImpulse | number): void {
-      console.log('collisionPost');
-    }
-  });
-  return listener
-}

package/src/box2d-wasm/PhysicsComponent.ts

@@ -1,83 +0,0 @@
-import { BodyType, Vec2 } from 'planck'
-import { NoRenderComponentX } from '..'
-import { PhysicsSprite } from './PhysicsSprite'
-
-interface RigidBodyProps {
-  type?: BodyType
-  density?: Float
-  restitution?: Float
-  friction?: Float
-  gravityScale?: Float
-}
-
-export class RigidBody extends NoRenderComponentX<RigidBodyProps> {
-  body: Box2D.b2Body
-  // set linearVelocity(vel: Vec2) {
-  //   if (!this.node) {
-  //     return
-  //   }
-  //   const physics = this.node.instance
-  //   if (physics instanceof Sprite) {
-  //     physics.getBody().setVel(vel)
-  //   }
-  // }
-
-  // get linearVelocity() {
-  //   if (!this.node) {
-  //     return Vec2.ZERO
-  //   }
-  //   const physics = this.node.instance
-  //   const vel = (physics as Sprite).getBody().getVel()
-  //   return v2(vel)
-  // }
-}
-
-interface PhysicsMaterialProps {
-  friction?: number
-  restitution?: number
-  density?: number
-}
-export class PhysicsMaterial extends NoRenderComponentX<PhysicsMaterialProps> {
-
-}
-
-interface ColliderPhysicsProps {
-  tag?: number
-  group?: number
-  offset?: Vec2
-  onCollisionEnter?: (other: ColliderPhysics) => void
-  onCollisionExit?: (other: ColliderPhysics) => void
-  onCollisionStay?: (other: ColliderPhysics) => void
-}
-
-export class ColliderPhysics<T extends ColliderPhysicsProps = ColliderPhysicsProps> extends NoRenderComponentX<T, PhysicsSprite['node']> {
-  enabled = true
-  instance: PhysicsSprite
-}
-
-interface BoxColliderPhysicsProps extends ColliderPhysicsProps {
-  width: number
-  height: number
-}
-export class BoxColliderPhysics extends ColliderPhysics<BoxColliderPhysicsProps> {
-
-  // set onCollisionEnter(val) {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   phys1._onCollisionEnter = val
-  // }
-
-  // get onCollisionEnter() {
-  //   const phys1 = this.getComponent(ColliderPhysics)
-  //   return phys1._onCollisionEnter
-  // }
-}
-interface CircleColliderPhysicsProps extends ColliderPhysicsProps {
-  radius: number
-}
-export class CircleColliderPhysics extends ColliderPhysics<CircleColliderPhysicsProps> {
-}
-interface PolygonColliderPhysicsProps extends ColliderPhysicsProps {
-  points: Array<Vec2>
-}
-export class PolygonColliderPhysics extends ColliderPhysics<PolygonColliderPhysicsProps> {
-}