Afterburner

Afterburner 0.3.2 (Forge 1.21.11)

Brings 1.21.11 up to the 26.3 builds: the options added since 0.2.6 (listed below), and the fixes from 0.3.0 to 0.3.2.

Fixed

• With "half size menu blur" on, the game crashed at startup next to WalksyLib. They now work together.
• With "sprite pixels freed" on, Distant Horizons drew far terrain pink and purple. That option now stays off while Distant Horizons or Voxy is installed.
• With the default settings, terrain could be drawn scattered and out of place: half of batched chunk drawing was on without the other half. Batched chunk drawing and the options built on it are not in this version's build, and stay off.

New, on by default (each can be switched off in the settings)

• Accurate Ping: The server worked out a player's ping when its busy main thread got to the reply, which on a long tick adds up to a whole tick to everyone's ping. This measures to when the reply came in instead. Only the number shown (and what other mods read) changes; the connection does not.
• Block Array Per Chunk Build: Building a chunk reads the block next to every face and around every smooth-lit corner; the blocks of the chunk and the ring around it are now read out once and looked up from an array. Same chunks as vanilla, about a tenth less building time in an offline test.
• Bulk Vertex Writes: Mobs, players, armour and items are drawn from boxes and quads made of many vertices. Now each is stored into the vertex buffer in one go instead of vertex by vertex. The same picture, less work for the render thread.
• Cached Registry Sync On Join: The registries and tags sent to a player who joins are built once and reused for the next players, until a reload or any change of tags or registries. The packets are the same as the game would build.
• Calm Loading Screen: The world loading screen is drawn at no more than 30 frames a second. Drawing its chunk map as fast as possible took a good part of a processor core away from making the world, which matters on 2-core PCs.
• Cheaper Aquifers: Underground water and lava pockets (aquifers) are worked out for every block that is not solid: the twelve nearby cells are looked up again at every height, and a new number holder is made each time. Now the cells of a column are worked out once and reused for the twelve blocks that share them, and one holder is kept for each chunk. The same water and lava, the same blocks.
• Cheaper Light Queue: The light thread keeps its task list with less copying and fewer objects, and tells the main thread about changed light in one message per round. The light and the packets come out the same as vanilla.
• Cheaper Mob Checks: Mobs in a crowd, and mobs near walls, repeat three small checks every tick (is my block a ladder, is my head in a wall, who can I push). They now keep or skip the repeated work. Same results as vanilla.
• Cheaper Precipitation: The random freezing and snow tries in each chunk stop early when it is not raining and the top block is not water. Same results as vanilla.
• Chunks In Front First: On a server, the chunks a player is waiting for are sent the ones in front of them first (inside the way they look). The same chunks, in another order.
• Collisions Without Shape Objects: When something moves, the game made a new shape object for every block it might touch and clipped the move against each. Now the common block shapes (full blocks, slabs, farmland, paths) are clipped straight from their numbers; stairs, fences and the rest are clipped as before. Same results as vanilla, to the last digit.
• Compact Scheduled Ticks: Water, lava, redstone and other scheduled block ticks are kept in each chunk in one array instead of a hash set and a queue of objects, and checking for a scheduled tick makes no garbage. Same ticks in the same order as vanilla.
• Comparators Read Once: A comparator told of a change read the container or item frame it measures twice, and a chest is counted slot by slot each time. Now it is read once. Same decision, about a third quicker per comparator; it shows in worlds with many comparators.
• Dust Memory Ignores Faraway Changes: The redstone dust memory used to drop an answer when any block changed in the same chunk sections. Now it drops it only when a block within 2 blocks of the dust changed. Same redstone as vanilla.
• Faster Block Entity Cleanup: When hoppers, furnaces, spawners and the like go away (chunks unloading, an area cleared, an explosion), each one taken off the list of block entities to tick moved every one after it down the list. With thousands going at once, that could take a tenth of a second or more in one tick. Now the list is tidied in one pass. Same results as vanilla.
• Faster Chunk Update Checks: Every frame the game checks every chunk on screen to see whether it needs rebuilding, though in most frames nothing changed. This remembers which ones were waiting and checks only those until something changes. Same chunks rebuilt, at the same time.
• Faster Explosion Drops: The items an explosion's blocks drop are collected into stacks by kind instead of checking every stack so far for each drop. The same stacks in the same order.
• Faster Explosion Exposure: An explosion works out how much of each nearby entity it can see by sending rays through the blocks in between. This looks each block's shape up once instead of at every step of every ray. The same result.
• Faster Explosion Particles: Each explosion particle finds its explosion with a binary search instead of a walk through the list, which helps in chain reactions. The same particles appear.
• Faster Server List: The multiplayer list refreshes faster: more servers are pinged at once, and servers listed by IP address skip a server-redirect lookup that public name servers can never answer. The list shows the same.
• Faster Surface Layer: The top layer of new land (grass, sand, snow...) asked the game for the biome of every block, which works out all eight neighbouring biome-zoom corners again each time. Now the corner values of a column are kept while the layer is built downwards. Same biomes, same blocks.
• Faster Texture Loading: Makes the smaller copies of each texture (mipmaps) with a quicker routine that gives exactly the same pixels. Cuts the loading time of high-resolution resource packs, most on slow PCs.
• Fewer Surface Rule Checks: The top layer of new land is chosen by a list of rules (bedrock, grass and sand by biome, deepslate) that was asked about every stone block of every column. Now it is worked out from the list itself where each rule can possibly give a block, and a rule is left out at heights where it cannot. A list with a rule this does not know is used the vanilla way. Same blocks as vanilla.
• Free Idle Graphics Memory: Lets go of the title screen's background picture (about 24 MB) while you are in a world. It comes back when you leave the world.
• Idle Graphics Card Note: On Windows PCs with a built-in and a separate graphics card: if the game runs on the built-in one, the title screen says so once, and these settings get a button to switch (from the next start). Nothing changes on its own.
• Keep Chunks by Section: Keeps chunks from servers with Afterburner in pieces of 16x16x16 blocks instead of whole. When a chunk has changed a little since last time, only the pieces that changed are sent again; pieces that are the same in many chunks are kept once. Everything read from disk is checked and asked for again if it is damaged. Needs Keep Chunks, and replaces what that has kept so far for the server. Until tried more.
• Largest Texture Size: The longest side of a block, item or particle texture, in pixels. Needs the Texture Size Cap switch on (restart after switching it). Reload resources (F3 + T) after changing.
• Mobs Remember Fluid Checks: A mob near water that is not in it looked at every block of its box for fluid each tick. Now it keeps the answer until the blocks around it change. Same results as vanilla.
• No Needless Ticket Saves: The chunk ticket file is no longer rewritten at every autosave when no saved ticket has counted down. The file is the same.
• Pace Chunks on Slow Links: On a server, a player on a slow connection is not sent a new batch of chunks while their connection is backed up or two batches are still unanswered, so that moves and block changes are not stuck behind chunk data.
• Pack Packets Without a Copy: Packets are packed where they lie instead of being copied first. The bytes sent are the same; less garbage.
• Parallel Mipmaps: Makes the mipmaps of all textures on all of the game's background workers instead of one after the other. Helps resource pack loading on PCs with 3 or more cores.
• Plain Random Numbers: Every world and every entity drew its random numbers with a locked memory write and a check against other threads on each one, thousands of times a tick. Now they use the game's own plain source, which gives the same numbers. Same results as vanilla.
• Redstone Dust Remembers Its Power: Redstone dust worked out its power again for every neighbour update, mostly with nothing around it changed. Now it keeps the answer until a block in the chunk sections around it changes. Same redstone as vanilla.
• Reused Region Compressor: Chunks saved to region files are compressed with one compressor per thread instead of a new one for every chunk. The saved bytes are the same as the game's own.
• Shared Multi-Player Packets: Light, block entity and block update packets sent to several players are packed once and the same bytes go to each.
• Skip Finished Fade-In: Terrain skips the fade-in blend once a chunk has finished appearing. Same picture, a little less work per pixel.
• Skip Unused Shaders: Shaders that only debug views use aren't built at startup, and identical ones share one program. Less to build on a slow CPU and less in the graphics driver.
• Texture Size Cap: For high-resolution resource packs (128x and up) on computers with little memory or an old graphics card. Block, item and particle textures bigger than the size set below are scaled down as they load, which saves memory and graphics memory but loses detail; smaller ones are left alone. An atlas too big for the graphics card is scaled down instead of stopping the game. Changes take effect at the next resource reload (F3 + T).
• Walking Mobs Skip Block Effects: A mob that walks through empty surroundings no longer runs the step in which blocks act on it, until something around it changes. Same results as vanilla.

