Class AssetLoader

Type-safe asset loader class

Example

// Default configuration with 60 second timeout
const assetLoader = new AssetLoader();

// Configuration with custom settings
const customLoader = new AssetLoader({
  maxConcurrentLoads: 5,
  timeout: 30000 // 30 seconds
});

// Disable timeout (wait indefinitely)
const noTimeoutLoader = new AssetLoader({
  timeout: 0 // or any negative value
});

// Load promises in object format
const assets = await assetLoader.load({
  environment: Rn.CubeTexture.fromUrl({
    baseUrl: '/path/to/environment',
    mipmapLevelNumber: 1,
    isNamePosNeg: true,
    hdriFormat: Rn.HdriFormat.HDR_LINEAR,
  }),
  specular: Rn.CubeTexture.fromUrl({
    baseUrl: '/path/to/specular',
    mipmapLevelNumber: 10,
    isNamePosNeg: true,
    hdriFormat: Rn.HdriFormat.RGBE_PNG,
  }),
  diffuse: Rn.CubeTexture.fromUrl({
    baseUrl: '/path/to/diffuse',
    mipmapLevelNumber: 1,
    isNamePosNeg: true,
    hdriFormat: Rn.HdriFormat.RGBE_PNG,
  })
});

console.log(assets.environment); // CubeTexture
console.log(assets.specular); // CubeTexture
console.log(assets.diffuse); // CubeTexture

Index

Constructors

constructor

Methods

getLoadingStatus load loadArray loadSingle loadWithRetry loadWithRetryArray loadWithRetrySingle waitForAllLoads

Constructors

constructor

new AssetLoader(config?: AssetLoaderConfig): AssetLoader
Creates a new AssetLoader instance with the specified configuration.
Parameters
- config: AssetLoaderConfig = {}
  Configuration options for the asset loader
  
  Asset loader configuration interface
  - OptionalmaxConcurrentLoads?: number
    Limit on the number of concurrent loads
  - Optionaltimeout?: number
    Timeout duration (in milliseconds). Set to 0 or negative value to disable timeout
Returns AssetLoader
Example
```
// Default configuration
const loader = new AssetLoader();

// Custom configuration
const customLoader = new AssetLoader({
  maxConcurrentLoads: 5,
  timeout: 30000
});
```
- Defined in foundation/helpers/AssetLoader.ts:100

Methods

getLoadingStatus

getLoadingStatus(): { active: number; queued: number }
Gets the current loading status including active and queued loads. Useful for monitoring loading progress and debugging.

Returns { active: number; queued: number }
Object containing the number of active and queued loads
Example
```
const status = loader.getLoadingStatus();
console.log(`Active: ${status.active}, Queued: ${status.queued}`);
```
- Defined in foundation/helpers/AssetLoader.ts:408

load

load<T extends Record<string, Promise<any>>>(
promiseObject: T,
): Promise<AwaitedObject<T>>
Loads multiple promises organized as an object with named keys. The result preserves the same structure with resolved values.
Type Parameters
- T extends Record<string, Promise<any>>
  Object type where values are promises
Parameters
- promiseObject: T
  Object containing promises to be loaded
Returns Promise<AwaitedObject<T>>
Promise that resolves to an object with the same keys but resolved values
Example
```
const assets = await loader.load({
  texture: loadTexture('path/to/texture.jpg'),
  model: loadModel('path/to/model.gltf'),
  audio: loadAudio('path/to/sound.mp3')
});

// Type-safe access to resolved values
console.log(assets.texture); // Texture
console.log(assets.model);   // Model
console.log(assets.audio);   // AudioBuffer
```
- Defined in foundation/helpers/AssetLoader.ts:129

loadArray

loadArray<T>(promises: Promise<T>[]): Promise<T[]>
Loads multiple promises in bulk as an array. Supports both homogeneous arrays and heterogeneous tuples with type safety.
Type Parameters
- T
  The type of values in the array or tuple
Parameters
- promises: Promise<T>[]
  Array or tuple of promises to be loaded
Returns Promise<T[]>
Promise that resolves to an array or tuple of resolved values with preserved types
Example
```
// Homogeneous array
const textures = await loader.loadArray([
  loadTexture('texture1.jpg'),
  loadTexture('texture2.jpg'),
  loadTexture('texture3.jpg')
]);

// Heterogeneous tuple with type safety
const [texture, model, audio] = await loader.loadArray([
  loadTexture('texture.jpg'),
  loadModel('model.gltf'),
  loadAudio('sound.mp3')
] as const);
```
- Defined in foundation/helpers/AssetLoader.ts:225
loadArray<T extends readonly unknown[]>(
promises: readonly [{ [K in string | number | symbol]: Promise<T[K]> }],
): Promise<T>
Loads multiple promises in bulk as an array. Supports both homogeneous arrays and heterogeneous tuples with type safety.
Type Parameters
- T extends readonly unknown[]
  The type of values in the array or tuple
Parameters
- promises: readonly [{ [K in string | number | symbol]: Promise<T[K]> }]
  Array or tuple of promises to be loaded
