kiwiengine 0.0.1-alpha → 0.5.2

package/src/asset/loaders/spritesheet.ts

@@ -1,67 +1,65 @@
-import { Spritesheet, SpritesheetData } from 'pixi.js';
-import { Loader } from './loader';
-import { textureLoader } from './texture';
+import { Spritesheet, SpritesheetData } from 'pixi.js'
+import { Loader } from './loader'
+import { textureLoader } from './texture'
 
-const atlasIdCache = new WeakMap<object, Map<string, string>>();
-let idCounter = 0;
+const atlasIdCache = new WeakMap<SpritesheetData, Map<string, string>>()
+let idCounter = 0
 
-function getCachedId(src: string, atlas: object): string {
-  let innerMap = atlasIdCache.get(atlas);
+export function getCachedAtlasId(src: string, atlas: SpritesheetData): 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: SpritesheetData) {
+    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 spritesheet = new Spritesheet(texture, atlas)
+      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();
-
-export { getCachedId, spritesheetLoader };
+export const spritesheetLoader = new SpritesheetLoader()

package/src/asset/loaders/text.ts

@@ -1,31 +1,31 @@
-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
   }
 }
 
-export const textLoader = new TextLoader();
+export const textLoader = new TextLoader()

package/src/asset/loaders/texture.ts

@@ -1,46 +1,47 @@
-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) {
+  protected override async doLoad(src: string) {
     const loadingPromise = new Promise<Texture | undefined>((resolve) => {
-      const image = new Image();
-      image.crossOrigin = 'anonymous';
-      image.src = src;
+      const image = new Image()
+      image.crossOrigin = 'anonymous'
+      image.src = src
 
       image.onload = () => {
-        this.loadingPromises.delete(src);
+        this.loadingPromises.delete(src)
 
         if (!this.hasActiveRef(src)) {
-          resolve(undefined);
-          return;
+          resolve(undefined)
+          return
         }
 
-        if (this.loadedAssets.has(src)) {
-          console.error(`Texture already loaded: ${src}`);
-          resolve(undefined);
-          return;
+        if (this.cachedAssets.has(src)) {
+          console.error(`Texture already loaded: ${src}`)
+          resolve(undefined)
+          return
         }
 
-        const texture = Texture.from(image);
-        this.loadedAssets.set(src, texture);
-        resolve(texture);
-      };
+        const texture = Texture.from(image)
+        texture.source.scaleMode = 'nearest'
+        this.cachedAssets.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.delete(src)
+        console.error(`Failed to load texture: ${src}`, error)
+        resolve(undefined)
+      }
+    })
+
+    this.loadingPromises.set(src, loadingPromise)
+    return await loadingPromise
   }
 
-  protected override _dispose(src: string, texture: Texture) {
-    texture.destroy(true);
+  protected override cleanup(src: string, texture: Texture) {
+    texture.destroy(true)
   }
 }
 
-export const textureLoader = new TextureLoader();
+export const textureLoader = new TextureLoader()

package/src/asset/preload.ts

@@ -1,76 +1,87 @@
-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 { SpritesheetData } from 'pixi.js'
+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;
-};
-
-function isImage(path: string): boolean {
-  return path.endsWith('.png') ||
-    path.endsWith('.jpg') ||
-    path.endsWith('.jpeg') ||
-    path.endsWith('.gif') ||
-    path.endsWith('.webp');
+export type AssetSource = string | {
+  src: string
+  atlas: SpritesheetData
+} | {
+  fnt: string
+  src: string
 }
 
-function isAudio(path: string): boolean {
-  return path.endsWith('.mp3') ||
-    path.endsWith('.wav') ||
-    path.endsWith('.ogg');
-}
+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 isFontFamily(fontFamily: string): boolean {
-  return !fontFamily.includes('.');
+function getLoaderForPath(path: string): Loader<any> | undefined {
+  return loaderForPathMap.find(({ check }) => check(path))?.loader
 }
 
-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}`);
-      }
+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
     }
-    else {
-      const id = getCachedId(asset.src, asset.atlas);
-      await spritesheetLoader.load(id, asset.src, asset.atlas);
+    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}`)
+  }
+}
+
+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)
+}