New, off by default (still being tried, or no gain measured yet; each can be switched on in the settings)

• Block Updates Reuse One Position: A changed block tells its six neighbours, and each told block got its own new position object even when it does nothing with it. Now blocks that ignore the news share one. Same updates in the same order.
• Cached Biome Zoom: Which biome a block is in is found from the eight quart corners around it, each nudged by a pseudo-random number. The surface layer of new land worked those numbers out again for every column. Now each corner is worked out once per chunk. Same biomes as vanilla.
• Cap on Eager Chunk Saves: While the server is running late, at most two changed chunks are saved per tick instead of up to twenty; the rest wait. Fewer long ticks; nothing is lost.
• Cheaper Fog: Fog is worked out at the corners of each terrain triangle instead of at every pixel. Slightly less work per pixel; distant fog can look a touch different.
• Cheaper Region Compression: Chunks are saved with lighter compression, which costs the saving thread less CPU but makes the world files bigger. Any other tool or game version reads them.
• Compressed Block Atlas: With a high-resolution resource pack (128x or bigger), keeps the block textures on the graphics card in a compressed form, a quarter of the size. Slightly lossy and slower to load; needs OpenGL with S3TC. Restart needed.
• Containers Skip Empty Comparator Look-Around: A container whose contents changed looked at 8 blocks around it for comparators. Now it skips that when its chunk section has no comparator at all. Same updates; no quicker.
• Count Dropped Item Copies: Only counts and logs how many dropped item stacks are drawn and how many times their models are submitted. Changes nothing you see.
• Entity Shadow Cache: Entity shadows read the blocks under each entity again every frame. This keeps them while nothing around changes. Meant to be the same picture as vanilla, but not yet checked in a real game.
• Explosion Sound Cap: At most 8 explosion sounds a tick; the extra ones in a big chain reaction are not played. Particles and blocks are not affected.
• Far Entities Less Often: On a server, a player on a slow connection is sent entities that are more than 32 blocks away every 6 ticks (12 beyond 64 blocks) instead of every 3. Far mobs move in bigger steps, so this is off by default.
• Faster Inventory Advancement Checks: Picking up or moving an item checks only the advancements that wait for that item, instead of every unfinished recipe unlock. Same advancements, same order as vanilla.
• Fewer Particles on Slow Links: On a server, a player on a slow connection is not sent decorative particles (hearts, smoke, crits...), and at most 100 particles a tick.
• Free Texture Pixels After Loading: Block, item and particle textures keep a second copy of their pixels in the computer's memory after they are on the graphics card. This lets that copy go (hundreds of MB with a high-resolution pack). The picture is the same.
• Half Size Menu Blur: The blurred background behind the title screen and the pause menu is worked out at half the width and height, which is much lighter on a weak graphics chip. The blur looks a little softer. Off while a shader pack is active.
• Half-Rate Big Fading Textures: With high-resolution texture packs, textures that fade between frames and are 128 pixels or wider are redrawn every second tick instead of every tick, so the fade moves in coarser steps. Frame changes still show at once. Less work for slow graphics chips.
• Half-Size Glow Outline: The outline around glowing entities is drawn at half width and height, which is much lighter on the graphics chip. The outline looks a little softer and wider.
• Heightmaps From Blocks: With the chunk link, chunks are sent without their heightmaps, which your game works out from the blocks. Not tried with a real game yet.
• Kept Mob Count For Spawning: Every tick the game counts all mobs in the world, walking every entity there is, items and experience orbs too. Now it keeps a list of just the mobs and looks each chunk up once. Same counts as vanilla. No measurable gain. Needs Faster Mob Spawning.
• Lazy Nearby-Mob Sorting: A mob's list of living things nearby was sorted by distance at every scan, though most scans nothing reads the order. Now it is sorted when first read, from the distances at the scan. Same order as vanilla. No measurable gain.
• Light Read Once Per Chunk Build: While a chunk section is built, the light data of the sections around it is looked up once and the light of every block is read from that, instead of going through the light engine each time. Same light. Not yet checked in a real game.
• Move Model Corners Once: The boxes of mobs, players and armour have 8 corners, but the game moved each one three times. Now once. The same picture, but it measured no faster.
• Paced Light Updates: Light updates from the server are applied for about 2.5 ms a frame, the rest in the next frames, in order. Fewer stutters when many chunks arrive; the light is the same once they are done, but a chunk can look dark for a moment.
• Paced Server Packets: Packets from the server are handled for about 5 ms a frame, the rest in the next frames, in order. Fewer stutters after a lag spike; things in a backlog arrive a few frames later.
• Particle Quads Without Garbage: Particles are turned to face the camera with a few reused objects instead of five new ones per particle per frame. Same picture as vanilla, but not yet checked in a real game.
• Rain Column Cache: Rain and snow look up the ground height, the weather and the light of up to 441 columns around you every frame. This keeps the answers while nothing changes. Meant to be the same picture as vanilla, but not yet checked in a real game.
• Redstone Dust Updates Without a Set: A wire whose power changed built a set of 7 positions to update its neighbours in the set's order. Now the same order is worked out without the set. Same updates, same order; no change in tick time.
• Remembered Text Layout: Text drawn from plain strings, such as the F3 screen and many HUD labels, keeps its laid-out letters from frame to frame instead of building them again each frame. Same picture. Not yet checked in a real game; chat, tooltips and names are not covered.
• Repair Damaged Region Files: When the table at the start of a world's region file is damaged, chunks are found again from the data still in the file instead of being lost, after a copy of the file is kept. Healthy files are never changed. Switch it on for a broken world.
• Resting TNT Memory: A lit TNT lying still remembers how far it can move until something around it changes. It is not shown on a long run yet.
• Reuse Chunk Build Copies: Building a chunk copies the blocks of its 27 sections; a section that has not changed since it was last copied now hands out the same copy again, and sections of one block only share one. Less work and garbage while chunks load. Same chunks as vanilla. Until it has been checked in a real client.
• Shared Entity Packet Compression: An entity packet sent to several players that is big enough to be packed is packed once and the same bytes are sent to each. Most entity packets are too small to be packed, so it rarely does anything.
• Single Screen Clear: The screen is wiped once per frame in the world instead of twice. The picture is the same. Off while a shader pack is active.
• Skip Back Faces of Entity Models: Mobs, players and armour are built from boxes, and half of each box faces away from you and is thrown away by the graphics card. Now those faces are not written at all. Same picture. Until it has been checked in a real client.
• Skip Back Faces While Bobbing: Lets the skipping of back faces of entity models work while view bobbing moves your eye, judging by where the eye really is. Needs Skip Back Faces. Until it has been checked in a real client.
• Skip Chunks Hidden In Thick Fog: Chunk sections that lie wholly in fully opaque fog (in lava, powder snow, with blindness or darkness, in the Nether) are not drawn or built. They would show the fog colour anyway. Never with a shader pack. Not yet checked in a real game.
• Skip Re-Hashing Cached Server Packs: A server resource pack kept from an earlier join is not read through and hashed again when a small record next to it matches the file's size and modified time. A pack edited without changing its size and time would go unnoticed.
• Skip Repeated Light: Server: light that is byte for byte what a chunk last sent is left out of its light packets, so players get fewer light packets and their games rebuild fewer sections.
• Skip Repeated Light Rebuilds: When the server sends light for a chunk section that is exactly what the game already has, the section and its neighbours are not rebuilt. Not tried in a real game yet.
• Skip Saving Unchanged Player Files: Autosave no longer rewrites a player's statistics or advancements file when it would be exactly the same. The files are the same.
• Stepped Animations: Textures that fade smoothly from one frame to the next (command blocks, sculk, magma, prismarine...) jump between frames like the rest, and are only redrawn when the frame changes. Less work for slow graphics chips.
• Still World Behind Blurred Menus: While the pause menu or the options opened from it blur the background, the world is drawn once and kept, and drawn again once a second, instead of every frame. Much lighter on a weak graphics chip, but the world behind the blur stands still. Chat, the inventory and other screens that show the live world are not affected. Off while a shader pack is active.

Everything else is as in 0.2.6.