Returns Promise<T>
Promise that resolves to an array or tuple of resolved values with preserved types
Example
```
// Homogeneous array
const textures = await loader.loadArray([
  loadTexture('texture1.jpg'),
  loadTexture('texture2.jpg'),
  loadTexture('texture3.jpg')
]);

// Heterogeneous tuple with type safety
const [texture, model, audio] = await loader.loadArray([
  loadTexture('texture.jpg'),
  loadModel('model.gltf'),
  loadAudio('sound.mp3')
] as const);
```
- Defined in foundation/helpers/AssetLoader.ts:226

loadSingle

loadSingle<T>(promise: Promise<T>): Promise<T>
Loads a single promise with queue management, timeout, and concurrency control.
Type Parameters
- T
  The type of value the promise resolves to
Parameters
- promise: Promise<T>
  The promise to be loaded
Returns Promise<T>
Promise that resolves to the same value as the input promise
Example
```
const texture = await loader.loadSingle(loadTexture('texture.jpg'));
const model = await loader.loadSingle(loadModel('model.gltf'));
```
- Defined in foundation/helpers/AssetLoader.ts:156

loadWithRetry

loadWithRetry<T extends Record<string, Promise<any>>>(
promiseFactories: { [K in string | number | symbol]: (() => T[K])[] },
): Promise<AwaitedObject<T>>
Loads multiple promises with retry capabilities organized as an object. Combines the structure of load() with the retry functionality of loadWithRetryArray().
Type Parameters
- T extends Record<string, Promise<any>>
  Object type where values are promises
Parameters
- promiseFactories: { [K in string | number | symbol]: (() => T[K])[] }
  Object where each value is an array of factory functions
Returns Promise<AwaitedObject<T>>
Promise that resolves to an object with the same keys but resolved values
Example
```
const assets = await loader.loadWithRetry({
  texture: [
    () => loadTexture('high-res.jpg'),
    () => loadTexture('low-res.jpg')
  ],
  model: [
    () => loadModel('detailed.gltf'),
    () => loadModel('simple.gltf')
  ]
});

console.log(assets.texture); // Texture (from successful factory)
console.log(assets.model);   // Model (from successful factory)
```
- Defined in foundation/helpers/AssetLoader.ts:287

loadWithRetryArray

loadWithRetryArray<T>(promiseFactories: (() => Promise<T>)[][]): Promise<T[]>
Loads multiple promises with retry capabilities for each one. Each promise has its own set of factory functions for retry attempts.
Type Parameters
- T
  The type of values the promises resolve to
Parameters
- promiseFactories: (() => Promise<T>)[][]
  Array where each element is an array of factory functions for one promise
Returns Promise<T[]>
Promise that resolves to an array of resolved values
Example
```
const assets = await loader.loadWithRetryArray([
  [
    () => loadTexture('high-res.jpg'),
    () => loadTexture('low-res.jpg')
  ],
  [
    () => loadModel('detailed.gltf'),
    () => loadModel('simple.gltf')
  ]
]);
```
- Defined in foundation/helpers/AssetLoader.ts:254

loadWithRetrySingle

loadWithRetrySingle<T>(promiseFactories: (() => Promise<T>)[]): Promise<T>
Loads a single promise with automatic retry using fallback factories. If the first promise fails, it will try the next factory in order.
Type Parameters
- T
  The type of value the promise resolves to
Parameters
- promiseFactories: (() => Promise<T>)[]
  Array of factory functions that create promises, ordered by priority
Returns Promise<T>
Promise that resolves to the value from the first successful factory
Throws
When no promise factories are provided
Example
```
const texture = await loader.loadWithRetrySingle([
  () => loadTexture('high-quality.jpg'),    // Try first
  () => loadTexture('medium-quality.jpg'),  // Fallback 1
  () => loadTexture('low-quality.jpg')      // Fallback 2
]);
```
- Defined in foundation/helpers/AssetLoader.ts:191

waitForAllLoads

waitForAllLoads(): Promise<void>
Waits until all currently active and queued loads are complete. Useful for ensuring all assets are loaded before proceeding.

Returns Promise<void>
Promise that resolves when all loads are complete
Example
```
// Start multiple loads
loader.loadSingle(loadTexture('texture.jpg'));
loader.loadSingle(loadModel('model.gltf'));

// Wait for all to complete
await loader.waitForAllLoads();
console.log('All assets loaded!');
```
- Defined in foundation/helpers/AssetLoader.ts:432

Class AssetLoader

Example

Index

Constructors

Methods

Constructors

constructor

Parameters

OptionalmaxConcurrentLoads?: number

Optionaltimeout?: number

Returns AssetLoader

Example

Methods

getLoadingStatus

Returns { active: number; queued: number }

Example

load

Type Parameters

Parameters

Returns Promise<AwaitedObject<T>>

Example

loadArray

Type Parameters

Parameters

Returns Promise<T[]>

Example

Type Parameters

Parameters

Returns Promise<T>

Example

loadSingle

Type Parameters

Parameters

Returns Promise<T>

Example

loadWithRetry

Type Parameters

Parameters

Returns Promise<AwaitedObject<T>>

Example

loadWithRetryArray

Type Parameters

Parameters

Returns Promise<T[]>

Example

loadWithRetrySingle

Type Parameters

Parameters

Returns Promise<T>

Throws

Example

waitForAllLoads

Returns Promise<void>

Example

Settings

On This Page

`Optional`maxConcurrentLoads?: number

`Optional`timeout?: number