All Classes and Interfaces
Class
Description
The options every entry has.
A (optionally draggable) window whose content area shows a stack of
Panels.Packed ARGB colour helpers: the parts of newer Minecraft's
net.minecraft.util.ARGB that CoolCatLib uses, for
1.20.1, which only has FastColor.ARGB32.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).
BlockEntityTypes.Factory<T extends net.minecraft.world.level.block.entity.BlockEntity>
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.Collects brewing recipes while
RegisterBrewingRecipesEvent
fires.Internal registry for custom brewing recipes.
Shakes the camera: an explosion nearby, a giant's footstep.
One shake.
A GLSL program linked from a vertex and a fragment shader in resources.
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 image button drawn from
WidgetSprites (one texture per state), optionally tinted with a color.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 NBT (see
ItemContainers).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 payload sent through
Network: 1.20.5+'s CustomPacketPayload, which 1.20.1 doesn't have.A piece of data saved with a
Codec under its id in a CompoundTag.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.DataGenerationContext.RegistryDependentFactory<T extends net.minecraft.data.DataProvider>
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.
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...).
ExtendedMenus.Factory<T extends net.minecraft.world.inventory.AbstractContainerMenu>
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.
Represents a flexible brewing recipe for the Minecraft brewing stand.
A namespaced id (
minecraft:stone).Inventories kept in an item stack's NBT, as vanilla keeps them: an
Items list in the stack's
BlockEntityTag for block items (as shulker boxes keep theirs, so placing the block restores the contents), and
in the stack's own tag for other items (as bundles do).A
DataComponent kept in an item stack's NBT tag, under its id.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.Item stack helpers for what 1.20.1's
ItemStack lacks (it has NBT tags, not data components).Item tooltips.
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.
MenuScreenRegistry.ScreenFactory<M extends net.minecraft.world.inventory.AbstractContainerMenu,U extends net.minecraft.client.gui.screens.Screen & net.minecraft.client.gui.screens.inventory.MenuAccess<M>>
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.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.
Registers brewing recipes.
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 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: vanilla's post chain format, so vanilla's own effects (and any made for
them) load as they are.
Another input of a pass, sampled as
sampler: a target (its color, or its depth), or else a texture,
assets/<namespace>/textures/effect/<path>.png.One draw of a program over its output target.
A target's size; screen-sized where not given.
A value for a program's uniform:
{"name": "Amount", "values": [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(float) and ScreenEffectManager.render(net.ixdarklord.coolcatcanvas.api.client.effect.ScreenEffectScope) per scope, and
ScreenEffectManager.reload(net.minecraft.server.packs.resources.ResourceManager) once vanilla's 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.
Whether an Iris (Fabric) or Oculus (Forge) shader pack is in use, through Iris's API when either is installed.
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(float) and SkyboxManager.reload(net.minecraft.server.packs.resources.ResourceManager); LevelRenderer's calls
SkyboxManager.beginSky(org.joml.Matrix4fc, org.joml.Matrix4fc) and SkyboxManager.render(net.ixdarklord.coolcatcanvas.api.client.sky.SkyLayerStage) from vanilla's sky pass (or SkyboxManager.renderWithoutVanillaSky(net.minecraft.client.multiplayer.ClientLevel) where there's
none), 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 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.
A panel showing a 2D "world" that can be panned by dragging and zoomed with the mouse wheel
(anchored at the cursor, smoothly animated).
The textures of a widget for each of its states; a backport of the vanilla class added in Minecraft 1.20.2.
How a nine-sliced sprite is cut: the size of its textures and the borders that keep their size.