All Classes and Interfaces
Class
Description
The options every entry has.
A (optionally draggable) window whose content area shows a stack of
Panels.A typed piece of data any entity (players included), block entity or item stack 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 or item stack.One mod's
Attachments.value is null when the value was reset to its default.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 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.Internal registry for custom brewing recipes.
Shakes the camera: an explosion nearby, a giant's footstep.
One shake.
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.
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, or for a world config when a server starts
(every time one starts).
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.
A world config is about to go back to its defaults because its server stopped.
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: the generated config screens.
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.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.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).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.Entities on the server.
An entity was added to a server level: spawned, or loaded with its chunk (players too, when they join).
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.
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...).
Models baked with the game's though no item or block uses them, for drawing in code (an item renderer's parts, say).
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.
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.
The handlers one holder hands out, by type and side.
An entity or block entity that hands out its own handlers;
HandlerType.find(net.minecraft.world.level.Level, net.minecraft.core.BlockPos, net.minecraft.core.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.
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.
Colours items' tinted faces (a model's
tintindex), the same on every loader.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.Draws items in code, the same on every loader: an item whose model is
"parent": "builtin/entity" is drawn by
its renderer wherever it shows (in hands, slots, frames, on the ground), with the model's display transforms already
applied.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, net.minecraft.world.item.ItemStack)/Container.canTakeItem(net.minecraft.world.Container, int, net.minecraft.world.item.ItemStack) and slot
limits.Key mappings shown in the controls screen.
A platform-agnostic, extensible language provider inspired by Fabric’s
TranslationBuilder.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.
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.
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.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.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, and their tick.
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.
Before a player ticks, on both sides; check
player.level().isClientSide().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(net.ixdarklord.coolcatcanvas.api.client.vfx.RiftSpec, net.minecraft.world.phys.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(net.minecraft.resources.ResourceLocation, net.minecraft.resources.ResourceLocation).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, in the
post_effect format of later Minecraft versions.What a pass samples: a target or a texture.
One draw of a fragment shader over its output target.
A target a pass can draw into.
Samples a target's color, or its depth with
useDepthBuffer.Samples
assets/<namespace>/textures/effect/<path>.png.A named uniform and its default value:
{"name": "Amount", "type": "float", "value": 0.5}.The GLSL types a uniform can have.
A uniform's value.
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(net.minecraft.client.DeltaTracker), ScreenEffectManager.render(net.ixdarklord.coolcatcanvas.api.client.effect.ScreenEffectScope) per scope and
ScreenEffectManager.endFrame(), and ScreenEffectManager.reload(net.minecraft.server.packs.resources.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.renderFrame(net.minecraft.client.gui.GuiGraphics, int, int, float)).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.
A GL program linked from
assets/<namespace>/shaders/<path>.vsh and .fsh, for screen effects and sky
layers.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(net.minecraft.resources.ResourceLocation, net.ixdarklord.coolcatcanvas.api.client.sky.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(net.minecraft.client.DeltaTracker), SkyboxManager.endFrame() and SkyboxManager.reload(net.minecraft.server.packs.resources.ResourceManager);
LevelRenderer's calls SkyboxManager.beginSky(org.joml.Matrix4f, org.joml.Matrix4f, float, net.minecraft.client.Camera, java.lang.Runnable) as the sky pass starts, SkyboxManager.render(net.ixdarklord.coolcatcanvas.api.client.sky.SkyLayerStage) per stage, and asks what to hide of
vanilla's sky.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).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.
A row, with its own height; the list sets its bounds as it lays the rows out.
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.
How custom tooltip components (from
Item.getTooltipImage) are drawn.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(net.ixdarklord.coolcatcanvas.api.client.vfx.Trail, net.ixdarklord.coolcatcanvas.api.client.vfx.Curve, int, int).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.
The parts of vanilla's sky a skybox can hide.
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.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
register(net.minecraft.resources.ResourceLocation, net.ixdarklord.coolcatcanvas.api.client.vfx.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.