@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/cjs/native-engine/AssetPipeline.js

@@ -1,539 +1,478 @@
-'use strict';
-
-/**
- * @file AssetPipeline.ts
- * @description Asset Pipeline for Nice2Dev Game Engine
- * PRO-1.11.1: Core Engine Systems - Asset Pipeline
- *
- * Features:
- * - glTF 2.0 import (primary format)
- * - FBX, OBJ, Collada, 3DS import
- * - Texture compression (Basis Universal)
- * - Asset bundling (.ndasset)
- * - Asset streaming
- * - Hot reloading
- */
-// ============================================================
-// Asset Manager
-// ============================================================
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class AssetManager {
-    constructor(settings) {
-        this.assets = new Map();
-        this.loaders = new Map();
-        this.processors = new Map();
-        this.loadingPromises = new Map();
-        this.callbacks = {};
-        this.defaultSettings = settings ?? {};
-        this.registerDefaultLoaders();
-    }
-    registerDefaultLoaders() {
-        this.registerLoader('gltf', new GLTFLoader());
-        this.registerLoader('glb', new GLTFLoader());
-        this.registerLoader('obj', new OBJLoader());
-        this.registerLoader('fbx', new FBXLoader());
-        this.registerLoader('dae', new ColladaLoader());
-        this.registerLoader('png', new ImageLoader());
-        this.registerLoader('jpg', new ImageLoader());
-        this.registerLoader('webp', new ImageLoader());
-        this.registerLoader('ktx2', new KTX2Loader());
-        this.registerLoader('hdr', new HDRLoader());
-        this.registerLoader('wav', new AudioLoader());
-        this.registerLoader('mp3', new AudioLoader());
-        this.registerLoader('ogg', new AudioLoader());
-        this.registerLoader('ndasset', new BundleLoader());
-    }
-    // ─── Registration ──────────────────────────────────────
-    registerLoader(format, loader) {
-        this.loaders.set(format, loader);
-    }
-    registerProcessor(type, processor) {
-        this.processors.set(type, processor);
-    }
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
-    }
-    // ─── Loading ───────────────────────────────────────────
-    async load(path, settings) {
-        // Check if already loaded
-        const existing = this.getByPath(path);
-        if (existing && existing.state === 'loaded') {
-            return existing;
-        }
-        // Check if already loading
-        const pending = this.loadingPromises.get(path);
-        if (pending) {
-            return pending;
-        }
-        const promise = this.doLoad(path, settings);
-        this.loadingPromises.set(path, promise);
-        try {
-            const asset = await promise;
-            return asset;
-        }
-        finally {
-            this.loadingPromises.delete(path);
-        }
-    }
-    async doLoad(path, settings) {
-        const format = this.getFormat(path);
-        const loader = this.loaders.get(format);
-        if (!loader) {
-            throw new Error(`No loader registered for format: ${format}`);
-        }
-        const mergedSettings = { ...this.defaultSettings, ...settings };
-        // Create placeholder asset
-        const asset = {
-            id: this.generateId(),
-            name: this.getName(path),
-            type: this.inferType(format),
-            format,
-            path,
-            state: 'loading',
-            size: 0,
-            dependencies: [],
-            metadata: { version: 1 },
-            data: null,
-            lastModified: Date.now(),
-        };
-        this.assets.set(asset.id, asset);
-        this.callbacks.onLoadStart?.(asset);
-        try {
-            // Load raw data
-            const rawData = await this.fetchData(path);
-            asset.size = rawData.byteLength;
-            // Parse with loader
-            const loadedData = await loader.load(rawData, path, mergedSettings);
-            // Process if needed
-            const processor = this.processors.get(asset.type);
-            if (processor) {
-                asset.data = await processor.process(loadedData, mergedSettings);
-            }
-            else {
-                asset.data = loadedData;
-            }
-            asset.state = 'loaded';
-            asset.loadedAt = Date.now();
-            // Load dependencies
-            if (asset.dependencies.length > 0) {
-                await Promise.all(asset.dependencies.map((dep) => this.load(dep)));
-            }
-            this.callbacks.onLoadComplete?.(asset);
-            return asset;
-        }
-        catch (error) {
-            asset.state = 'error';
-            asset.error = error;
-            this.callbacks.onLoadError?.(asset, error);
-            throw error;
-        }
-    }
-    async loadMultiple(paths, settings) {
-        const promises = paths.map((path) => this.load(path, settings));
-        return Promise.all(promises);
-    }
-    async fetchData(path) {
-        const response = await fetch(path);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch: ${path} (${response.status})`);
-        }
-        return response.arrayBuffer();
-    }
-    // ─── Unloading ─────────────────────────────────────────
-    unload(id) {
-        const asset = this.assets.get(id);
-        if (!asset) {
-            return;
-        }
-        // Call processor cleanup if available
-        const processor = this.processors.get(asset.type);
-        if (processor?.cleanup) {
-            processor.cleanup(asset.data);
-        }
-        asset.data = null;
-        asset.state = 'unloaded';
-        this.assets.delete(id);
-        this.callbacks.onUnload?.(asset);
-    }
-    unloadByPath(path) {
-        const asset = this.getByPath(path);
-        if (asset) {
-            this.unload(asset.id);
-        }
-    }
-    unloadAll() {
-        for (const id of this.assets.keys()) {
-            this.unload(id);
-        }
-    }
-    unloadUnused() {
-        // Implementation would track references and unload assets with refcount 0
-    }
-    // ─── Access ────────────────────────────────────────────
-    get(id) {
-        return this.assets.get(id);
-    }
-    getByPath(path) {
-        for (const asset of this.assets.values()) {
-            if (asset.path === path) {
-                return asset;
-            }
-        }
-        return undefined;
-    }
-    getByType(type) {
-        return Array.from(this.assets.values()).filter((a) => a.type === type);
-    }
-    getAll() {
-        return Array.from(this.assets.values());
-    }
-    has(id) {
-        return this.assets.has(id);
-    }
-    isLoaded(id) {
-        const asset = this.assets.get(id);
-        return asset?.state === 'loaded';
-    }
-    // ─── Hot Reloading ─────────────────────────────────────
-    async reload(id) {
-        const asset = this.assets.get(id);
-        if (!asset) {
-            throw new Error(`Asset not found: ${id}`);
-        }
-        // Store current state
-        const path = asset.path;
-        // Unload
-        this.unload(id);
-        // Reload
-        return this.load(path);
-    }
-    enableHotReload(_watchPaths) {
-        // Implementation would use FileSystem API or WebSocket to watch for changes
-    }
-    disableHotReload() {
-        // Stop watching
-    }
-    // ─── Bundling ──────────────────────────────────────────
-    async createBundle(assetIds, bundlePath) {
-        const assets = assetIds.map((id) => {
-            const asset = this.assets.get(id);
-            if (!asset) {
-                throw new Error(`Asset not found: ${id}`);
-            }
-            return asset;
-        });
-        // Serialize assets to binary format
-        const bundleData = this.serializeBundle(assets);
-        const bundle = {
-            id: this.generateId(),
-            name: this.getName(bundlePath),
-            type: 'bundle',
-            format: 'ndasset',
-            path: bundlePath,
-            state: 'loaded',
-            size: bundleData.data.byteLength,
-            dependencies: [],
-            metadata: { version: 1 },
-            data: bundleData,
-            lastModified: Date.now(),
-            loadedAt: Date.now(),
-        };
-        this.assets.set(bundle.id, bundle);
-        return bundle;
-    }
-    serializeBundle(assets) {
-        // Create bundle header and concatenate asset data
-        const entries = [];
-        const buffers = [];
-        let offset = 0;
-        for (const asset of assets) {
-            const serialized = this.serializeAsset(asset);
-            entries.push({
-                id: asset.id,
-                type: asset.type,
-                offset,
-                size: serialized.byteLength,
-            });
-            buffers.push(serialized);
-            offset += serialized.byteLength;
-        }
-        // Concatenate all buffers
-        const totalSize = buffers.reduce((sum, b) => sum + b.byteLength, 0);
-        const data = new ArrayBuffer(totalSize);
-        const view = new Uint8Array(data);
-        let pos = 0;
-        for (const buffer of buffers) {
-            view.set(new Uint8Array(buffer), pos);
-            pos += buffer.byteLength;
-        }
-        return { assets: entries, data };
-    }
-    serializeAsset(_asset) {
-        // Serialize individual asset to binary
-        // Implementation depends on asset type
-        return new ArrayBuffer(0);
-    }
-    async loadBundle(bundlePath) {
-        const bundle = (await this.load(bundlePath));
-        const bundleData = bundle.data;
-        const loadedAssets = [];
-        for (const entry of bundleData.assets) {
-            const assetData = bundleData.data.slice(entry.offset, entry.offset + entry.size);
-            const asset = this.deserializeAsset(entry, assetData);
-            this.assets.set(asset.id, asset);
-            loadedAssets.push(asset);
-        }
-        return loadedAssets;
-    }
-    deserializeAsset(entry, _data) {
-        // Deserialize from binary
-        return {
-            id: entry.id,
-            name: '',
-            type: entry.type,
-            format: 'ndasset',
-            path: '',
-            state: 'loaded',
-            size: entry.size,
-            dependencies: [],
-            metadata: { version: 1 },
-            data: null,
-            lastModified: Date.now(),
-            loadedAt: Date.now(),
-        };
-    }
-    // ─── Helpers ───────────────────────────────────────────
-    getFormat(path) {
-        const ext = path.split('.').pop()?.toLowerCase();
-        return (ext ?? 'unknown');
-    }
-    getName(path) {
-        return path.split('/').pop()?.split('.')[0] ?? '';
-    }
-    inferType(format) {
-        switch (format) {
-            case 'gltf':
-            case 'glb':
-            case 'fbx':
-            case 'obj':
-            case 'dae':
-            case '3ds':
-                return 'scene';
-            case 'png':
-            case 'jpg':
-            case 'webp':
-            case 'ktx2':
-            case 'basis':
-            case 'hdr':
-            case 'exr':
-                return 'texture';
-            case 'wav':
-            case 'mp3':
-            case 'ogg':
-                return 'audio';
-            case 'ndasset':
-                return 'bundle';
-            default:
-                return 'scene';
-        }
-    }
-    generateId() {
-        return `asset_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
+  constructor(settings) {
+    this.assets = /* @__PURE__ */ new Map();
+    this.loaders = /* @__PURE__ */ new Map();
+    this.processors = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.defaultSettings = settings ?? {};
+    this.registerDefaultLoaders();
+  }
+  registerDefaultLoaders() {
+    this.registerLoader("gltf", new GLTFLoader());
+    this.registerLoader("glb", new GLTFLoader());
+    this.registerLoader("obj", new OBJLoader());
+    this.registerLoader("fbx", new FBXLoader());
+    this.registerLoader("dae", new ColladaLoader());
+    this.registerLoader("png", new ImageLoader());
+    this.registerLoader("jpg", new ImageLoader());
+    this.registerLoader("webp", new ImageLoader());
+    this.registerLoader("ktx2", new KTX2Loader());
+    this.registerLoader("hdr", new HDRLoader());
+    this.registerLoader("wav", new AudioLoader());
+    this.registerLoader("mp3", new AudioLoader());
+    this.registerLoader("ogg", new AudioLoader());
+    this.registerLoader("ndasset", new BundleLoader());
+  }
+  // ─── Registration ──────────────────────────────────────
+  registerLoader(format, loader) {
+    this.loaders.set(format, loader);
+  }
+  registerProcessor(type, processor) {
+    this.processors.set(type, processor);
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  // ─── Loading ───────────────────────────────────────────
+  async load(path, settings) {
+    const existing = this.getByPath(path);
+    if (existing && existing.state === "loaded") {
+      return existing;
+    }
+    const pending = this.loadingPromises.get(path);
+    if (pending) {
+      return pending;
+    }
+    const promise = this.doLoad(path, settings);
+    this.loadingPromises.set(path, promise);
+    try {
+      const asset = await promise;
+      return asset;
+    } finally {
+      this.loadingPromises.delete(path);
+    }
+  }
+  async doLoad(path, settings) {
+    const format = this.getFormat(path);
+    const loader = this.loaders.get(format);
+    if (!loader) {
+      throw new Error(`No loader registered for format: ${format}`);
+    }
+    const mergedSettings = { ...this.defaultSettings, ...settings };
+    const asset = {
+      id: this.generateId(),
+      name: this.getName(path),
+      type: this.inferType(format),
+      format,
+      path,
+      state: "loading",
+      size: 0,
+      dependencies: [],
+      metadata: { version: 1 },
+      data: null,
+      lastModified: Date.now()
+    };
+    this.assets.set(asset.id, asset);
+    this.callbacks.onLoadStart?.(asset);
+    try {
+      const rawData = await this.fetchData(path);
+      asset.size = rawData.byteLength;
+      const loadedData = await loader.load(rawData, path, mergedSettings);
+      const processor = this.processors.get(asset.type);
+      if (processor) {
+        asset.data = await processor.process(loadedData, mergedSettings);
+      } else {
+        asset.data = loadedData;
+      }
+      asset.state = "loaded";
+      asset.loadedAt = Date.now();
+      if (asset.dependencies.length > 0) {
+        await Promise.all(asset.dependencies.map((dep) => this.load(dep)));
+      }
+      this.callbacks.onLoadComplete?.(asset);
+      return asset;
+    } catch (error) {
+      asset.state = "error";
+      asset.error = error;
+      this.callbacks.onLoadError?.(asset, error);
+      throw error;
+    }
+  }
+  async loadMultiple(paths, settings) {
+    const promises = paths.map((path) => this.load(path, settings));
+    return Promise.all(promises);
+  }
+  async fetchData(path) {
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch: ${path} (${response.status})`);
+    }
+    return response.arrayBuffer();
+  }
+  // ─── Unloading ─────────────────────────────────────────
+  unload(id) {
+    const asset = this.assets.get(id);
+    if (!asset) {
+      return;
+    }
+    const processor = this.processors.get(asset.type);
+    if (processor?.cleanup) {
+      processor.cleanup(asset.data);
+    }
+    asset.data = null;
+    asset.state = "unloaded";
+    this.assets.delete(id);
+    this.callbacks.onUnload?.(asset);
+  }
+  unloadByPath(path) {
+    const asset = this.getByPath(path);
+    if (asset) {
+      this.unload(asset.id);
+    }
+  }
+  unloadAll() {
+    for (const id of this.assets.keys()) {
+      this.unload(id);
+    }
+  }
+  unloadUnused() {
+  }
+  // ─── Access ────────────────────────────────────────────
+  get(id) {
+    return this.assets.get(id);
+  }
+  getByPath(path) {
+    for (const asset of this.assets.values()) {
+      if (asset.path === path) {
+        return asset;
+      }
+    }
+    return void 0;
+  }
+  getByType(type) {
+    return Array.from(this.assets.values()).filter((a) => a.type === type);
+  }
+  getAll() {
+    return Array.from(this.assets.values());
+  }
+  has(id) {
+    return this.assets.has(id);
+  }
+  isLoaded(id) {
+    const asset = this.assets.get(id);
+    return asset?.state === "loaded";
+  }
+  // ─── Hot Reloading ─────────────────────────────────────
+  async reload(id) {
+    const asset = this.assets.get(id);
+    if (!asset) {
+      throw new Error(`Asset not found: ${id}`);
+    }
+    const path = asset.path;
+    this.unload(id);
+    return this.load(path);
+  }
+  enableHotReload(_watchPaths) {
+  }
+  disableHotReload() {
+  }
+  // ─── Bundling ──────────────────────────────────────────
+  async createBundle(assetIds, bundlePath) {
+    const assets = assetIds.map((id) => {
+      const asset = this.assets.get(id);
+      if (!asset) {
+        throw new Error(`Asset not found: ${id}`);
+      }
+      return asset;
+    });
+    const bundleData = this.serializeBundle(assets);
+    const bundle = {
+      id: this.generateId(),
+      name: this.getName(bundlePath),
+      type: "bundle",
+      format: "ndasset",
+      path: bundlePath,
+      state: "loaded",
+      size: bundleData.data.byteLength,
+      dependencies: [],
+      metadata: { version: 1 },
+      data: bundleData,
+      lastModified: Date.now(),
+      loadedAt: Date.now()
+    };
+    this.assets.set(bundle.id, bundle);
+    return bundle;
+  }
+  serializeBundle(assets) {
+    const entries = [];
+    const buffers = [];
+    let offset = 0;
+    for (const asset of assets) {
+      const serialized = this.serializeAsset(asset);
+      entries.push({
+        id: asset.id,
+        type: asset.type,
+        offset,
+        size: serialized.byteLength
+      });
+      buffers.push(serialized);
+      offset += serialized.byteLength;
+    }
+    const totalSize = buffers.reduce((sum, b) => sum + b.byteLength, 0);
+    const data = new ArrayBuffer(totalSize);
+    const view = new Uint8Array(data);
+    let pos = 0;
+    for (const buffer of buffers) {
+      view.set(new Uint8Array(buffer), pos);
+      pos += buffer.byteLength;
+    }
+    return { assets: entries, data };
+  }
+  serializeAsset(_asset) {
+    return new ArrayBuffer(0);
+  }
+  async loadBundle(bundlePath) {
+    const bundle = await this.load(bundlePath);
+    const bundleData = bundle.data;
+    const loadedAssets = [];
+    for (const entry of bundleData.assets) {
+      const assetData = bundleData.data.slice(entry.offset, entry.offset + entry.size);
+      const asset = this.deserializeAsset(entry, assetData);
+      this.assets.set(asset.id, asset);
+      loadedAssets.push(asset);
+    }
+    return loadedAssets;
+  }
+  deserializeAsset(entry, _data) {
+    return {
+      id: entry.id,
+      name: "",
+      type: entry.type,
+      format: "ndasset",
+      path: "",
+      state: "loaded",
+      size: entry.size,
+      dependencies: [],
+      metadata: { version: 1 },
+      data: null,
+      lastModified: Date.now(),
+      loadedAt: Date.now()
+    };
+  }
+  // ─── Helpers ───────────────────────────────────────────
+  getFormat(path) {
+    const ext = path.split(".").pop()?.toLowerCase();
+    return ext ?? "unknown";
+  }
+  getName(path) {
+    return path.split("/").pop()?.split(".")[0] ?? "";
+  }
+  inferType(format) {
+    switch (format) {
+      case "gltf":
+      case "glb":
+      case "fbx":
+      case "obj":
+      case "dae":
+      case "3ds":
+        return "scene";
+      case "png":
+      case "jpg":
+      case "webp":
+      case "ktx2":
+      case "basis":
+      case "hdr":
+      case "exr":
+        return "texture";
+      case "wav":
+      case "mp3":
+      case "ogg":
+        return "audio";
+      case "ndasset":
+        return "bundle";
+      default:
+        return "scene";
+    }
+  }
+  generateId() {
+    return `asset_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
 }
-// ============================================================
-// Loaders (Placeholder Implementations)
-// ============================================================
 class GLTFLoader {
-    async load(data, path, _settings) {
-        // Use glTF parser library
-        const isGLB = path.endsWith('.glb');
-        if (isGLB) {
-            return this.parseGLB(data);
-        }
-        else {
-            const text = new TextDecoder().decode(data);
-            return this.parseGLTF(JSON.parse(text));
-        }
-    }
-    parseGLB(_data) {
-        // Parse binary glTF
-        return this.createEmptyScene();
-    }
-    parseGLTF(_json) {
-        // Parse JSON glTF
-        return this.createEmptyScene();
-    }
-    createEmptyScene() {
-        return {
-            nodes: [],
-            rootNodes: [],
-            meshes: [],
-            materials: [],
-            textures: [],
-            animations: [],
-            skeletons: [],
-            lights: [],
-            cameras: [],
-        };
-    }
+  async load(data, path, _settings) {
+    const isGLB = path.endsWith(".glb");
+    if (isGLB) {
+      return this.parseGLB(data);
+    } else {
+      const text = new TextDecoder().decode(data);
+      return this.parseGLTF(JSON.parse(text));
+    }
+  }
+  parseGLB(_data) {
+    return this.createEmptyScene();
+  }
+  parseGLTF(_json) {
+    return this.createEmptyScene();
+  }
+  createEmptyScene() {
+    return {
+      nodes: [],
+      rootNodes: [],
+      meshes: [],
+      materials: [],
+      textures: [],
+      animations: [],
+      skeletons: [],
+      lights: [],
+      cameras: []
+    };
+  }
 }
 class OBJLoader {
-    async load(_data, _path, _settings) {
-        // Parse OBJ format
-        return { primitives: [], bounds: { min: { x: 0, y: 0, z: 0 }, max: { x: 0, y: 0, z: 0 } } };
-    }
+  async load(_data, _path, _settings) {
+    return { primitives: [], bounds: { min: { x: 0, y: 0, z: 0 }, max: { x: 0, y: 0, z: 0 } } };
+  }
 }
 class FBXLoader {
-    async load(_data, _path, _settings) {
-        // Use FBX parser (assimp WASM)
-        return {
-            nodes: [],
-            rootNodes: [],
-            meshes: [],
-            materials: [],
-            textures: [],
-            animations: [],
-            skeletons: [],
-            lights: [],
-            cameras: [],
-        };
-    }
+  async load(_data, _path, _settings) {
+    return {
+      nodes: [],
+      rootNodes: [],
+      meshes: [],
+      materials: [],
+      textures: [],
+      animations: [],
+      skeletons: [],
+      lights: [],
+      cameras: []
+    };
+  }
 }
 class ColladaLoader {
-    async load(_data, _path, _settings) {
-        // Parse Collada XML
-        return {
-            nodes: [],
-            rootNodes: [],
-            meshes: [],
-            materials: [],
-            textures: [],
-            animations: [],
-            skeletons: [],
-            lights: [],
-            cameras: [],
-        };
-    }
+  async load(_data, _path, _settings) {
+    return {
+      nodes: [],
+      rootNodes: [],
+      meshes: [],
+      materials: [],
+      textures: [],
+      animations: [],
+      skeletons: [],
+      lights: [],
+      cameras: []
+    };
+  }
 }
 class ImageLoader {
-    async load(data, path, settings) {
-        const blob = new Blob([data]);
-        const imageBitmap = await createImageBitmap(blob);
-        const textureSettings = settings.texture ?? {};
-        const maxSize = textureSettings.maxSize ?? 4096;
-        let width = imageBitmap.width;
-        let height = imageBitmap.height;
-        // Resize if needed
-        if (width > maxSize || height > maxSize) {
-            const scale = maxSize / Math.max(width, height);
-            width = Math.floor(width * scale);
-            height = Math.floor(height * scale);
-        }
-        return {
-            width,
-            height,
-            format: this.getFormat(path),
-            mipLevels: textureSettings.generateMipmaps
-                ? Math.floor(Math.log2(Math.max(width, height))) + 1
-                : 1,
-            data: [data],
-            sRGB: textureSettings.sRGB ?? true,
-            generateMipmaps: textureSettings.generateMipmaps ?? true,
-            addressModeU: 'repeat',
-            addressModeV: 'repeat',
-            filterMin: 'linear',
-            filterMag: 'linear',
-            filterMip: 'linear',
-            anisotropy: 16,
-        };
-    }
-    getFormat(path) {
-        if (path.endsWith('.hdr') || path.endsWith('.exr')) {
-            return 'rgba16f';
-        }
-        return 'rgba8';
-    }
+  async load(data, path, settings) {
+    const blob = new Blob([data]);
+    const imageBitmap = await createImageBitmap(blob);
+    const textureSettings = settings.texture ?? {};
+    const maxSize = textureSettings.maxSize ?? 4096;
+    let width = imageBitmap.width;
+    let height = imageBitmap.height;
+    if (width > maxSize || height > maxSize) {
+      const scale = maxSize / Math.max(width, height);
+      width = Math.floor(width * scale);
+      height = Math.floor(height * scale);
+    }
+    return {
+      width,
+      height,
+      format: this.getFormat(path),
+      mipLevels: textureSettings.generateMipmaps ? Math.floor(Math.log2(Math.max(width, height))) + 1 : 1,
+      data: [data],
+      sRGB: textureSettings.sRGB ?? true,
+      generateMipmaps: textureSettings.generateMipmaps ?? true,
+      addressModeU: "repeat",
+      addressModeV: "repeat",
+      filterMin: "linear",
+      filterMag: "linear",
+      filterMip: "linear",
+      anisotropy: 16
+    };
+  }
+  getFormat(path) {
+    if (path.endsWith(".hdr") || path.endsWith(".exr")) {
+      return "rgba16f";
+    }
+    return "rgba8";
+  }
 }
 class KTX2Loader {
-    async load(_data, _path, _settings) {
-        // Parse KTX2 compressed texture
-        return {
-            width: 0,
-            height: 0,
-            format: 'rgba8',
-            mipLevels: 1,
-            data: [],
-            sRGB: true,
-            generateMipmaps: false,
-            addressModeU: 'repeat',
-            addressModeV: 'repeat',
-            filterMin: 'linear',
-            filterMag: 'linear',
-            filterMip: 'linear',
-            anisotropy: 16,
-        };
-    }
+  async load(_data, _path, _settings) {
+    return {
+      width: 0,
+      height: 0,
+      format: "rgba8",
+      mipLevels: 1,
+      data: [],
+      sRGB: true,
+      generateMipmaps: false,
+      addressModeU: "repeat",
+      addressModeV: "repeat",
+      filterMin: "linear",
+      filterMag: "linear",
+      filterMip: "linear",
+      anisotropy: 16
+    };
+  }
 }
 class HDRLoader {
-    async load(_data, _path, _settings) {
-        // Parse HDR/EXR format
-        return {
-            width: 0,
-            height: 0,
-            format: 'rgba16f',
-            mipLevels: 1,
-            data: [],
-            sRGB: false,
-            generateMipmaps: true,
-            addressModeU: 'repeat',
-            addressModeV: 'repeat',
-            filterMin: 'linear',
-            filterMag: 'linear',
-            filterMip: 'linear',
-            anisotropy: 1,
-        };
-    }
+  async load(_data, _path, _settings) {
+    return {
+      width: 0,
+      height: 0,
+      format: "rgba16f",
+      mipLevels: 1,
+      data: [],
+      sRGB: false,
+      generateMipmaps: true,
+      addressModeU: "repeat",
+      addressModeV: "repeat",
+      filterMin: "linear",
+      filterMag: "linear",
+      filterMip: "linear",
+      anisotropy: 1
+    };
+  }
 }
 class AudioLoader {
-    async load(data, path, _settings) {
-        // Decode audio using Web Audio API
-        const audioContext = new AudioContext();
-        const audioBuffer = await audioContext.decodeAudioData(data);
-        return {
-            sampleRate: audioBuffer.sampleRate,
-            channels: audioBuffer.numberOfChannels,
-            bitDepth: 16,
-            duration: audioBuffer.duration,
-            buffer: audioBuffer,
-            format: this.getFormat(path),
-        };
-    }
-    getFormat(path) {
-        if (path.endsWith('.mp3')) {
-            return 'mp3';
-        }
-        if (path.endsWith('.ogg')) {
-            return 'ogg';
-        }
-        return 'wav';
-    }
+  async load(data, path, _settings) {
+    const audioContext = new AudioContext();
+    const audioBuffer = await audioContext.decodeAudioData(data);
+    return {
+      sampleRate: audioBuffer.sampleRate,
+      channels: audioBuffer.numberOfChannels,
+      bitDepth: 16,
+      duration: audioBuffer.duration,
+      buffer: audioBuffer,
+      format: this.getFormat(path)
+    };
+  }
+  getFormat(path) {
+    if (path.endsWith(".mp3")) {
+      return "mp3";
+    }
+    if (path.endsWith(".ogg")) {
+      return "ogg";
+    }
+    return "wav";
+  }
 }
 class BundleLoader {
-    async load(data, _path, _settings) {
-        // Parse bundle header and return structure
-        // Actual asset loading deferred until requested
-        return {
-            assets: [],
-            data,
-        };
-    }
+  async load(data, _path, _settings) {
+    return {
+      assets: [],
+      data
+    };
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createAssetManager(settings) {
-    return new AssetManager(settings);
+  return new AssetManager(settings);
 }
-
 exports.AssetManager = AssetManager;
 exports.createAssetManager = createAssetManager;