Keystone 1.3.10

The far zone keeps the game's projection when a shader pack is loaded. A pack reads the depth buffer to work out where a pixel is in the world; the far zone wrote depth through a projection of its own, so parts of it were lit and shadowed as if they were somewhere else - dark smears with the world showing through. It now draws with the game's own projection and is cut off at the game's far plane, which is past the pack's fog anyway. Without a pack nothing changes.

Chunks edited while the server was down are noticed. Afterimage 0.6.1 snapshots the write times in the region file headers next to its change log, so a world edited from the outside (a script that fills an ocean, moves a city, rewrites biomes) is recorded as changed and clients drop the far copies they still hold of it.

Keystone 1.3.8

A single block that cannot be read no longer costs the whole map its colours.

jmcolor asks live world data for every map pixel, and a tile entity that is still being read can throw - LittleTiles threw a NullPointerException inside allTiles while a server was going down, and the module then switched every colour off for the rest of the session.

• Failures are counted per kind of block, and only that kind is given up on, after 512 of them (-Dkeystone.jmcolor.giveUpAfter). One failed block just keeps JourneyMap's own colour there.
• A LittleTiles block that has not finished loading is skipped instead of asked for its tiles.

Keystone 1.3.7

Two crashes a dedicated server hit on the same day.

• Exception ticking world (ConcurrentModificationException in ChunkProviderServer.tick): the chunks queued for unloading are now walked over a copy, so a chunk queued or dropped while that loop runs - from another thread, or from an unload event - can no longer end the tick.
• Exception ticking world entities (ArrayIndexOutOfBoundsException inside fastutil): the tile entity list's deferred removals are kept under the list's own lock, a call from another thread gets the plain list path, and the first such call is logged with its stack so the mod behind it can be found. A broken map is dropped instead of thrown.

Keystone 1.3.6

JourneyMap draws Immersive Railroading track in the colours of the bed it was laid on.

Track is one block state for every piece of railway, and its rails, sleepers and bed are a model drawn by the tile entity. JourneyMap gave whole lines the single colour of that state, tinted like grass by the biome, so railways showed up as green stripes.

• A track block now takes the colour of its rail bed (gravel, concrete, whatever it was laid on) with the share the sleepers and the rails cover on top of it; snow on the track whitens it.
• Track without a bed is sleepers and rails only; everything else of the mod keeps JourneyMap's own colours.
• Shares: -Dkeystone.jmcolor.railbed (0.62), -Dkeystone.jmcolor.railties (0.28).

Keystone 1.3.5

JourneyMap draws LittleTiles and Chisels & Bits blocks in the colours of what is inside them.

Both mods use one block state for every build in the world, so JourneyMap gave whole cities the single colour that state got from its placeholder texture. What such a block really shows lives in its tile entity.

• The block is taken apart per map pixel: 16x16 columns, the highest tile or bit of each column gives its block state, and JourneyMap's own colours for those states are averaged over the columns — what the block looks like seen from above.
• Done through JourneyMap's own extension point (a handler per mod id sets an IBlockColorProxy that is asked per position), not by patching its renderer.
• Anything unexpected falls back to JourneyMap's own colour, and the first error switches the module off for the session. -Dkeystone.jmcolor=false turns it off.

Map tiles already drawn keep their old colours until those chunks are mapped again.

Keystone 1.3.3

Afterimage's far zone now works with OptiFine shader packs.

A pack makes the game build chunk geometry in OptiFine's vertex layout (normal, mid texture coordinate, tangent and block id next to the vanilla fields). Until now the far zone only knew the vanilla layout: with a pack loaded it took no new copies and drew the old ones with the wrong pointers, and its depth clear made the pack treat the far zone as sky.

• Copies are taken and drawn in the layout the game is building in, through the pack's own arrays and pointers, so a pack lights the far zone like the terrain in front of it.
• The depth buffer is left alone while a pack is loaded.
• The disk cache stays in the vanilla layout and serves both: a pack's vertices are written without their extra fields and get them back when read, worked out from the quad itself.
• Switching a pack on or off starts the copies in memory over; the cache on disk stays valid.

Everything else is unchanged.

Keystone 1.3.2

A mod's world generation can be switched off. -Dkeystone.nogen=morevegetation,othermod makes Forge skip the world
generators whose class name contains one of those names (a mod id is usually part of its package), so the mod stops
scattering its plants, ores or rocks into newly generated chunks. Everything already placed keeps working, the blocks
stay craftable and placeable, and the log names each generator it skips. Empty by default, so the jar behaves exactly
as before unless the flag is set.

Keystone 1.3.1

Client fix for Immersive Vehicles. Replace the previous z-keystone jar in the client's mods; the server can stay on 1.3.0.

Signs, poles and vehicles no longer flicker between shaded and bright. Immersive Vehicles draws everything at the
end of the frame and switches lighting on through Minecraft's GL state cache. Other mods that draw at the same moment
and change GL state directly (selection outlines, waypoint beams and similar) left that cache out of step whenever they
had something on screen, and Immersive Vehicles' lighting call was then skipped: its models showed flat and bright in
some frames and shaded in others, changing as the camera moved. Keystone now puts the GL state back in step with the
cache just before Immersive Vehicles draws.

Keystone 1.3.0

Install on the server and the client (the server part decides how far trains are sent).

Immersive Railroading stays in sight. A dedicated server sends entities to a player only within its view-distance
(80 blocks at view-distance 6) and only in chunks the player watches. Trains vanished as soon as you moved a little away,
and rails disappeared together with their chunks, which is especially visible next to a far city drawn by Afterimage.

• Server: trains, wagons and seats of Immersive Railroading (every UniversalModCore entity) are sent to each player up
  to 1.5x the render distance that player set in their video settings, at most 1024 blocks, whether or not the player
  watches their chunk. The render distance comes from the client settings packet that vanilla 1.12 ignores.
• Client: such entities are kept and keep moving where the client has no chunk, and are drawn there at sky light.
  UniversalModCore's own pass for large entities now draws every such entity that no other pass drew this frame, within
  the same range.
• Client: rails, multiblocks and other UniversalModCore blocks with a model, in chunks the client unloads, keep being
  drawn within the range until the chunk is loaded again.

Settings (JVM flags): -Dirfar.factor (1.5), -Dirfar.maxBlocks (1024), -Dirfar.maxKeptTiles (50000),
-Dirfar.enabled=false to turn it off.

Keystone 1.2.13

Client fix. Replace the previous z-keystone jar in mods; the server can keep 1.2.9 or later.

Far copies with wrong textures after the texture set changed. Afterimage's far copies and its disk cache store block
geometry with texture coordinates in the block texture atlas. When the set of textures changes (a mod or resource pack
added or removed, or new item icons such as the ones 1.2.12 adds for Immersive Vehicles packs), most textures move to
other places in the atlas, and copies made before show other textures: roads drawn as grass, walls as leaves.

Afterimage now takes a fingerprint of the atlas layout after every texture load. The disk cache records the fingerprint
it was written with; if the layout differs at start-up, the old cache is moved to afterimage/cache-stale-<time> and
deleted in the background, and the far zone fills again as you play. A resource reload that changes the layout also
drops the copies in video memory. The log shows disk: cache discarded, it was made with another block texture layout
when that happens.

The first start with 1.2.13 discards the existing cache once, because it has no fingerprint yet.

Afterimage 0.5.9.