kiwiengine 0.0.1-alpha → 0.5.3

package/src/asset/loaders/loader.ts

@@ -1,39 +1,43 @@
-abstract class Loader<T> {
-  protected loadedAssets: Map<string, T> = new Map();
-  protected loadingPromises: Map<string, Promise<T | undefined>> = new Map();
+export abstract class Loader<T> {
+  protected cachedAssets = new Map<string, T>()
+  protected loadingPromises = new Map<string, Promise<T | undefined>>()
 
-  #refCount: Map<string, number> = new Map();
-  #incRefCount(id: string) { this.#refCount.set(id, (this.#refCount.get(id) || 0) + 1); }
+  #refCount = new Map<string, number>()
+  #incRefCount(id: string) { this.#refCount.set(id, (this.#refCount.get(id) || 0) + 1) }
 
-  protected hasActiveRef(id: string) { return this.#refCount.get(id)! > 0; }
-  protected abstract _load(id: string, ...args: any[]): Promise<T | undefined>;
-  protected _dispose(id: string, asset: T): void { /* override to clean up */ }
+  protected hasActiveRef(id: string) { return this.#refCount.get(id)! > 0 }
+  protected abstract doLoad(id: string, ...args: any[]): Promise<T | undefined>
+  protected cleanup(id: string, asset: T): void { /* override to clean up */ }
 
-  checkLoaded(id: string) {
-    return this.loadedAssets.has(id);
+  checkCached(id: string) {
+    return this.cachedAssets.has(id)
+  }
+
+  getCached(id: string) {
+    if (!this.checkCached(id)) throw new Error(`Asset not found: ${id}`)
+    this.#incRefCount(id)
+    return this.cachedAssets.get(id)
   }
 
   async load(id: string, ...args: any[]) {
-    this.#incRefCount(id);
-    if (this.checkLoaded(id)) return this.loadedAssets.get(id);
-    if (this.loadingPromises.has(id)) return await this.loadingPromises.get(id);
-    return await this._load(id, ...args);
+    this.#incRefCount(id)
+    if (this.checkCached(id)) return this.cachedAssets.get(id)
+    if (this.loadingPromises.has(id)) return await this.loadingPromises.get(id)
+    return await this.doLoad(id, ...args)
   }
 
   release(id: string) {
-    const refCount = this.#refCount.get(id);
-    if (refCount === undefined) throw new Error(`Asset not found: ${id}`);
+    const refCount = this.#refCount.get(id)
+    if (refCount === undefined) throw new Error(`Asset not found: ${id}`)
     if (refCount === 1) {
-      this.#refCount.delete(id);
-      const asset = this.loadedAssets.get(id);
+      this.#refCount.delete(id)
+      const asset = this.cachedAssets.get(id)
       if (asset) {
-        this._dispose(id, asset);
-        this.loadedAssets.delete(id);
+        this.cleanup(id, asset)
+        this.cachedAssets.delete(id)
       }
     } else {
-      this.#refCount.set(id, refCount - 1);
+      this.#refCount.set(id, refCount - 1)
     }
   }
 }
-
-export { Loader };

package/src/asset/loaders/spritesheet.ts

@@ -1,67 +1,78 @@
-import { Spritesheet, SpritesheetData } from 'pixi.js';
-import { Loader } from './loader';
-import { textureLoader } from './texture';
+import { Dict, Spritesheet, SpritesheetFrameData } from 'pixi.js'
+import { Atlas } from '../../types/atlas'
+import { Loader } from './loader'
+import { textureLoader } from './texture'
 
-const atlasIdCache = new WeakMap<object, Map<string, string>>();
-let idCounter = 0;
+const atlasIdCache = new WeakMap<Atlas, Map<string, string>>()
+let idCounter = 0
 
-function getCachedId(src: string, atlas: object): string {
-  let innerMap = atlasIdCache.get(atlas);
+export function getCachedAtlasId(src: string, atlas: Atlas): string {
+  let innerMap = atlasIdCache.get(atlas)
   if (!innerMap) {
-    innerMap = new Map<string, string>();
-    atlasIdCache.set(atlas, innerMap);
+    innerMap = new Map<string, string>()
+    atlasIdCache.set(atlas, innerMap)
   }
 
   if (!innerMap.has(src)) {
-    innerMap.set(src, `${src}#${idCounter++}`);
+    innerMap.set(src, `${src}#${idCounter++}`)
   }
 
-  return innerMap.get(src)!;
+  return innerMap.get(src)!
 }
 
 class SpritesheetLoader extends Loader<Spritesheet> {
-  #idToSrc: Map<string, string> = new Map();
+  #idToSrc = new Map<string, string>();
 
-  protected override async _load(id: string, src: string, atlas: SpritesheetData) {
-    this.#idToSrc.set(id, src);
+  protected override async doLoad(id: string, src: string, atlas: Atlas) {
+    this.#idToSrc.set(id, src)
 
     const loadingPromise = (async () => {
-      const texture = await textureLoader.load(src);
+      const texture = await textureLoader.load(src)
       if (!texture) {
-        console.error(`Failed to load texture: ${src}`);
-        return;
+        console.error(`Failed to load texture: ${src}`)
+        return
       }
 
-      const spritesheet = new Spritesheet(texture, atlas);
-      await spritesheet.parse();
+      const frames: Dict<SpritesheetFrameData> = {}
+      for (const [key, value] of Object.entries(atlas.frames)) {
+        frames[key] = { frame: value }
+      }
+      const animations: Dict<string[]> = {}
+      for (const [key, value] of Object.entries(atlas.animations)) {
+        animations[key] = value.frames
+      }
+      const spritesheet = new Spritesheet(texture, { frames, meta: { scale: 1 }, animations })
+      await spritesheet.parse()
 
-      this.loadingPromises.delete(id);
+      this.loadingPromises.delete(id)
 
       if (this.hasActiveRef(id)) {
-        if (this.loadedAssets.has(id)) {
-          textureLoader.release(src);
-          console.error(`Spritesheet already exists: ${src}`);
+        if (this.cachedAssets.has(id)) {
+          textureLoader.release(src)
+          console.error(`Spritesheet already exists: ${src}`)
         } else {
-          this.loadedAssets.set(id, spritesheet);
-          return spritesheet;
+          this.cachedAssets.set(id, spritesheet)
+          return spritesheet
         }
       } else {
-        textureLoader.release(src);
+        textureLoader.release(src)
       }
-    })();
+    })()
 
-    this.loadingPromises.set(id, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(id, loadingPromise)
+    return await loadingPromise
   }
 
-  protected override _dispose(id: string, spritesheet: Spritesheet) {
-    spritesheet.destroy();
+  protected override cleanup(id: string, spritesheet: Spritesheet) {
+    spritesheet.destroy()
 
-    const src = this.#idToSrc.get(id);
-    if (src) textureLoader.release(src);
+    const src = this.#idToSrc.get(id)
+    if (src) textureLoader.release(src)
   }
-}
 
-const spritesheetLoader = new SpritesheetLoader();
+  override async load(id: string, src: string, atlas: Atlas) {
+    return await super.load(id, src, atlas)
+  }
+}
 
-export { getCachedId, spritesheetLoader };
+export const spritesheetLoader = new SpritesheetLoader()

package/src/asset/loaders/text.ts

@@ -1,31 +1,35 @@
-import { Loader } from './loader';
+import { Loader } from './loader'
 
 class TextLoader extends Loader<string> {
-  protected override async _load(src: string) {
+  protected override async doLoad(src: string) {
     const loadingPromise = (async () => {
-      const response = await fetch(src);
+      const response = await fetch(src)
       if (!response.ok) {
-        console.error(`Failed to load text: ${src}`);
-        return;
+        console.error(`Failed to load text: ${src}`)
+        return
       }
 
-      const text = await response.text();
+      const text = await response.text()
 
-      this.loadingPromises.delete(src);
+      this.loadingPromises.delete(src)
 
       if (this.hasActiveRef(src)) {
-        if (this.loadedAssets.has(src)) {
-          console.error(`Text already exists: ${src}`);
+        if (this.cachedAssets.has(src)) {
+          console.error(`Text already exists: ${src}`)
         } else {
-          this.loadedAssets.set(src, text);
-          return text;
+          this.cachedAssets.set(src, text)
+          return text
         }
       }
-    })();
+    })()
 
-    this.loadingPromises.set(src, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
+  }
+
+  override async load(src: string) {
+    return await super.load(src)
   }
 }
 
-export const textLoader = new TextLoader();
+export const textLoader = new TextLoader()

package/src/asset/loaders/texture.ts

@@ -1,46 +1,39 @@
-import { Texture } from 'pixi.js';
-import { Loader } from './loader';
+import { Texture } from 'pixi.js'
+import { Loader } from './loader'
 
 class TextureLoader extends Loader<Texture> {
-  protected override async _load(src: string) {
-    const loadingPromise = new Promise<Texture | undefined>((resolve) => {
-      const image = new Image();
-      image.crossOrigin = 'anonymous';
-      image.src = src;
-
-      image.onload = () => {
-        this.loadingPromises.delete(src);
-
-        if (!this.hasActiveRef(src)) {
-          resolve(undefined);
-          return;
-        }
-
-        if (this.loadedAssets.has(src)) {
-          console.error(`Texture already loaded: ${src}`);
-          resolve(undefined);
-          return;
+  protected override async doLoad(src: string) {
+    const loadingPromise = (async () => {
+      const response = await fetch(src)
+      if (!response.ok) {
+        console.error(`Failed to load texture: ${src}`)
+        return
+      }
+
+      const blob = await response.blob()
+      const bitmap = await createImageBitmap(blob, { premultiplyAlpha: 'premultiply' })
+
+      this.loadingPromises.delete(src)
+
+      if (this.hasActiveRef(src)) {
+        if (this.cachedAssets.has(src)) {
+          console.error(`Texture already exists: ${src}`)
+        } else {
+          const texture = Texture.from(bitmap)
+          texture.source.scaleMode = 'nearest'
+          this.cachedAssets.set(src, texture)
+          return texture
         }
+      }
+    })()
 
-        const texture = Texture.from(image);
-        this.loadedAssets.set(src, texture);
-        resolve(texture);
-      };
-
-      image.onerror = (error) => {
-        this.loadingPromises.delete(src);
-        console.error(`Failed to load texture: ${src}`, error);
-        resolve(undefined);
-      };
-    });
-
-    this.loadingPromises.set(src, loadingPromise);
-    return await loadingPromise;
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
   }
 
-  protected override _dispose(src: string, texture: Texture) {
-    texture.destroy(true);
+  override async load(src: string) {
+    return await super.load(src)
   }
 }
 
-export const textureLoader = new TextureLoader();
+export const textureLoader = new TextureLoader()

package/src/asset/preload.ts

@@ -1,76 +1,83 @@
-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';
+import { Atlas } from '../types/atlas'
+import { audioLoader } from './loaders/audio'
+import { binaryLoader } from './loaders/binary'
+import { bitmapFontLoader } from './loaders/bitmap-font'
+import { fontFamilyLoader } from './loaders/font'
+import { Loader } from './loaders/loader'
+import { getCachedAtlasId, spritesheetLoader } from './loaders/spritesheet'
+import { textLoader } from './loaders/text'
+import { textureLoader } from './loaders/texture'
 
-type AssetSource = string | {
-  src: string;
-  atlas: SpritesheetData;
-};
+export type AssetSource = string
+  | { src: string, atlas: Atlas }
+  | { fnt: string, src: string }
 
-function isImage(path: string): boolean {
-  return path.endsWith('.png') ||
-    path.endsWith('.jpg') ||
-    path.endsWith('.jpeg') ||
-    path.endsWith('.gif') ||
-    path.endsWith('.webp');
-}
+const loaderForPathMap: Array<{ check: (path: string) => boolean, loader: Loader<any> }> = [
+  { check: (p) => p.endsWith('.json') || p.endsWith('.atlas'), loader: textLoader },
+  { check: (p) => p.endsWith('.skel'), loader: binaryLoader },
+  { check: (p) => /\.(png|jpe?g|gif|webp)$/.test(p), loader: textureLoader },
+  { check: (p) => /\.(mp3|wav|ogg)$/.test(p), loader: audioLoader },
+  { check: (p) => !p.includes('.'), loader: fontFamilyLoader }
+]
 
-function isAudio(path: string): boolean {
-  return path.endsWith('.mp3') ||
-    path.endsWith('.wav') ||
-    path.endsWith('.ogg');
+function getLoaderForPath(path: string): Loader<any> | undefined {
+  return loaderForPathMap.find(({ check }) => check(path))?.loader
 }
 
-function isFontFamily(fontFamily: string): boolean {
-  return !fontFamily.includes('.');
+async function loadAsset(asset: AssetSource): Promise<void> {
+  if (typeof asset === 'string') {
+    const loader = getLoaderForPath(asset)
+    if (!loader) {
+      console.warn(`No loader found for asset: ${asset}`)
+      return
+    }
+    await loader.load(asset)
+  } else if ('atlas' in asset) {
+    const id = getCachedAtlasId(asset.src, asset.atlas)
+    await spritesheetLoader.load(id, asset.src, asset.atlas)
+  } else if ('fnt' in asset) {
+    await bitmapFontLoader.load(asset.fnt, asset.src)
+  } else {
+    console.warn(`Unknown asset type: ${asset}`)
+  }
 }
 
-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);
+function releaseAsset(asset: AssetSource): void {
+  if (typeof asset === 'string') {
+    const loader = getLoaderForPath(asset)
+    if (!loader) {
+      console.warn(`No loader found for asset: ${asset}`)
+      return
     }
+    loader.release(asset)
+  } else if ('atlas' in asset) {
+    const id = getCachedAtlasId(asset.src, asset.atlas)
+    spritesheetLoader.release(id)
+  } else if ('fnt' in asset) {
+    bitmapFontLoader.release(asset.fnt)
+  } else {
+    console.warn(`Unknown asset type: ${asset}`)
+  }
+}
 
-    loaded++;
-    progressCallback?.(loaded / total);
-  }));
+export async function preload(
+  assets: AssetSource[],
+  progressCallback?: (progress: number) => void
+): Promise<() => void> {
+  let loaded = 0
+  const total = assets.length
 
-  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);
+  await Promise.all(
+    assets.map(async (asset) => {
+      try {
+        await loadAsset(asset)
+        loaded++
+        progressCallback?.(loaded / total)
+      } catch (err) {
+        console.error(`Failed to load asset:`, asset, err)
       }
-    });
-  };
-}
+    })
+  )
 
-export { AssetSource, preload };
+  return () => assets.forEach(releaseAsset)
+}