GLTFLoader abort signal integration with LoadingManager progress tracking

Managing Request Cancellation in Three.js

To ensure that aborting a GLTFLoader request also updates the LoadingManager and cleans up callbacks, you must manually bridge the gap between the AbortSignal and the manager's internal state. Because LoadingManager tracks the number of items loaded versus total items, a canceled request typically leaves the manager in a "pending" state, preventing the global onLoad event from ever firing.

Implementation Strategy

The most reliable way to guarantee that aborting a loader stops related events without leaving dangling callbacks is to wrap the loader call in a controller that handles the AbortError specifically to notify the manager.

1. Initialize the Controller: Create an AbortController for each request or group of requests.
2. Pass the Signal: Pass the signal within the options object of the GLTFLoader.load method (supported in modern Three.js versions via the underlying FileLoader).
3. Handle the Error: In the loader's error callback, check if the error is an AbortError. If it is, manually trigger the logic required to "complete" that item's slot in the LoadingManager or reset the manager's state.

const manager = new THREE.LoadingManager();
const loader = new THREE.GLTFLoader(manager);
const controller = new AbortController();

loader.load(
  'model.glb',
  (gltf) => { /* success */ },
  (progress) => { /* progress */ },
  (error) => {
    if (error.name === 'AbortError') {
      console.log('Request aborted: Cleaning up manager state...');
      // Manual cleanup logic here
    }
  },
  undefined, // options
  { signal: controller.signal } // Pass signal here
);

Addressing the Core Questions

• Should LoadingManager expose AbortSignal forwarding? While it would simplify the API, the current architecture separates the management of the queue from the execution of the fetch. Forwarding would require the manager to track every active loader instance, adding significant overhead.
• Preventing dangling callbacks: Ensure that any addEventListener attached to the AbortSignal is removed using the { once: true } option or manually in the loader's final callback to prevent memory leaks.
• Uniform timeout pattern: For loaders lacking native support, the recommended pattern is to wrap the loader in a Promise that races against a setTimeout. When the timeout wins, call abort() on the controller and reject the promise.

Assumptions and Verification

This approach assumes the use of a Three.js version where FileLoader propagates the signal to the fetch API. To verify this behavior:

• Open the Browser Network Tab; trigger the abort and confirm the request status changes to (canceled).
• Log the LoadingManager item count before and after the abort to ensure the manager is not indefinitely waiting for a file that will never arrive.

Diagnostic Detail Needed: Are you using a custom FileLoader implementation or a specific Three.js version older than r150? If so, the signal may not propagate, requiring a manual override of the FileLoader.prototype.load method.