ResourceLoader

public static ResourceLoaderInstance Singleton { get; }

Borrowed wrapper of the global ResourceLoader, not a fresh loader per access. Do not Free()/Dispose() the engine-owned Singleton. Use static methods for ordinary operations; register ResourceFormatLoader separately.

public static void AddResourceFormatLoader(ResourceFormatLoader formatLoader, bool atFront = false);

Adds an owned format loader to the global list; atFront=true gives priority over current handlers. Retain the instance until explicit unregistration. Repeating the same instance adds a duplicate rather than updating it; tested. Invalid objects/capacity exhaustion produce diagnostics with no separate Error. Do not register anew before each Load.

public static bool Exists(string path, string typeHint = "");

Checks cache/loader resource existence, not necessarily a valid disk file. A cached resource gives true even after file deletion and before typeHint filtering. A malformed file with a recognized extension can also give true without parsing. This guarantees neither successful Load<T>() nor a matching C# type; check loading separately.

public static Resource GetCachedRef(string path);

Gets a cached Resource or null without loading a cache miss. Can return the same C# wrapper already used elsewhere, confirmed by ReferenceEquals. Early Dispose of that wrapper invalidates other managed aliases. Coordinate shared lifetime rather than independently disposing each alias. Not a clone or disk refresh.

public static string[] GetDependencies(string path);

Collects declared external dependencies through format loaders, not a recursive loaded-object tree. An entry may be an ordinary path or UID::type::fallback record; the public wrapper does not add types, so the middle field can be empty. Do not pass a composite record directly to a filesystem API. Empty does not distinguish no dependencies from unsupported/failed format handling. Import, UID remaps and custom loaders can affect representation.

public static string[] GetRecognizedExtensionsForType(string type);

Queries registered loaders for an engine type name, not C# System.Type. Empty can query the general set. Names have no leading dot; duplicates and plugin-registration changes are possible. The list proves no individual file existence, import state or validity.

public static string GetResourceType(string path);

Asks loaders for resource type metadata by path and can perform I/O. Not a C# cast or full-load guarantee. A custom C# resource reported engine base type may differ from its managed class name. Empty means no recognized type, not a detailed Error.

public static long GetResourceUid(string path);

Game runtime queries the ResourceUid reverse registry by normalized path, not every file UID header. Unknown paths return InvalidId. A stale reverse entry after SetId/RemoveId can return an ID without current HasId(). The editor uses a different loader path; editor scanning was not tested here.

public static bool HasCached(string path);

Checks a normalized path entry in resource cache. Loads no file and validates no data freshness, disk existence or actual type. A held resource can stay cached after file deletion/change. Does not guarantee the entry survives after all owners release it.

public static string[] ListDirectory(string directoryPath);

Lists immediate directory and recognized-resource names, not every physical file or a recursive tree. Directories end in /; .import/.remap/.uid sidecars collapse to the original name, with sorted deduplicated results. Extension recognition proves no valid parsing: a malformed .rdata appeared in the test. Empty can also follow directory-open/list-start failure. Export/import backends were not executed here.

public static Resource Load(string path, string typeHint = "", ResourceLoader.CacheMode cacheMode = ResourceLoader.CacheMode.Reuse);

Synchronously obtains a Resource through its format and cache mode; failure can return null with engine diagnostics. Creates no Entity: PackedEntity still needs Instantiate()/AddChild(). Reuse can return the same native object and C# wrapper; do not Dispose a shared wrapper while other aliases use it. On the tested text backend Ignore creates an independent top resource but reuses external dependencies; IgnoreDeep loads those independently. Replace can refresh a held compatible-type object; ReplaceDeep also refreshes external dependencies. Disk changes do not automatically update Reuse. Custom loaders must account for cacheMode.

public static T Load<T>(string path, string typeHint = null, ResourceLoader.CacheMode cacheMode = ResourceLoader.CacheMode.Reuse) where T : class;

Synchronously obtains a Resource through its format and cache mode; failure can return null with engine diagnostics. Creates no Entity: PackedEntity still needs Instantiate()/AddChild(). Reuse can return the same native object and C# wrapper; do not Dispose a shared wrapper while other aliases use it. On the tested text backend Ignore creates an independent top resource but reuses external dependencies; IgnoreDeep loads those independently. Replace can refresh a held compatible-type object; ReplaceDeep also refreshes external dependencies. Disk changes do not automatically update Reuse. Custom loaders must account for cacheMode. The generic wrapper only casts the native result to T. It does not infer typeHint from T; a mismatch can throw InvalidCastException rather than return null.

public static Resource LoadThreadedGet(string path);

Collects one accepted user-request result. Can wait/block before completion; normally wait for Loaded first. After Failed also finish request lifecycle, expecting null and loader diagnostics. One call reduces request count; two identical Requests need two collections. After all are collected status becomes InvalidResource. With no request/already consumed it returns null; the Resource can be a shared cached wrapper.

public static ResourceLoader.ThreadLoadStatus LoadThreadedGetStatus(string path, Reckfell.Collections.Array progress = null);

Returns status for the original request path string, not any equivalent OS path. InvalidResource can mean no request or all results already collected, not only a missing file. A supplied progress Array is overwritten with one 0…1 number, discarding existing elements; provide your own array. Use Loaded status, not progress alone, to decide ordinary collection. Do not busy-wait the main thread without frames.

public static Error LoadThreadedRequest(string path, string typeHint = "", bool useSubThreads = false, ResourceLoader.CacheMode cacheMode = ResourceLoader.CacheMode.Reuse);

Starts/acquires a user request for background Resource loading. Error.Ok does not mean ready: poll LoadThreadedGetStatus() across frames, then collect with LoadThreadedGet(). Use exactly the same path string throughout. A repeated path can share a token and increase the required Get count; one Get does not clear two requests. Do not assume new flags on a repeated Request reconfigure the existing token. Not an async C# Task, cancellation API or world-streaming system.

public static void RemoveResourceFormatLoader(ResourceFormatLoader formatLoader);

Removes the first registration of the instance. If added twice, one Remove leaves another entry; tested. Deletes no files and does not clear all cached resources. Remove all owned registrations before disposing the loader; missing/null instances produce diagnostics.

public static void SetAbortOnMissingResources(bool abort);

Changes global missing-dependency failure policy, not a per-Load option. The built-in text loader can continue with a missing dependency when false, without promising a usable resource or repaired schema. Abort concerns load failure, not a promise to terminate the game. Disables neither all parsing errors nor background requests. This pass source-reviewed the policy rather than executing damaged dependencies.