Struct InventoryDef 

pub struct InventoryDef {
    pub id: String,
    pub slot_count: usize,
    pub layout: Vec<SlotLayout>,
    pub include_player_inventory: bool,
    pub player_inv_offset: (f32, f32),
    pub background_texture: Option<String>,
    pub title: String,
    pub background_size: Option<(f32, f32)>,
    pub machine: Option<Machine>,
}

Describes one inventory-backed screen: how many slots a mod block has, where they sit, whether the player’s own inventory is appended below, and which background texture to draw (vanilla default, or a mod’s own).

Fields

id: String

slot_count: usize

layout: Vec<SlotLayout>

Per-slot pixel positions. Empty = auto-generate a default grid (see InventoryDef::default_grid).

include_player_inventory: bool

Appends the player’s main inventory (3×9) + hotbar (9) below the custom slots — no armor, no offhand. Native vanilla slot rendering.

player_inv_offset: (f32, f32)

background_texture: Option<String>

None = default vanilla-style panel texture.

title: String

background_size: Option<(f32, f32)>

Screen size to center the container on — None uses the vanilla default (176×166). Set this when a custom on_ui_render overlay draws decoration at a different size, so the real vanilla Slots (positioned by layout/player_inv_offset relative to the container’s top-left corner) land under that decoration instead of the two disagreeing about where the top-left corner even is.

machine: Option<Machine>

A machine’s part of it (.yui <RecipeArea kind="…">): its slots make recipes of a kind, like a crafting table.

Implementations

impl InventoryDef

pub fn new(id: impl Into<String>, slot_count: usize) -> InventoryDef

pub fn machine(self, machine: Machine) -> InventoryDef

Makes part of it a machine (see Machine).

pub fn layout(self, layout: Vec<SlotLayout>) -> InventoryDef

Explicit per-slot pixel positions, overriding the default grid.

pub fn layout_from_text(self, text: &str) -> InventoryDef

Remap the slot grid from Yog Data text (JSON too): a list of {x, y} — one entry per slot, in slot-index order. Lets users/mod-packs override the layout without recompiling. Text that doesn’t read is ignored (falls back to whatever layout was set before, or the default grid).

pub fn include_player_inventory(self, v: bool) -> InventoryDef

Whether the player’s main inventory + hotbar (no armor/offhand) is appended below the custom slots. Default: true.

pub fn player_inv_offset(self, x: f32, y: f32) -> InventoryDef

pub fn background_texture(self, path: impl Into<String>) -> InventoryDef

Custom background texture (resource path); None keeps the default vanilla-style panel.

pub fn background_size(self, w: f32, h: f32) -> InventoryDef

Size (in GUI pixels) a custom on_ui_render overlay draws its decoration at — used to center the real vanilla container on the same footprint so its Slots land under that decoration. Leave unset to keep the vanilla default 176×166 centering.

pub fn title(self, title: impl Into<String>) -> InventoryDef

pub fn resolved_layout(&self) -> Vec<SlotLayout>

Resolve the effective slot layout: the explicit one if set, otherwise InventoryDef::default_grid.

pub fn default_grid(slot_count: usize) -> Vec<SlotLayout>

Default vanilla-style grid: up to 9 columns, 18px spacing, starting at (8, 18) — leaves room for a title above, matches vanilla containers.

Trait Implementations

impl Clone for InventoryDef

fn clone(&self) -> InventoryDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InventoryDef

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

Formats the value using the given formatter.

impl Fields for InventoryDef

const FIELDS: &'static [(&'static str, &'static str)]

impl Schema for InventoryDef

fn encode(&self, __yog_w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(__yog_d: &mut Decoder<'_>) -> Option<InventoryDef>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, __yog_p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(__yog_u: &mut Unpacker<'_>) -> Option<InventoryDef>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<InventoryDef>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.