Struct Registry 

pub struct Registry { /* private fields */ }

Implementations

impl Registry

pub unsafe fn from_raw(api: *const YogApi) -> Self

Build from the pointer passed by the runtime. Only called by export_mod!.

Safety

api must point to the runtime’s YogApi table, valid for the rest of the process.

pub fn on_block_break<F>(&mut self, handler: F)

where F: Fn(&BlockBreakEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_chat<F>(&mut self, handler: F)

where F: Fn(&ChatEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_join<F>(&mut self, handler: F)

where F: Fn(&PlayerJoinEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_leave<F>(&mut self, handler: F)

where F: Fn(&PlayerLeaveEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_use_item<F>(&mut self, handler: F)

where F: Fn(&UseItemEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_use_block<F>(&mut self, handler: F)

where F: Fn(&UseBlockEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_attack_entity<F>(&mut self, handler: F)

where F: Fn(&AttackEntityEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_damage<F>(&mut self, handler: F)

where F: Fn(&EntityDamageEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_death<F>(&mut self, handler: F)

where F: Fn(&EntityDeathEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_spawn<F>(&mut self, handler: F)

where F: Fn(&EntitySpawnEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_place_block<F>(&mut self, handler: F)

where F: Fn(&PlaceBlockEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_death<F>(&mut self, handler: F)

where F: Fn(&PlayerDeathEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_respawn<F>(&mut self, handler: F)

where F: Fn(&PlayerRespawnEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_advancement<F>(&mut self, handler: F)

where F: Fn(&AdvancementEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_entity_interact<F>(&mut self, handler: F)

where F: Fn(&EntityInteractEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_item_craft<F>(&mut self, handler: F)

where F: Fn(&CraftEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_machine_craft<F>(&mut self, handler: F)

where F: Fn(&MachineCraftEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

A machine making a recipe — see MachineCraftEvent.

pub fn on_explosion<F>(&mut self, handler: F)

where F: Fn(&ExplosionEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_item_pickup<F>(&mut self, handler: F)

where F: Fn(&ItemPickupEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_player_move<F>(&mut self, handler: F)

where F: Fn(&PlayerMoveEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_container_open<F>(&mut self, handler: F)

where F: Fn(&ContainerOpenEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_container_close<F>(&mut self, handler: F)

where F: Fn(&ContainerCloseEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_projectile_hit<F>(&mut self, handler: F)

where F: Fn(&ProjectileHitEvent, EventPhase, &dyn Server) -> bool + Send + Sync + 'static,

pub fn on_tick<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_server_started<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_server_stopping<F>(&mut self, listener: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_command<F>(&mut self, name: impl AsRef<str>, handler: F)

where F: Fn(&CommandContext, &dyn Server) -> Option<String> + Send + Sync + 'static,

pub fn on_typed_command<F>( &mut self, name: impl AsRef<str>, schema: impl AsRef<str>, handler: F, )

where F: Fn(&CommandContext, &dyn Server) -> Option<String> + Send + Sync + 'static,

Register a command with Brigadier-typed arguments.

schema is a space-separated list of argument types: int, float, word, string (greedy, must be last), player, blockpos.

In the handler use ctx.arg_int(0), ctx.arg_blockpos(1), etc.

pub fn on_packet<F>(&mut self, channel: impl AsRef<str>, handler: F)

where F: Fn(&PacketEvent, &dyn Server) + Send + Sync + 'static,

pub fn on_client_packet<F>(&mut self, channel: impl AsRef<str>, handler: F)

where F: Fn(&PacketEvent, &dyn Server) + Send + Sync + 'static,

pub fn on_typed_packet<P, F>(&mut self, channel: impl AsRef<str>, handler: F)

where P: Packet + Send + Sync + 'static, F: Fn(&P, &dyn Server) + Send + Sync + 'static,

Register a typed-packet handler.

The payload is decoded from raw bytes using P’s Packet impl. Malformed payloads are silently dropped.

pub fn add_recipe(&mut self, recipe: Recipe)

Register a recipe (Yog’s format — see Recipe; the host writes its Minecraft version’s JSON).

pub fn add_recipe_json(&mut self, id: &str, json: &str)

Register a recipe given as Yog’s recipe JSON — how yog build registers the mod’s own kinds ({"type": "mymod:infusion", "slots": …}), which stay the mod’s data: for its machines and its books.

pub fn register_item(&mut self, def: ItemDef)

pub fn register_block(&mut self, def: BlockDef)

pub fn add_biome_feature(&mut self, feature: &str, biomes: &str, step: &str)

Add placed feature feature (the mod’s datapack’s, like an ore’s mymod:mythril_ore) to the biomes of tag biomes at generation step (underground_ores). An ore .ydef does this for you.

pub fn register_tool_material(&mut self, material: ToolMaterial)

Register a tool material — what tool items naming it (ItemDef::tool) are made of. The game’s are built in.

pub fn register_armor_material(&mut self, material: ArmorMaterial)

Register an armor material — what armor items naming it (ItemDef::armor) are made of. The game’s are built in.

pub fn register_sound_group(&mut self, group: SoundGroup)

Register a sound group — what blocks naming it (BlockDef::sound) sound like. The game’s groups are built in.

pub fn register_inventory(&mut self, def: InventoryDef)

Register a real Container/Menu inventory screen — see yog_inventory::InventoryDef. Attach it to a block via BlockDef::inventory(id).

pub fn register_startup_grant(&mut self, grant: StartupGrant)

Register a startup grant: items/books to give once when a player first joins.

pub fn register_book(&mut self, book: &Book)

Register a book.

pub fn register_book_data(&mut self, id: &str, data: &[u8])

Register a book given as Yog Data, binary — what yog build makes of a content/**/*.ybook; the bytes go to the runtime as they are.

pub fn register_dimension(&mut self, def: &YogDimensionDef)

Register (or patch) a dimension’s type (sky, lighting, physics, …).

def.id need not be a new custom id — pass a vanilla id ("minecraft:overworld", "minecraft:the_nether", "minecraft:the_end") to patch that dimension’s type/generator instead of creating a new one (e.g. to replace the overworld’s terrain with your own generator type).

Must be called from register() — the same mod-init window as blocks/items — so the host can declare/patch the dimension before Minecraft’s registries freeze. See the yog-dimensions crate docs; set def.generator_type (via YogDimensionDef::generator_type) to pick a generator type registered with Registry::register_chunk_generator.

pub fn register_dimension_data(&mut self, id: &str, data: &[u8])

Register a dimension given as Yog Data, binary — what yog build makes of a .ydef of kind dimension (its terrain generated by the runtime itself); the bytes go to the runtime as they are.

pub fn register_chunk_generator<F>( &mut self, generator_type_id: &str, generator: F, )

where F: Fn(&ChunkWriter) + Send + Sync + 'static,

Register a named, reusable chunk-generator type under generator_type_id (e.g. "mymod:custom_terrain") — analogous to how Biomes O’Plenty registers selectable world-type presets. Any dimension (custom or vanilla) can opt into this generator via YogDimensionDef::generator_type; the platform host may also list registered generator type ids as options on the world-creation screen.

generator is called once per chunk column that needs generating in any dimension using this type — write whatever terrain logic you want using the ChunkWriter handle (combine as many noise layers as you like; this crate doesn’t prescribe a generation style).

pub fn installed_mods(&self) -> Vec<ModInfo>

Register a menu entry — the host renders a button on vanilla screens (TitleScreen on Fabric, ModListScreen on Forge/NeoForge) that opens ui_id. label is the human-readable button text (e.g. “Yog Mods”). ui_id is the UI to open when clicked (e.g. “example:menu”). See installed_mods. During register() the list only contains mods loaded before this one.

pub fn interop(&self) -> Interop

Access the inter-mod communication layer.

Allows exporting function pointers from this mod and importing function pointers from other mods.

pub fn raw_api(&self) -> *const YogApi

Raw YogApi pointer — for passing to interop-imported functions that register content through the C ABI table directly.

pub fn register_menu_entry(&mut self, label: &str, ui_id: &str)

pub fn register_ui<F, R>(&mut self, ui_id: &str, handler: F)

where F: Fn(&str, &str) -> R + Send + Sync + 'static, R: UiHandled,

Register a UI tree with an event callback. ui_id is the unique identifier (e.g. “mymod:menu”). handler receives (ui_id, event) for the screen’s input: click:X:Y, drag:X:Y, release:X:Y, scroll:DY, key:KEY:MODS (GLFW key code and modifier bits, on press and repeat) and char:CODEPOINT (a typed character). It returns () or a bool: true marks a key:/char: event as used, so the host skips its default handling of the key (Esc closing the screen, …) — see UiHandled.

pub fn schedule_once<F>(&self, delay_ticks: u64, handler: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn schedule_repeating<F>(&self, period_ticks: u64, handler: F)

where F: Fn(&dyn Server) + Send + Sync + 'static,

pub fn on_client_tick<F>(&mut self, handler: F)

where F: Fn(&ClientTickEvent) + Send + Sync + 'static,

Register a handler called every client tick (render thread, no server).

pub fn on_ui_render<F>(&mut self, ui_id: &str, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a render callback for a specific UI screen (ui_id).

Called from YogUIScreen.render() — i.e. AFTER renderBackground() darkens the screen — so your UI draws on top of the dimmed world view. Use this instead of on_hud_render for book/inventory screens.

Clicks are forwarded as "click:X:Y" via the register_ui handler so you can do hit-testing on your own stored layout.

pub fn on_book_page<F>(&mut self, drawer: &str, handler: F)

where F: Fn(&GfxContext, &Value, [f32; 4]) + Send + Sync + 'static,

Draw the pictures of book pages of type drawn whose drawer is drawer ("mymod:diagram"): handler gets the page’s data and the picture’s box [x, y, w, h] in screen pixels, every frame the page is open.

{ type: "drawn", drawer: "mymod:diagram", title: "Wiring", height: 64,
  caption: "{u|in} → {u|out}", text: "…", data: { nodes: 3 } }

pub fn on_item_tooltip<S, D>(&mut self, item: &str, size: S, draw: D)

where S: Fn(&str, &str) -> Option<(f32, f32)> + Send + Sync + 'static, D: Fn(&GfxContext, &str, &str, [f32; 4]) + Send + Sync + 'static,

A picture under the tooltips of item (as Hex Casting’s scrolls show their pattern): size(item, snbt) says whether a stack — its custom data as SNBT — gets one and its size in GUI pixels; draw draws it in the box [x, y, w, h] (screen pixels) while the tooltip shows.

pub fn on_item_text<F>(&mut self, item: &str, text: F)

where F: Fn(&str, &str) -> Option<(Option<String>, Vec<String>)> + Send + Sync + 'static,

A stack’s own name and tooltip, from its custom data (SNBT): text(item, snbt) gives Some((name, lines)) — name None keeps the item’s; lines stand instead of the item’s description — or None for the item’s own. A written blueprint names its design:

registry.on_item_text(Items::BLUEPRINT, |_, snbt| {
    let bp = Blueprint::from_nbt(snbt)?;
    Some((Some(bp.name.clone()), vec![format!("{} ports", bp.ports)]))
});

pub fn on_hud_render<F>(&mut self, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a handler called every frame when the HUD is rendered.

gfx provides full GPU pipeline access plus 2D convenience draw calls. view_proj and camera_pos are zero in HUD context; use gfx.draw2d() for HUD elements.

pub fn on_world_render<F>(&mut self, handler: F)

where F: Fn(&GfxContext) + Send + Sync + 'static,

Register a handler called every frame at the end of world rendering.

gfx.view_proj() is the combined projection × view matrix (camera-relative). gfx.camera_pos() is the camera world position. To render at world position P, translate by P - camera_pos before drawing.

pub fn on_key_press<F>(&mut self, handler: F)

where F: Fn(&KeyPressEvent) -> bool + Send + Sync + 'static,

Register a handler for keyboard input (client-side). Return false to prevent Minecraft from processing the key.

pub fn on_screen_open<F>(&mut self, handler: F)

where F: Fn(&ScreenEvent) + Send + Sync + 'static,

Register a handler called when a GUI screen is opened.

pub fn on_screen_close<F>(&mut self, handler: F)

where F: Fn(&ScreenEvent) + Send + Sync + 'static,

Register a handler called when a GUI screen is closed.

Trait Implementations

impl Send for Registry

impl Sync for Registry