Alle Klassen und Schnittstellen
Klasse
Beschreibung
Renders custom slot tooltips on inventory screens via EngineSlot.
Base interface for all network packets.
A utility for Cubic Bézier easings.
Represents a complete Bézier path composed of multiple splines.
A control point on a Bézier path, which may be an anchor or tangent point.
Represents a cubic Bézier spline with control points and coefficients.
Implements
EngineBlockBehavior on BlockBehaviour to allow runtime property modification.Implements
EngineBlockStateBehavior on BlockStateBase via accessor mixins.Font definition IDs for the built-in JetBrains Mono Nerd Font family.
Generates data (recipes, loot tables, models, etc.) for all loaded bundles.
Debug Entry to display info about Bundles.
Handles discovery, dependency sorting, and loading of bundles from the file system.
An Entrypoint to a Bundle.
A Record of data related to Bundle Files.
Utility class for building BundleFiles from a root directory.
Packet sent from Client to Server to verify bundle directory synchronization.
Similar to
All specified in "${bundleId}.bundles.toml"
IModInfo
All specified in "${bundleId}.bundles.toml"
Bundle Manager that manages Bundle Lifecycles.
Parses the Toml for a bundle.
Creates TOML content from BundleInfo.
Overrides camera depth/near/far values with client-configured values.
Chat-based dialogue display.
Chat icon components using a custom font for engine UI elements.
Allows chunk generators other than noise chunk generators to provide custom chunk generator settings.
Redirects NoiseGeneratorSettings lookup to use the chunk generator's custom settings if available.
Client-side singleton providing access to all client subsystems and utility methods.
Server-to-client packet for dialogue lifecycle.
Client-side cutscene playback manager.
Client-side counterpart to
DialogueManager.Accessor for clock instance internals (paused, totalTicks, partialTick, rate).
Utility class for handling Colors.
Attachment for executing server commands at a specific point in the cutscene.
Shared constants and singleton managers for FoundryEngine.
Registers the four NeoForge config types (client, server, common, startup).
A Panel to display the Console output in game.
Implements
EngineSlot on the creative inventory slot wrapper.Base class for all cutscene attachments.
Overrides camera position and rotation during cutscenes.
Server-side tracker for active cutscene playbacks per player (used for temporary invulnerability etc.).
Dedicated cutscene timeline / preview / effects panel.
Shared UI state between the Cutscene panels.
Resolves
DataComponentType by field name from DataComponents.A named action executed during dialogue traversal (enter, option-select).
/engine dialogue — controls the dialogue system.A named predicate controlling whether a node or option is accessible.
Controls how dialogue is presented on the client.
A single node in a dialogue tree.
A selectable option within a
DialogueNode.Server-bound packet to load a full dialogue tree state from the ImGui editor.
Tracks an in-progress dialogue for a single player on the server.
Style configuration for dialogue rendering.
A named set of style values.
A named collection of
DialogueNodes with a designated root node.Command to dump Registry data to a file.
A
RepositorySource that serves paths from a dynamic supplier as a virtual resource pack.The Easing class holds a set of general-purpose motion
tweening functions by Robert Penner.
A base class for Back easings.
Back easing in - backtracking slightly, then reversing direction and moving to target.
Back easing in/out - backtracking slightly, then reversing direction and moving to target,
then overshooting target, reversing, and finally coming back to target.
Back easing out - moving towards target, overshooting it slightly, then reversing and coming back to target.
A base class for elastic easings.
An Elastic easing used for ElasticIn functions.
An Elastic easing used for ElasticInOut functions.
An Elastic easing used for ElasticOut functions.
Attachment for screen effects (post-processing shaders).
Configures block behavior properties such as collision, resistance, sounds, and friction.
Configures block state behavior properties such as light emission, destroy speed, and tool requirements.
Util for creating commands for the /engine command.
Wrapper around Minecraft's DataGenerator for Foundry Engine data generation.
Controls dimension save behavior and save properties for level stems.
Base runtime exception for Foundry Engine errors.
Extends the game renderer with pre- and post-render hooks for head and return rendering.
Provides access to GPU device backend information.
Base interface for all engine mixin interfaces, providing a self-cast helper.
Extends keyboard input handling with key press and character typed hooks.
Controls server level ticking behavior when no players are present.
Manages additional storage paths, world path resolution, and instanced world management.
A Log Appender to make the
ConsolePanel work.Extends the Minecraft client with init, close, and per-tick gizmo hooks.
Extends mouse input handling with button and scroll event hooks.
Implements
ParticleContext so that GenericParticleData implementations
can call particle methods without importing any net.minecraft.client types.Processes a post-chain with external render targets and a graphics resource allocator.
Allows removing entries from a
MappedRegistry and toggling its frozen state at runtime.Exposes the internal clock instances of a
ServerClockManager.Customizes inventory slot behavior (position, locking, tooltips).
Centralized error handler for script errors with server broadcast support.
Maps file extensions to file icons.
Simple Util to check if it's a mods first load.
Computes SHA-256 hashes of folder contents for change detection.
Command Registry.
Registers commands that reference client-only classes (e.g.
Companion plugin shared by every FoundryEngine mixin config.
Main entrypoint for FoundryEngine.
Client-side entrypoint for FoundryEngine.
Dedicated server entrypoint for FoundryEngine.
A class which can handle a value which is freezable.
Persistable data container identified by an Identifier, backed by NBT compounds.
Manages the lifecycle and tick dispatch of game sessions, scoped per world.
Mixin to render ImGui and custom Post Chain stuff
A single game session with configurable tick and lifecycle handlers.
Events fired during game session lifecycle transitions.
A Generic Particle Data class, extended to add function to a Particle via
ParticleContextA Registry for registering things.
Thread-safe implementation of
RegistryList backed by CopyOnWriteArrayList.Accessor to retrieve the native OpenGL handle from a GlBuffer.
Implements
EngineGpuDevice to expose the GPU device backend.Event posted once when the global
ScriptShell is initialized.Command to supply info about the item you're holding.
Client-side rendering contract for dialogue displays.
Minimal ImGui font manager.
Ported ImGui OpenGL3 Backend tailored for Minecraft's Blaze3D GlStateManager
with safe Multi-Viewport support.
Data class to store implementation specific fields.
This class is a straightforward port of the
imgui_impl_glfw.cpp.
Data class to store implementation specific fields.
The Central ImGui Manager.
The ImGui Window type.
A Wrapper around a custom Char which is an icon.
A Library of Icons.
Mixin to render offhand arm when empty and handle item-in-hand rendering overrides.
See
ImGuiManager.shouldInterceptKeyboard()
Cancels Minecraft Keyboard inputs if ImGui captures the keyboard.Implements
EngineDimensionOptions on LevelStem to control per-dimension save behavior.Implements
EngineLevelStorageSource on LevelStorageSource to support additional paths and instanced worlds.A record for a normal style formatted log entry.
The Main Menu implementation.
Implements
EngineRegistry and WritableRegistry on MappedRegistry to support entry removal and freezing.Visitor that converts GFM Markdown AST to Minecraft Components.
Utility class for parsing Markdown into Minecraft Components.
A single material parsed from a
.mtl file.Screen that displays GFM markdown content with scrolling support.
A
ButtonWidget that renders and behaves like a vanilla Minecraft button:
nine-slice sprite (enabled / highlighted / disabled), centered label with drop shadow,
a click sound and the pressed label offset while held.A
WidgetBase that renders like a vanilla Minecraft checkbox: a 17x17 box with the
selected check sprite, a hover highlight and a label rendered to the right.Mixin to enable things when Minecraft starts, and to remove things when Minecraft closes.
A
WidgetBase that renders like a vanilla Minecraft slider: a track sprite with a
draggable handle, a hover highlight and a centered label.See
ImGuiManager.shouldInterceptMouse()
Cancels Minecraft Mouse inputs if ImGui captures the Mouse.An Exception which is thrown when a Mixin should have implemented a Method but hasn't.
Lists every resource in every loaded pack by walking the real backing filesystem paths
directly, instead of going through ResourceManager#listResources(path, predicate).
The Style of an ImGui Window.
Pre-defined permission checks for command and chat access levels.
Redirects clock manager lookup to use the per-level clock instead of the server-level one in sendLevelInfo.
A base class for creating and managing ImGui popups in the Foundry Engine.
Implements
EnginePostChain on PostChain for external target processing.Accessor for PostPass custom uniform buffers.
Accessor for PostChain's internal pass list.
Generic Priority Enum for ordering and prioritization.
Generic registry interface for key-value storage with freeze support.
A registry interface for ordered lists of values with freeze support.
A Reference to an Entry in a
Registry / GenericRegistry.Command to reload all bundles.
Wraps reload resources to add a success feedback message.
Allows registering
RenderPipeline.A configuration describing how a runtime level should be constructed.
Central persistence and sync for FoundryEngine's engine data.
Screen-based dialogue display using the widget system (EngineScreen + PanelWidget / ButtonWidget / TextWidget).
Shared CompilerConfiguration for all Groovy scripting in FoundryEngine.
Sandbox restrictions for Groovy script execution.
A class loader that enforces
ScriptSandbox.isClassAllowed(String) before
delegating to the real class loader.Global Groovy script shell for compiling bundle scripts.
Runs script code on a daemon worker thread with a configurable timeout so
that a hung entrypoint cannot block the mod loader forever.
Thrown when a script operation exceeds its configured execution timeout.
Shared server-side utilities and helpers for FoundryEngine.
Client-to-server packet for dialogue interaction.
Prevents chunk tasks from executing when the level should not tick.
Implements
EngineServerClockManager to expose clock instances and redirect broadcasts per-level.Implements
EngineLevelAccess on ServerLevel to support tick-when-empty and per-level clock routing.Accessor for ShaderManager's post-chain projection fields.
An Inline Implementation of a DebugScreenEntry.
An inline implementation for a DebugRenderer.
Implements
EngineSlot on Slot to support custom tooltips and disabled override.A simple condition for a player, to check things easily.
Manages additional world storage directories and world instancing for pack distribution.
Use
BlockTagBuilder and ItemTagBuilder or this with a Wildcard if you know what you're doingRedirects clock manager lookups in time commands to use the source level's clock.
Fires
TitleScreenModificationEvent when singleplayer/multiplayer/realms buttons are pressed.A
ChunkGenerator instance that does not know how to be, and does not care to be serialized.Converts string input to a typed value.
Thrown when a utility class is instantiated via its private constructor.
Canonical waypoint data model.
Filters world dimensions to exclude those with save-properties disabled during world gen.
Builds a world-space Model-View-Projection (MVP) matrix from the camera state.