Struct StateTree 

pub struct StateTree { /* private fields */ }

Where a project’s state lives, and what hangs off it.

Built by whatever runs the process – the dev CLI from its project directory, a shipped application from the directory beside its executable, an embedder from whatever its own layout implies – and passed down. Library code is handed one; it never resolves a root for itself.

Three roots, because the three fall apart on real installs:

• the content root holds what a build produces and reads (data/, assets/, worlds/),
• the writable root holds what the running application writes (saves/, settings, crashes/), split away when the content root is a read-only install such as Program Files,
• the cache root holds the regenerable segments, split away when the caches should outlive (or be shared across) the content beside them.

An unsplit tree resolves all three at the content root, which is the single-folder layout a portable install and a dev checkout both use.

Implementations

impl StateTree

pub fn at<P>(content: P) -> StateTree

where P: Into<PathBuf>,

A tree with every root at content.

pub fn with_writable<P>(self, dir: P) -> StateTree

where P: Into<PathBuf>,

Move the runtime-writable state to dir, leaving the content where it is: a read-only install writes its saves and settings per-user.

pub fn with_cache<P>(self, dir: P) -> StateTree

where P: Into<PathBuf>,

Move both cache segments to dir. Anchors the regenerable artifacts away from the content and the writable state, so a warm cache can sit behind a content root that is read-only, or freshly built, or both.

pub fn content_root(&self) -> &Path

The root holding what a build produces and reads.

pub fn writable_root(&self) -> &Path

The root holding what the running application writes.

pub fn assets_dir(&self) -> PathBuf

The state root’s assets/ directory.

pub fn data_dir(&self) -> PathBuf

The state root’s data/ directory.

pub fn worlds_dir(&self) -> PathBuf

The state root’s worlds/ directory.

pub fn saves_dir(&self) -> PathBuf

Directory holding the runtime save files. Created on first write by the running application, never by a build.

pub fn preview_saves_dir(&self) -> PathBuf

Sandboxed sibling of saves_dir for preview sessions: the save UI keeps working against this directory, the real saves are never touched, and the sandbox is wiped at each session start.

pub fn settings_path(&self) -> PathBuf

The mutable settings file, written by the in-engine settings menu and never by a build.

pub fn crashes_dir(&self) -> PathBuf

Directory holding crash reports. Created on first write; capped by the writer’s retention pruning.

pub fn editor_session_path(&self) -> PathBuf

The editor’s session store: the per-project state an editor run carries between launches, which is state rather than cache.

pub fn runtime_cache_path(&self) -> PathBuf

The segment a running application writes: one container holding every regenerable artifact it produces for its own later launches, indexed by producer and key.

Deletable at any time; whatever is missing is recomputed. The application writes this file and no other, so a concurrent build writing a segment of its own never shares a file with it.

pub fn bundled_runtime_cache_path(&self) -> PathBuf

The runtime segment a bundle ships, read-only. cn export warms it with the shader binaries a first launch would otherwise compile; because those artifacts are backend IR (DXBC / SPIR-V) rather than machine code, one warmed at package time is valid on any machine.

Always resolves against the content root, so it stays readable on a read-only install. That is also the only thing separating it from runtime_cache_path: a bundle the player can write to has one segment serving both roles.

pub fn build_cache_path(&self) -> PathBuf

The segment a build writes: one container holding every payload, expansion, and baked thumbnail a cook produced, indexed by producer and key.

Deletable at any time; whatever is missing is recompiled.

Trait Implementations

impl Clone for StateTree

fn clone(&self) -> StateTree

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for StateTree

impl PartialEq for StateTree

fn eq(&self, other: &StateTree) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StateTree