Struct BlobData 

pub struct BlobData { /* private fields */ }

Holds the raw payload sections of each blob file.

Indexed by PayloadLocator::blob_index. Blob 0’s payload section is loaded eagerly by load_raw() – it carries the defs and the primary payloads and is needed immediately. Overflow blobs (1, 2, …) start Unloaded and are read from disk on demand the first time a locator references them, so a large world does not pay the RAM (or I/O) cost of every overflow blob at startup.

Systems call release(blob_index) after consuming a blob’s payloads (e.g. after uploading SPIR-V to the GPU) so the memory is freed promptly.

Implementations

impl BlobData

pub fn new(payload_sections: Vec<Option<Vec<u8>>>) -> BlobData

Build an in-memory store where every section is already resident. Used by the cn debug path, which compiles payloads in memory with no blob files, so there is nothing to lazily load. A None section is treated as already released.

pub fn empty() -> BlobData

empty store for worlds with no compiled payloads (tests, runtime-only worlds)

pub fn disk_backed(&self) -> bool

true when the payloads were loaded from blob files on disk, so a streamed payload can be re-read from disk rather than kept in RAM

pub fn read(&mut self, locator: &PayloadLocator) -> Result<&[u8], CnResult>

read the bytes for a given locator

An Unloaded overflow blob is read from its file on first access and becomes Loaded. Errors if the locator is out of range, the blob was released, or the on-demand load fails.

pub fn release(&mut self, blob_index: u32)

release a blob’s in-memory payload once all systems that need it have finished consuming it (e.g. after GPU upload)

subsequent read() calls for locators in this blob return an error rather than reloading – the data is known to no longer be needed – so only call this once you are sure no other system needs it

pub fn release_all_resident(&mut self) -> usize

Release every payload section still resident, called once every system has finished init. Systems read compiled payloads only during init and cache what they keep (GPU uploads, decoded audio clips, streaming sources that own their extracted bytes or re-read from disk), so nothing consults BlobData again at runtime – the resident sections are dead weight past World::start. Never-loaded overflow slots are left as they are: they hold only a file path and were needed by no system. Returns the number of bytes freed.

Trait Implementations

impl PayloadStore for BlobData

fn read(&mut self, locator: &PayloadLocator) -> Result<&[u8], CnResult>

Read the bytes a locator points at. &mut self because a disk-backed store may load an overflow section lazily on first access. Errors when the payload was released, the locator is out of range, or a lazy load fails.

fn release(&mut self, blob_index: u32)

Release an entire blob’s in-memory payload once every system that needs it has finished (e.g. after GPU upload). A store with nothing resident for blob_index treats this as a no-op.

fn disk_backed(&self) -> bool

Whether the payloads are backed by files still on disk, so a released payload can be re-read on demand rather than kept RAM-resident.

fn release_all_resident(&mut self) -> usize

Release every resident section at once, returning the bytes freed. World::start calls this after init: systems read compiled payloads only while initing and cache what they keep, so nothing consults the store again. A store with nothing resident frees nothing.