CTM Reborn

CTM Reborn

A connected-textures and baked-model library for Fabric and NeoForge, and a fork of
Athena by ThatGravyBoat and Terrarium Earth.

CTM Reborn exists for one reason: to keep the Athena format alive on current Minecraft versions so that Chisel Reborn and every resource pack ever written against Athena keeps working while upstream Athena is between releases.

What connected textures actually do

Demonstration image from Connected Textures (CTM) Overhaul, released under CC0-1.0.

Look at the borders. Vanilla Minecraft draws every block with the same texture, so a wall of one
material reads as a grid of repeated tiles with a seam at every boundary. With connected textures,
each block asks its neighbours what they are and picks a different sprite depending on the answer —
so the grooves and edges trace the outline of the whole shape instead of every individual cube.

The red, green, cyan and white regions above are each many separate blocks. The framing follows the
silhouette of each region, corners turn where the region actually turns, and interior faces come out
clean. That is the entire idea, and the Athena format is a way of describing it in JSON.

This is Athena’s implementation

Not a reimplementation, not a rewrite, not a clone of the format. The code in this project is
Athena’s code. The connected-texture logic, the model types, the format parsing, the quad
generation, the platform hookup — ThatGravyBoat and the Terrarium Earth contributors wrote all of
it. CTM Reborn carries that implementation onto newer Minecraft versions and keeps it building.
The changes here are version compatibility and maintenance; the substance is theirs.

Athena is a genuinely well-designed library. The format is compact, the model types cover the cases
packs actually need, and the connection-condition system is more expressive than it first looks.
None of that is our work, and nothing here is presented as an improvement on it.

The fork is a stopgap, not a replacement. It is published under Athena’s own MIT license with
its authorship intact, and the intent is to deprecate CTM Reborn the moment Athena updates to
these Minecraft versions.

The Athena format

Model definitions live at assets/<namespace>/athena/<block>.json and are tagged with the loader
they use:

{
  "athena:loader": "athena:ctm",
  "ctm_textures": "mymod:block/marble_[$index]",
  "connect_to": { "type": "sameBlock" }
}

They can also be written inline in a blockstate file, using the athena:athena block-state model.

Model types

athena:giant is the original name for athena:mural and still works.

Texture layouts

ctm_textures accepts three shapes, and the format picks based on what it sees:

• Single sprite — "mymod:block/plain". One texture, no connection logic.
• 47-slice — "mymod:block/marble_[$index]". The classic full CTM set; [$index] is filled in
  with 0–46, one sprite per neighbour configuration.
• Four-slice — an object naming particle, center, vertical, horizontal and empty.
  Each block face is drawn as four quadrants assembled from those five sprites, which gets you
  convincing connections from a handful of textures.

Any of the three can also be given per-face, with an optional default:

"ctm_textures": {
  "default": "mymod:block/side_[$index]",
  "up":      { "particle": "...", "center": "...", "vertical": "...", "horizontal": "...", "empty": "..." }
}

Connection conditions

connect_to decides which neighbours count as connected. It defaults to sameState.

These nest, so a condition like "any block in this tag, but not if it is powered" is expressible
directly in the pack.

Tinting

Faces can carry a tint — either a fixed colour or a tint index resolved through the usual block
colour handlers — so grass-like and foliage-like blocks connect and stay biome-coloured.

How it works

• A client resource-reload listener collects every assets/<ns>/athena/ file and keys it by the
  athena:loader field, so a pack can define models for blocks from mods it does not ship.
• Definitions are parsed with codecs (Mojang’s DataFixerUpper), which means the same description
  both reads and writes — that is what makes the data provider below possible.
• At bake time each model resolves its sprites into a small integer-keyed table, deduplicating
  repeats, then emits quads per face.
• For each face the model builds a CtmState: eight boolean neighbour checks — up, down, left,
  right and the four diagonals — evaluated through the block’s connect_to condition. That state
  selects the sprite or the four quadrant sprites.
• Platform hookup is thin. Fabric registers a CustomUnbakedBlockStateModel plus a model-loading
  plugin; NeoForge registers through RegisterBlockStateModels with a small ModelBakery mixin.
  Everything else is shared.
• A data provider is included for generating these files from code rather than writing them by hand.

Compatibility

The mod id is ctm_reborn, but nothing a pack depends on changed:

• Files are still read from assets/<namespace>/athena/.
• The athena:loader key still works, alongside ctm_reborn:loader.
• Every model type is registered under both athena: and ctm_reborn:.
• On Fabric the mod declares provides: ["athena"], so mods depending on Athena are satisfied.
  NeoForge has no equivalent mechanism, so mods there that hard-require the athena mod id will
  not see it.

Versions

License and credits

MIT, inherited from Athena.

• Athena — ThatGravyBoat and contributors, Terrarium Earth. The format, the design, and the
  implementation this project is built from. https://github.com/terrarium-earth/Athena
• Demonstration image — Connected Textures (CTM) Overhaul, CC0-1.0.
  https://modrinth.com/mod/ctm-overhaul