Asset type dispatcher Confirmed

At a glance

Magic

none - the type byte is the top 8 bits of a u32 packed with the 24-bit size

Where on disc

every DATA_FIELD chunk header and every asset descriptor carries one

Dispatcher

FUN_8001F05C in SCUS_942.54

Parser

crates/asset/src/lib.rs::AssetType

Confidence

Confirmed - the dispatcher is dumped in full, and the developers' own malloc-error strings name each type (how we know)

Used by

asset loader, LZS decoder (the compressed path)

What a type byte is

Legaia's containers do not label their contents with a per-format magic word the way a PNG or a ZIP does. The container that carries an asset - a streaming chunk or a descriptor table - stores a one-byte code next to its size, and the code alone decides what happens next: which buffer is allocated, whether the bytes are copied or LZS-decompressed, and which subsystem is told "your data has arrived". The code space is a dozen values, fixed in the executable, so the same table serves every scene, battle and menu on the disc.

Calling convention

result = FUN_8001f05c(byte *src_data, u32 type_and_size, int param3, int copy_only);

• type_and_size packs type in the high 8 bits, size in the low 24 bits.
• copy_only != 0 → the asset is uncompressed and is copied into its buffer.
• copy_only == 0 → the asset is LZS-compressed and goes through the LZS decoder, the game's dictionary decompressor.

Type table

The full type space, with the bit each type contributes to the return value. The names are the developers' own: each type has a per-type malloc-error string in the executable.

Return-value bitfield

Every return is a small bitfield - one bit per data-bearing type, and type << 8 for the markers. Both callers (the streaming walker and the descriptor walker) OR every return into one accumulator, so the result summarises what a whole stream contained:

return_value & 0x00FF  = bit per data-bearing asset type seen
return_value & 0xFF00  = bit per FLAG-type marker seen

Why FLAG types exist

The FLAG cases let the dispatcher accept chunks whose type byte falls outside the data-bearing range without aborting the streaming walk. The walker still skips the data bytes (advance = 4 + (size & ~3)), but the dispatcher never reads them. FLAG chunks are stream-level out-of-band markers: any caller that looks at the returned bitfield can detect "this stream contained a 0x14-typed marker" without the marker carrying a parsed asset. Where the markers are consumed is open - possibly by code that reads past the streaming terminator (the DATA_FIELD trailer).

AssetType Rust enum

pub enum AssetType {
    Tim,        // 0
    TimList,    // 1
    Tmd,        // 2
    Man,        // 3
    Mes,        // 4
    Move,       // 5
    Anm,        // 6
    Vdf,        // 7
    Sin,        // 8
    Tmd2,       // 9
    Move2,      // 0xB
    Flag(u8),   // 0xA, 0xF, 0x14
    Unknown(u8),
}

Who calls the dispatcher

Two call sites exist, and only one is visible from the executable's static call graph. The other is reached from the town/field overlay - a chunk of MIPS code the game loads into RAM on demand, where most game logic lives. Zero static callers does not mean dead.

How we know

Full page: docs/formats/asset-type.md.

See also