All Classes and Interfaces
Class
Description
The options every entry has.
A (optionally draggable) window whose content area shows a stack of
Panels.Another mod that animates vanilla models, made known so vanilla-model clips can share parts with it: where its
animation overlaps the clips' on a part, the model's
OverlapRule decides which shows.Everything one armature-driven thing is doing: its animation layers, procedural motion, joint styles and Molang variables.
The animators of armature-driven things on this client, for client code that wants to play something itself (the server's
way is
ArmatureControl).An armature by name: a modelled, animated thing drawn from a Blockbench or Bedrock file.
Something drawn at a point of an armature, moving with it: a lantern on a hook, a flame on a torch joint, a block on a
cart.
Draws a block entity with an armature, standing on the bottom of its block and turned to the block's
facing if it
has one (the model's front, north in Blockbench, toward that side).What an armature-driven block entity is drawn from, each frame.
Armatures on the client: the armature item model type, trails, and forgetting animators on leaving a world.
Carries out the server's armature commands on this client.
The server telling clients to do something to an armature: play a motion on a layer, stop a layer, or set a Molang
variable.
What one armature-driven thing is doing right now: the entity, block entity or item stack it belongs to, its clock, and its
Molang variables.
Animating armatures from the server: everyone who can see the entity, block or held item sees the same thing.
A model as a file reader leaves it: joints, faces, points, textures and clips, all in Blockbench's own axes (model
pixels, Y up, facing north).
One side of a cube: the texture rectangle
(u0,v0)-(u1,v1) (0 to 1; u0 > u1 mirrors) and how many
quarter turns clockwise it is rotated.Four corners in order around the face (a triangle repeats its last), with texture coordinates from 0 to 1.
A texture slot: pixels inside the model file, or a texture in a resource pack.
Draws a posed armature.
How an armature is drawn this time: light, colour, outline and so on.
Plays sound and particle keyframes by themselves: a sound effect naming a sound event, a particle effect naming a
world effect (
VfxEffects) or a simple particle type.Effect particles (
ParticleSpec) pouring from a point of an armature: fire from a dragon's mouth, sparks
from a forge's chimney, dust from a digging claw.Draws any entity with an armature: projectiles, vehicles, effects, display props.
What an armature-driven entity is drawn from, each frame.
Something a clip did at a keyframe: a Blockbench sound, particle or timeline keyframe, or a Bedrock
sound_effects, particle_effects or timeline entry.An armature posed for one frame: where every joint is, which are shown, and how they are tinted.
The animator of every entity, block entity and item stack drawn with an armature, held only as long as the thing itself
(weak keys, compared by identity).
The
coolcatlib:armature special item model: an item drawn with an armature, each stack animated on its own.Items drawn with an armature.
The armatures read so far, by id.
How a part of an armature is drawn.
An armature's faces, ready to draw: one group per texture and material (each group is one draw), and in each group the
faces of each joint in a flat array.
Draws a living entity with an armature.
How bright an entity's glow textures are drawn (see
ArmatureMobRenderer.glow).The model
RenderLayers see: it has no parts of its own (the armature draws itself).What an armature-driven mob is drawn from, each frame.
An entity's tint this frame (see
ArmatureMobRenderer.tint).Whether an entity is see-through this frame (see
ArmatureMobRenderer.Translucency.translucent(T, float)).Lets a posed armature go through vanilla's model drawing (
submitModel), so it gets what vanilla models get for
free: the glowing outline, the block-breaking overlay, see-through sorting, and tint and overlay colours.A named point that moves with a joint: a Blockbench locator or null object, or a Bedrock locator.
Moving a pose stack to an armature's points, for attachments and sockets.
How far each joint is moved from its rest this frame: what the animation layers made of it, open to
modifiers before it is drawn.
The
query.* values Molang can read.A Molang query.
A glowing ribbon left behind by a point of an armature as it moves: a sword's swing, a comet's tail, a spirit's
wake.
Draws every armature trail that is still being fed, as one world effect.
A typed piece of data any entity (players included), block entity, item stack, level or the server itself can carry.
Attachment values being added, changed and removed on any holder (entity, block entity or item stack), and
players starting and stopping to track a holder's data.A value was stored where there was none.
A value is about to be added, changed or removed by code on this side (not by a sync from the server).
Synced values from the server were applied on this client (after their add, change and remove events).
A value was removed (
reset); the holder reads the default again.A player starts receiving a holder's synced data (server side): they started seeing the entity or received the
block entity's chunk (for holders carrying attachments at that moment), or, for their own attachments, joined,
respawned or changed dimension (always).
A player stops receiving a holder's data (server side): they stopped seeing the entity, the block entity's chunk
was dropped for them, or, for their own data, they left.
The
Attachment values of one entity, block entity, item stack, level or the server.One mod's
Attachments.value is null when the value was reset to its default.An armature as loaded from its files: joints, faces, points, clips and textures.
Reads a Blockbench project (
.bbmodel) as it is saved, so no export plugin is needed: groups become joints,
cubes and meshes become faces, locators and null objects become points, embedded textures come along, and every
animation with its sound, particle and timeline keyframes.Reads Bedrock's model and animation files (
.geo.json, .animation.json), the ones Blockbench exports
and other tools share.A vanilla model part that can bend along its length (ModelPartMixin).
The renderers block entities are drawn with.
Block entity types from common code (vanilla keeps their constructor private).
Blocks broken and placed, on the server.
A player is about to break a block (server side); interrupting cancels it.
A block is about to be placed, on the server; interrupting stops it, and the item isn't used up.
A block was placed: by an entity (usually a player), or with no placer.
One position's handler, looked up once and kept until it may have changed: when the block state there changes,
when the block entity is removed or replaced (chunk unloads included), or when
HandlerType.invalidate(Level, BlockPos) is called for the position.true or false; typed as true/false, yes/no, on/off or 1/0.Custom boss bars on the client: which style each bar is in (from the server's
BossBarStylePayload), the
renderers registered for each style, and what each bar needs from one frame to the next to be drawn well: its
eased progress, its trail, how fresh its last hit is.Draws a boss bar of one style (
BossBarRenderers.register(Identifier, BossBarRenderer)), in place of the game's, on the HUD at the top of
the screen.The client half of custom boss bars: how each style is drawn.
Server to client: the style a boss bar is drawn in (
CustomBossBars), and the entity it belongs to (-1 for
none).A boss bar as a
BossBarRenderer draws it this frame: what the game knows of it, and what CoolCatLib keeps
for drawing it well.Custom boss bars (
BossBarRenderers) in place of the game's, stacked with any others the game draws in its
own way.Internal registry for custom brewing recipes.
A stretch of a cutscene in which the camera keeps looking at something, whatever its keyframes' angles say: a
point, an entity, or the player watching.
One pose a
Cutscene's camera passes through, and how it gets there from the keyframe before.Where a camera is and how it looks: one instant of a
Cutscene.Shakes the camera: an explosion nearby, a giant's footstep, a rift tearing open.
One shake.
Zooms the camera: a spyglass of a mod's own, a scope, a lens.
One category of a config in a small window: that group's settings (its nested groups as sections), or a single
setting, with Save and Cancel.
A mapping of percentage thresholds to corresponding ChatFormatting styles.
Represents an individual percentage threshold and its associated chat formatting styles.
Client-side commands.
Where a config's edits go from this client.
A startup value this client has but the server doesn't.
The in-game GUI.
Draws over the vanilla HUD, every frame.
A mod's client entry point, written once in common code.
The local player joining and leaving a world or server.
The player may already be gone (e.g.
The client's tick.
One animation of an armature, as its file describes it.
An animation as a file describes it, with its joints by name;
Clip.bind turns it into one armature's clip.One joint's tracks; any may be missing, and a missing channel leaves the joint to other layers or its rest.
Something a clip does at a moment: a sound, a particle, or an instruction (Molang to run, which listeners also
get as text).
Any value with a
Codec: records, maps, item stacks...Utility class providing helper methods for working with Mojang
Codec objects.An animated color gradient: color stops placed evenly around a loop (the last blends back into the first, so it
never jumps), or the full rainbow of hues.
An HSV color picker in a popup over the screen it was opened from: a saturation/brightness square, a hue bar, an
alpha bar (for colors with alpha), a hex field, the 16 dye colors, and the old and new color side by side, with
Cancel and Done in the footer below them.
A packed ARGB color, written as
"#RRGGBB" (or "#AARRGGBB" with alpha).Utility record representing and manipulating colors in RGBA format.
Server commands.
Declares a config: its settings, then its groups and values, then
ConfigBuilder.build() registers and loads it.Every color of a mod's config screens (ARGB).
How a command source is answered.
A value that only matters while another value meets a condition, such as "particle count" while "particles" is on.
A config as a
ConfigFormat writes it: nested sections of encoded values, each with its comment lines.A value, already encoded by its codec.
A group, or the whole file; children keep their declaration order.
Client only: which widget edits which
ConfigType in the config screen.Client only: an animated effect for config screens, drawn at any of three layers.
The screen being drawn.
One widget, its bounds in GUI pixels as drawn, and its state.
The kinds of widgets effects are told about.
Client only: the registry of
config screen effects, by id.Annotations describing the fields of a
ConfigObject's class.Keys the entry had before.
An
int field holding a color.Comment lines above the entry in the file; on the class, the file's header.
Greys the entry out while a boolean entry is off: its dotted path from the root (
"rendering.enabled"),
declared before this one.Left out of the config screen.
The key in the file, instead of the field's name.
In a startup config, each side keeps its own value; see
localOnly() on the entry builders.Text (or a string list's elements) limited in length.
Text (or a string list's elements) matching a regular expression.
The range of a number, or of a number list's elements.
Kept on the server in a synced config; see
serverOnly() on the entry builders.A list's size bounds.
Shows a ranged number as a slider.
A translation key for the entry's name.
In a startup config, clients use the server's value while connected; see
useServerValue().A notice card: where edits go, why nothing is shown...
A nested group's heading: its name in the accent, then a rule to the edge; deeper groups are indented.
One setting: its name and a line of description on the left, the editor and a reset button on the right.
Every config's lifecycle, for code watching configs it didn't declare.
Values changed, by any means, on the thread that changed them.
The file was read for the first time, when the config is registered.
The file was read again after loading: edited on disk (hot reload), the reload command, or
Config.reload().The file was written.
Client only: the server's values of a synced config arrived.
One value changed, by any means: set in code, a screen or command, a reload, the server's values arriving, or a
reset.
A config file's syntax.
A config file couldn't be parsed.
The built-in file formats.
A named section of a config, holding values and nested groups in declaration order.
Upgrades a config file's contents by one version, before the values are read.
The startup values of every startup config that clients must match:
{"mod:config": {path: value}}.The server's values of a synced config, and whether the receiving player may edit them.
The values a player changed in a synced config.
Whether the server took a player's changes, and what it rejected.
A group or a value in a config's tree.
A config declared as a plain class: every non-static, non-transient field becomes an entry, with the field's
initial value as its default, and nested objects become groups.
A named set of values applied together, like "Performance" or "Quality".
Collects a preset's values.
Where a config lives, which side loads it, and whether the server's values reach the clients.
A config's screen: the title, badges and search in the top bar; categories (the root's settings and each top-level
group) in a sidebar; the chosen category's settings, with nested groups as sections, in the main panel; and the
unsaved-changes status with the actions in the bottom bar.
Client only: config screens for Core's configs.
What makes the screens: Glazed Menu sets it as it starts, and CoolCatLib's own screens are the fallback.
The main config screen: one mod's configs, or every mod's, as cards grouped by mod.
How a mod's config screens look: its
color schemes for dark and light mode, an optional
background texture, and the icon beside the title (the mod's own icon unless set).How the background texture fills the screen.
Dark or light: each player's choice for every mod's config screens.
What a config value is: how it's stored (a
Codec, so every file format and the network work alike), what
it may be, and how it's typed as text in the config screen and commands.The built-in
ConfigTypes.Lists every mod's CoolCatLib configs in Configured (MrCrayfish), which then gives those mods a config button in
NeoForge's mod list and Mod Menu.
One typed setting.
Utility class providing convenience methods for working with
Container and Player inventories.An item whose stacks carry an inventory (a backpack, a pouch), kept in the stack's
minecraft:container
component.The shape of an inventory: how many slots, what each accepts and holds, who reaches it and from which faces.
A menu slot of a
SlotContainer that follows its layout: filters and SlotRole.OUTPUT decide what a
player may put in, and slot limits how much.Creative mode tabs.
A value over a lifetime, in three points: it eases from
start to middle over the first half, then
from middle to end over the second.Boss bars drawn a mod's own way, from the server.
A cutscene: a camera flown along keyframes while the player watches, with letterbox bars, fades, subtitles and
markers in time with it.
Builds a
Cutscene.A named moment: when the cutscene passes it, the client fires
CutsceneEvents.MARKER with its id, for a
sound, an effect, a camera shake, anything that should land on a beat.A line of text shown at the foot of the screen for a while.
What a
Cutscene's positions are measured from, when it is played without an origin of its own.Plays cutscenes on players' clients from the server.
A client telling the server that the cutscene it was asked to play has ended, and why.
Why a cutscene stopped playing.
Cutscenes playing on this client, whoever started them: a mod, the server, a command.
The server telling a client to play a cutscene, or to stop the one playing.
A cutscene as it plays: what
Cutscenes.play(Identifier) hands back.A client telling the server how far the cutscene it was asked to play has got: a keyframe reached, or a marker
passed.
Cutscenes on the client: the ones it knows by id, and the one playing.
A mod's data generation entry point, written once in common code.
Where a
DataGenerationConstructor adds its providers; everything lands in the mod's generated resources.An item that draws over itself in GUIs.
Registers a mod's objects into one registry at the right time on each loader.
Easing curves, each mapping a progress in
[0, 1] to an eased value (0 at the start, 1 at the end).The
Easing curves by name, for anything that is written down: cutscene files, commands, packets.What a
ValueEditor edits: a config value, or an element of a list being edited.What a screen effect's callbacks see of the current frame.
A function of the frame deciding how strong an effect is, from 0 to 1.
One named uniform of a screen effect, written into every pass that declares it.
Outlines drawn around specific widgets, any
AbstractWidget (vanilla's buttons, edit boxes, sliders or your
own), without subclassing them.The default attributes (health, speed, ...) of a mod's living entities, which every living entity type needs.
A boss bar that belongs to a living entity and keeps itself: its name is the entity's, its progress the entity's
health, and it shows to the players near it while it is to be shown.
Keeps the entity bars that are showing, every server tick.
Entities on the server.
An entity was added to a server level: spawned, or loaded with its chunk (players too, when they join).
An entity was taken out of a server level: killed, discarded, unloaded with its chunk, or gone to another dimension.
The renderers entities are drawn with.
An entry whose type has no builder options of its own (booleans, enums, colors, ids, custom types).
One of an enum's constants, stored by name (read case-insensitively).
An enum constant with its own name in the config screen, and optionally a description of what it does, shown as
a tooltip when choosing it from the list:
The side of the game that's running: a client, or a dedicated server.
One cross-loader event, identified by its listener type: a functional interface.
When a listener runs relative to the others of the same event.
Where a phase's listeners run among other mods' own listeners of the game event: before them (NeoForge's highest
priority, a Fabric phase before the default one), with them, or after them (the lowest priority, a phase after
the default one).
A result that can be returned from an event, either allowing the event to continue processing or to cancel the
implementation resulting in vanilla behavior being disrupted.
An extension to
EventResult allowing to attach any kind of value to the result, null values are not permitted.A block entity with
Attachment data, handlers and ticking made simple.A
ExtendedBlockEntity with an inventory.Menus that send extra data to the client when they open (which item, which block...).
What a cloth is made of, for
Spring.fabric(Fabric): how heavy it is, how it hangs, how it moves through the air, how
it gives and how it folds, all at once.A sound channel the filters can be applied to again (the game's
Channel, through ChannelMixin).Your own arms in first person, posed as the player's clips pose them (
VanillaModel.firstPersonArms).The time world effects, skyboxes and screen effects animate by: real seconds, smooth from frame to frame, that
stop while the game is paused and go on from where they stopped when it is not.
Marks a method as a game test, for
GameTests.register(String, Class).How a game test runs.
Game tests from common code, the same on every loader: a test is a function given a
GameTestHelper, run in
a structure built for it, and it passes or fails.Blocks drawn as ghosts: their real models (block entities' too, a chest as a chest), drawn by the game's own
renderers with the player's camera into a picture of their own, then laid over the world at one opacity and tint.
A block to draw as a ghost, where it is drawn.
Where a ghost shows, against the world in front of it or behind it.
Implemented on TextColor by TextColorMixin.
A box something on the screen takes up, in GUI pixels: a thing drawn (
GuiArea.Kind.DRAWN: a sprite, a fill, a line
of text, an item) or a widget of the open screen (GuiArea.Kind.WIDGET: a button, a text box), from GuiAreas.Records the box of everything the HUD and the open screen's own pass add to the GUI render state each frame
(
GuiRenderStateMixin, while GameRendererMixin and ScreenMixin say which is being drawn), and
keeps the last whole frame's for GuiAreas.What is on the screen, for placing something of your own where nothing else is (see
GuiPlacement).The opacity
ItemOpacityRenderer draws at now: the GUI items made while it is under 1 remember it and are
blitted with it (GuiItemRenderStateMixin, GuiRendererMixin), and, for its withOpacity, the
text and filled rectangles made then are faded by it (GuiTextRenderStateMixin,
ColoredRectangleRenderStateMixin).A GUI item's render state that knows the opacity it was drawn at.
Finds where to put something of your own so it keeps out of the way of what else is on the screen: you give its size
and where you'd like it, and it comes back there if that is clear, else at the nearest clear place found by sliding it
in the directions you allow, past whatever is in its way, without leaving the bounds you set.
Where to draw it, and whether it moved out of the way of something.
The handlers one holder hands out, by type and side.
An entity or block entity that hands out its own handlers;
HandlerType.find(Level, BlockPos, Direction) asks it before any registered
provider.A kind of handler blocks, entities and items can hand out: something other code works with without knowing the
holder (an inventory, an energy buffer, a fluid tank...).
The handler types CoolCatLib provides.
When the item in a player's hand is shown being put away and taken out again.
Takes the HUD over: while a condition holds, the game's own HUD (hotbar, health, crosshair, chat, and whatever
other mods add to it) is not drawn, and a view of the mod's own is drawn in its place.
What is drawn in the HUD's place.
Represents a flexible brewing recipe for the Minecraft brewing stand.
A namespaced id (
minecraft:stone).A player using or attacking blocks, items and entities, before the game acts on it.
A player starts hitting a block (the first click, not each tick of breaking it); interrupting stops it.
A player is about to attack an entity; interrupting stops the attack.
A player is about to use (right-click) a block, with whatever is in the hand.
A player is about to use (right-click) an entity.
A player is about to use (right-click) the item in a hand, aimed at no block or entity.
How the camera gets from the keyframe before to a
CameraKeyframe.Inventories kept in an item stack's
minecraft:container component (as shulker boxes keep theirs).Draws over an item wherever the game draws it in a GUI (inventory slots, the hotbar, a held stack...), after
vanilla's own decorations: the durability bar, the cooldown and the count.
An item that hands out handlers for its stacks;
HandlerType.find(ItemStack) asks it before any registered
provider.Items drawn in a GUI at an opacity, fixed or animated: a HUD card fading in with its icon, a slot greying out.
An opacity eased from one value to another over a time, for an item fading in or out.
An item shown at a point of an armature-driven mob: a held sword, a hat, a lantern on a belt.
Item tooltips.
The tooltip as it is about to be shown, every other line in place: what is added here comes last.
The finished tooltip lines, name included, to add to or change.
Moving items in and out of any
Container the way automation does: through a face (null for none),
following WorldlyContainer face rules, Container.canPlaceItem(int, ItemStack)/Container.canTakeItem(Container, int, ItemStack) and slot
limits.One joint of an armature: a Blockbench group or a Bedrock bone.
The joints a layer may move.
Code that moves joints each frame, after the animation layers: procedural motion the clips can't know about.
Key mappings shown in the controls screen.
A platform-agnostic, extensible language provider inspired by Fabric’s
TranslationBuilder.How a layer's clips combine with the layers under it.
Letterbox bars on their own, without a cutscene: for a boss entrance, a scripted moment the player still controls,
a photo mode.
Bends a vanilla limb the way an elbow or knee bends: a smooth arc through the middle of its length, the end beyond it
turned whole.
Edits a list's elements, each with the editor of the element type, in the config screens' frame.
A list entry; its elements are checked by the element type given to the
ConfigBuilder.A list whose elements are all of one type (itself possibly constrained), optionally limited in size.
Living entities (players too) being hurt, dying and changing what they wear or hold, on the server.
An entity is about to take damage, before armor and effects reduce it; interrupting stops the damage (no hurt
flash, no knockback).
An entity is about to die; interrupting keeps it alive.
What an entity wears or holds in a slot changed (armor, hands, body, saddle), noticed on its next tick.
A joint that turns to look at something.
What a clip does when it reaches its end.
The screens menus open.
Vanilla's own constructor type is private; this takes its place (usually
MyScreen::new).A mod's common entry point, written once in common code and run the same way on every loader.
A compiled Molang expression or script, the language Bedrock and Blockbench write animation values in.
A piece of a compiled expression.
Molang source to a tree of
MolangExpr.Nodes.A node whose value never changes.
Every variable name ever compiled, as a slot number, so a running expression reads an array instead of a map.
How to play one clip: how it loops, how fast, and how it blends in from whatever was playing.
Play-phase payloads between client and server.
A number entry: optionally ranged, optionally shown as a slider.
An
int, long, float or double, optionally within a range.A model read from a Wavefront
.obj file: triangles with positions, texture coordinates and normals, in
named parts.A stretch of a model drawn as one: the faces under one
o, g or usemtl line.The .obj models read so far, by file; emptied when resource packs reload (ShaderManagerMixin).
.obj models as resources.An
.obj model carried by an armature: a sword in a hand, a lantern on a belt, a detailed head on a simple
body.How a rectangular outline looks: a solid color or an animated
ColorGradient (a rainbow, or colors of your
own), its thickness, and how far it sits outside the rectangle.What a vanilla model's clips do on a part another mod is moving at that moment: a part another animation mod is
moving, such as a weapon mod's attack swing.
Where a received payload came from.
One layer of an
AbstractMultiPanelWidget.What a kind of effect particle looks like and how it lives, built once and spawned many times with
WorldParticles.How a particle's quad is laid in the world.
Stream codecs found by type, so a record payload needs no hand-written
StreamCodec: each record component is
encoded in declaration order with the codec of its declared type.Builds the codec of a generic type from its type arguments.
Resolves the codecs of type arguments inside a
PayloadCodecs.Factory.Handles a received payload.
Facts about the running game and loader, the same way on every loader.
Players joining and leaving the server, their tick, respawning and changing dimension, picking items up, and crafting
and smelting.
A player went from one dimension to another, by portal or teleport; they are already in the new one.
The game made a new player object for a player who died or came back from the End, and is copying them over:
the place to carry over what the game doesn't (attachments kept through death already are).
A player took what they crafted out of a crafting result slot (the crafting table's, their inventory's, or
another menu's built the same way), on the server.
After a player ticks, on both sides; check
player.level().isClientSide().A player finished logging in and is in the level.
A player is logging out.
A player is about to pick up an item from the ground: it may be picked up, and they have room.
A player is back in the world after dying or leaving the End (the new player object).
A player took what was smelted out of a furnace, smoker or blast furnace, on the server.
Before a player ticks, on both sides; check
player.level().isClientSide().A player is about to go to another dimension: by portal, by command, by another mod's teleporter, anything that
moves them across.
The player animation mod Better Combat animates players with.
Recipes being crafted, on the server.
A crafting recipe's result was worked out: for the result slot of a crafting grid (the crafting table's, a
player's inventory, or another menu built the same way) whenever its ingredients change, or for a crafter about to
craft.
Helper class to perform a shaped recipe match when ingredients that require testing are involved.
Helper class to perform a shapeless recipe match when ingredients that require testing are involved.
An object registered through a
DeferredRegister, available once its registry has been filled.Resource reload listeners.
What must restart before a changed value takes effect.
A rift in the world, from
WorldRifts.open(RiftSpec, Vec3).Rifts from the server (the client side is
WorldRifts).The server opening one of a client's registered rifts, or closing one it opened.
What a rift looks and sounds like: a tear in the air that opens, hangs there, and closes.
A small 3D scene drawn to a texture of its own: blocks, whole structures, entities and items' icons, seen from a camera that
circles them.
A block of the scene.
An entity of the scene: never in a world, only drawn.
An item of the scene, drawn as its icon is in an inventory:
size across, its middle at a place, flat to
the camera when the camera looks straight on (camera(0, 0)).A line of text laid flat on the picture, in the texture's own pixels: its top left at (x, y), each font pixel
scale texture pixels.A
SceneViewport in a screen: a 3D view of blocks, a structure or entities, kept inside the widget's
rectangle.A full-screen post-processing effect, made with
ScreenEffects.register(Identifier, Identifier).Drives a player's client-side screen effects from the server, by the id they were registered under with
ScreenEffects.register.The passes and targets of a screen effect: the vanilla
post_effect format, so vanilla's own effects load as
is.One draw of a fragment shader over its output target.
A named uniform and its default value:
{"name": "Amount", "type": "float", "value": 0.5}.Screen effects being turned on and off, and changed.
What turned an effect on or off.
The order screen effects are drawn in, like layers in an image editor: the first layer is drawn first, straight
over the game, and each later one processes the image the layers before it produced.
Runs screen effects: GameRenderer's mixin calls
ScreenEffectManager.beginFrame(DeltaTracker), ScreenEffectManager.render(ScreenEffectScope) per scope and
ScreenEffectManager.endFrame(); ShaderManager's calls ScreenEffectManager.reload(ResourceManager) once shaders are (re)loaded.The server telling a client what to do with one of its registered screen effects.
Full-screen post-processing effects: color grading, distortion, blur, and whatever else a fragment shader can do to
the finished frame, with uniforms that can change every frame.
When in the frame a screen effect is drawn.
A panel whose contents scroll vertically inside
ScrollPanel.getScrollArea() (by default the whole panel;
override it to leave room for a header/footer drawn in ScrollPanel.extractFrame(GuiGraphicsExtractor, int, int, float)).Mixed into the server: its player data, to read and write offline players' values.
A boss bar's style (
CustomBossBars): kept on the bar, and sent to each player right after the bar itself,
whenever they are shown it.Cutscenes the server started with
CutsceneControl, as their players watch them.The server's lifecycle, for dedicated and integrated servers alike.
Once the server is ready to tick.
Before the levels load.
After the server has shut down.
When the server begins shutting down, before the levels save.
When a player needs the server's datapack contents: once as they log in (
joined is true), and for every
player after a datapack reload such as /reload (joined is false).A utility class that helps track the current Minecraft server instance
during the server lifecycle.
A mod's dedicated server entry point, written once in common code.
The server's tick, and each of its levels' ticks.
Camera shake from the server (the client side is
CameraShake).The server shaking a client's camera.
What a
WorldlyContainer shows through one face: only the slots that face reaches (numbered from 0), and
only what the face allows in and out.How a sky layer combines with what's drawn under it.
A custom sky, made with
Skyboxes.register(Identifier, SkyboxDefinition): layers of images, gradients and shaders drawn into vanilla's sky,
and parts of vanilla's sky hidden.Drives players' client-side skyboxes from the server, by the id they were registered under with
Skyboxes.register (or a resource pack skybox's file id).Players to send skybox commands to: the same commands as the static methods, each sent to all of them.
The layers of a skybox and what it hides of vanilla's sky.
Custom skies: images wrapped around the sky (cubemaps and panoramas), images placed in it (sprites), gradients and
shaders, each able to rotate, animate frame by frame and fade by time of day, weather or code; and parts of vanilla's
sky hidden while they show.
Runs skyboxes: GameRenderer's mixin calls
SkyboxManager.beginFrame(DeltaTracker) and SkyboxManager.endFrame(); SkyRenderer's calls
SkyboxManager.extract(SkyRenderState) and SkyboxManager.render(SkyLayerStage), and asks what to hide of vanilla's sky; ShaderManager's calls SkyboxManager.reload(ResourceManager)
once shaders are (re)loaded.The server telling a client what to do with one of its skyboxes.
What drives a layer's rotation or animation.
What a skybox's callbacks see of the current frame.
Runtime control over one layer of a skybox, on top of its definition.
One layer of a
SkyboxDefinition: an image, a gradient or a shader drawn over the sky, and how it moves and
fades.Plays the texture as a flipbook:
frames images of equal height stacked top to bottom.Shows the layer during part of the day: it fades in over
[startFadeIn, endFadeIn], stays, then fades
out over [startFadeOut, endFadeOut].Turns the layer around an axis as its clock moves.
When in vanilla's sky a layer is drawn.
What a sky layer draws.
An inventory following a
ContainerLayout.Represents a reference to a specific slot within an inventory or container.
A
SlotReference implementation for generic containers (e.g., chests, furnaces).A
SlotReference implementation for player inventories.Who may put items into a slot and take them out: players through a menu, and automation (hoppers, pipes,
ItemTransfer).A sound a
SoundFilterProvider is asked about.How a sound comes through to the listener, each part 0 to 1:
gain: how loud it stays, 1 for as loud as it was;
gainHF: how much of its high end it keeps; losing the highs is what makes a sound muffled, as through a
wall;
distortion: how much of it is sent through a distortion, which makes it rough, as if strained through
something;
reverb: how much of it is sent into a reverb, which makes it echo, as in a cave or a great hall.
Named sound filters from the server (the client side, and what each part does, is
SoundFilters and
SoundFilter): one small packet to set or clear a filter on a player, which then fades on its own.The sound filters' work (
api.client.sound.SoundFilters): for each sound, the providers' filters and the named
ones combined, as an EFX low-pass filter on its OpenAL source, and as much of it as they say sent, filtered the same,
through a distortion (auxiliary send 0) and into a reverb (send 1).The server setting a named sound filter on a client (gain, highs, distortion, reverb), or clearing it (
clear,
the filter's parts then unused), over fadeTicks.Says how a sound comes through to the listener; registered with
SoundFilters.register(SoundFilterProvider).Muffles, roughens and echoes the game's sounds: a player hiding in a chest hears the world through its walls, one
under a spell hears it from far away, a cave rings.
A registered provider, to remove again.
Secondary motion: a joint that lags behind and swings back, as a tail, ears, antennae, a cape or a hanging lantern
would.
Shown after a server refused this client for having different startup values.
How a
ConfigScope.STARTUP value is reconciled with the server's when a client joins.The menu a
StorageMenuDefinition opens on a block's or an item's inventory.What a menu is open on: a block entity (by position), or the stack in one of the player's inventory slots.
A menu for the inventory of a block or an item, declared once: where its slots go, what else the screen shows, and
what its buttons do.
Where one container slot shows on the screen (the slot's top-left, inside its 18x18 box).
A ready screen for any
StorageMenu: a vanilla-style panel sized by its StorageMenuDefinition, a box
behind every slot, and the usual labels, with no texture needed.A text entry: optionally limited in length, required, or matched against a pattern.
Text, optionally limited in length, required not to be empty, or matched against a pattern.
What
ServerBossEventMixin adds to every server boss bar: the style it is drawn in, and its entity.Draws an icon in a square; returns whether there was one.
Which players receive a
Attachment's value.Gradient (rainbow included) and outlined text for GUI drawing.
A boss bar drawn from one texture: a frame (with whatever dresses it: an emblem, thorns, a blade), and inside its
track a fill for the health and a trail for what was just lost.
How custom tooltip components (from
Item.getTooltipImage) are drawn.The keyframes of one channel (rotation, position or scale) of one joint, three values each, as the file wrote them:
rotations in degrees and positions in pixels, in Bedrock's axes.
One keyframe.
A mutable value that reports its own changes.
The path something moved along over its last few ticks, drawn as a ribbon with
VfxDraw.trail(Trail, Curve, int, int).How one animation gives way to the next: over how long, along which curve, and how the two meet.
Picks the transition between two animations on a layer, asked each time one gives way to another (unless the new
motion names its own).
The outcome of checking a value: fine as is, corrected into a valid value (a number clamped into its range, say),
or rejected.
A utility class for parsing strings into values of type T and converting values of type T into strings.
The widget editing one value in the config screen.
Builds an editor for a slot, at the given size.
A number that changes over a cutscene, as keys in time: how far the letterbox bars are in, how dark the fade is.
Draws the armatures a vanilla mob wears (
VanillaModel.attach), each on its part as the part is posed.Armatures on vanilla models (
VanillaModels).An armature worn on a part of a vanilla model: wings on a zombie's body, a tail on a player, a hat on a villager's
head.
What CoolCatLib adds to one kind of vanilla mob (or the player) without replacing its model: clips played on its
parts, changes to its parts, and armatures worn on them.
Armatures on vanilla mobs and players, without replacing their models: play clips on their parts, change their
parts, wear armatures on them.
A vanilla model being posed, after vanilla's own animation and any armature clips: change its parts by name
(
"head", "right_arm", "left_leg", "body"; any case or rightArm spelling).Changes made to a vanilla model every time it is posed.
The parts of vanilla's sky a skybox can hide.
What a vanilla mob is drawn with this frame, beyond vanilla: its animator (for clips and modifiers), its
attachments' frames by the index of the attachment in its
VanillaModel (null where one isn't worn), and,
found once when first needed, the parts other animation libraries are moving.Added to every entity render state (EntityRenderStateMixin).
How a world effect combines with the scene behind it.
Plays world effects on players' clients from the server, by the id they were registered under with
VfxEffects.register.Draws shapes of one
VfxMaterial into the world for the current frame, from a VfxRenderer.A named world effect a client can play: usually a few
WorldParticles and WorldVfx calls.World effects by name, so the server can start them with
VfxControl.play.The frame a
VfxRenderer is drawing into.Where in a frame's world effects a shape is drawn, given to
VfxFrame.draw(VfxMaterial, VfxLayer).What a world effect is drawn with: a texture, how it blends, and how softly it meets solid things.
What the server tells a client about one playing of a world effect.
The server telling a client to play one of its registered world effects.
Draws world effects each frame; registered with
WorldVfx.register(Identifier, VfxRenderer).A panel showing a 2D "world" that can be panned by dragging and zoomed with the mouse wheel
(anchored at the cursor, smoothly animated).
Spawns effect particles (
ParticleSpec) in the world the client is in.Rifts: tears in the air, drawn by a shader (
VfxMaterial.RIFT_SHADER) and run through three acts.World effects: glowing shapes drawn in the world, after everything else in it and before the player's hand.