Tags
Creators
Details
2.6.1
Compatibility
Changes
Added
-
One effect instance can carry a list of world positions.
VFXTriggerPayloadgained an optionalList<Vec3> positionsfield (empty = the exact single-point behaviour;positionandentityUuidsare unchanged), carried by aByteBufCodecs.collection(ArrayList::new, Vec3.STREAM_CODEC, MAX_POSITIONS)-shaped codec withMAX_POSITIONS = 4096, mirroringVFXDefinition.MAX_POSITIONS. That cap is a packet-size bound, not an instance cap: one instance renders at every point in the list and so spends a single lifecycle slot, whatever the list length.VFXAPI.sendEffect(ServerPlayer, Identifier, long instanceId, List<Vec3> positions, Map<String, Float> overrides, @Nullable EasingType easing)sends one such payload; every older overload is unchanged and still delegates. On the client,VFXClientpassespositionsthroughVFXEffectManager.playinto a new nullable runtime position list onVFXActiveEffect, andVFXWorldOverlayRenderer.effectPositionsprefers it over a runtime move position and the definition's ownpositions(rawVec3s, no block-centre offset).sendStop(player, effectId, instanceId)already matches by instance id, so it stops every position of the instance;MAX_ACTIVE_EFFECTSis untouched.VFXServerEffectskeeps the list in its per-player bookkeeping and re-sends it on reconnect, so a many-block instance survives a relog instead of collapsing to the definition's single point.FlashbackCompatcarries the list in its replay action (optional trailing block, so older recordings still decode), so a recorded many-block effect keeps its positions. One caution: the new(long, List<Vec3>, ...)overload makes a literalnullposition argument ambiguous against the existing(long, Vec3, ...)overload — such source must cast ((Vec3) null) or keep using the old overload. This is a wire change:PROTOCOL_VERSION7 → 8, and client and server must be the same version; an older client drops the whole packet on the mismatch, so it renders nothing until it updates rather than falling back to the single point. Documented in API.md; the pixels cannot be verified headless here. Not verified in game. -
block_listmask: mask an authored coordinate list with texture alpha. A new mask leaf (shape: "block_list") masks exactly the blocks named bypositions([[x, y, z], ...]) orregion([x0, y0, z0, x1, y1, z1]), rendering their own models and sampling the block texture atlas so leaves, plants and glass keep their cutout alpha.fill: "solid"(the default) covers the block area plus an outline ofstroke_widthblocks,hollowonly the outline (the one leaf that acceptshollow);stroke_widthdefaults to0.05and is animatable,occludebehaves as on theblockleaf. There is no cap onpositions- the models are cached, so a static list costs two draws per frame - while aregionis capped at 65536 blocks, the block-geometry vertex-buffer budget. The editor authors the leaf on the canvas (afillcombo, apositions/regionJSON field and anoccludetoggle beside the animatable band socket). See masks. Verified in game on 26.2 Fabric; the other five nodes were not separately checked.
Fixed
- A
block_listmask stays above the blocks it masks. The geometry pass draws the very models it masks, so the mask surface is coplanar with the block surface and the depth compare against the scene was decided by float noise between two different rasterisation paths - a masked block could draw over the mask, and at coincident faces the coverage flickered. The compare is now in world units: both depths are linearised with the frame's own projection (distance = b / (zNdc - a), thea/bterms uploaded per frame from the pure projection) and the mask is discarded only when it is farther than the scene by more than a tolerance in blocks. That tolerance is0.05 + 4.0e-6 * distance^2rather than a constant: the scene depth is quantised, so its own linearisation error grows as10 * d^2 * dz(about 1.2 cm at 100 blocks, 4.8 cm at 200), and a fixed margin would start flickering again past ~200 blocks. A coincident face stays inside it at every range; a wall one block in front stays outside it (the margin is 0.21 blocks at 200 and 0.41 at 300) until roughly 490 blocks, where one block of separation is smaller than what the depth buffer resolves anyway. The vertices are emitted exactly where the block is - no world-space nudge and no NDC bias, so there is zero parallax; if a frame somehow cannot produce the linearisation terms, an occluding mask is not drawn rather than painted over walls.occlude: falseis still the x-ray look. Pinned byscripts/check-mask-pipeline.ps1. Verified in game on 26.2 Fabric; the other five nodes were not separately checked. - A
block_listmask stays on its blocks while the FOV moves. The coverage pass rebuilt its inverse view-projection from the live camera, so sprinting, flying or a jump's FOV kick made the projection differ from the one the world (and the depth buffer) was rendered with, and the mask slid across the blocks it was masking. It now reads the frame's ownCameraRenderState-projectionMatrix×viewRotationMatrix, andposfrom that same state - straight from the game render state (gameRenderState().levelRenderState.cameraRenderState); the live camera is only the fallback, and on1.21.11(whose state carries no matrices) the projection is rebuilt from the FOV the frame was rendered with, captured by the existinggetFovhook, instead of the unmodulatedoptions.fov(). The block geometry is also drawn with this pass's ownProjectionuniform (no frameModelViewMat), and a listedpositionsmask re-checks its coordinates' block states every frame so a placed, broken or restated block re-bakes. Pinned byscripts/check-mask-pipeline.ps1. Verified in game on 26.2 Fabric; the other five nodes were not separately checked. - A
block_listmask stays on its blocks while you walk, not only while you stand still. With the projection taken from the frame, the remaining mismatch was the view bob: vanilla foldsbobHurt(andbobView, when View Bobbing is on) into the projection it hands the level renderer -GameRenderer.renderLevelbuildsprojection * bobPoseand passes the rotation as the model-view - while the mask composedprojection * viewRotation, which carries no bob, so walking made the mask oscillate sideways against the blocks. The mask now publishes the world's own bob pose once per frame, built from vanilla's ownbobHurt/bobViewthrough the mixin's@Invokers (bobHurtalways,bobViewonly whenoptions.bobView()says so, with the camera's partial tick, exactly as vanilla composes it), intoVFXWorldBob, and folds it in asprojection * bob * rotation. The pose is built in one reusedPoseStack(beginScratch/publishScratch), so a frame allocates nothing, and it is identity until the first publish - a frame that never got one is drawn exactly as before. On1.21.11, whose camera render state carries no matrices, the fallbackgetProjectionMatrix(fov)is composed with the samebob * rotation, becauserenderLevelfolds the bob there too. Pinned byscripts/check-mask-pipeline.ps1. Verified in game on 26.2 Fabric; the other five nodes were not separately checked.
Projects on Modrinth are automatically available through a Maven repository for use with JVM build tools such as Gradle. To learn more about the Modrinth Maven API, click here.
Note: When available, you should use the creator's maven repo instead as it will have transitive dependency information that the Modrinth Maven API does not. You may also end up with duplicate dependencies if you use a mix of Modrinth and non-Modrinth Maven repositories for your dependencies, because the group identifier will be different when served through the Modrinth Maven API.
Maven coordinates:
Version ID:
build.gradle:
repositories {
exclusiveContent {
forRepository {
maven {
name = "Modrinth"
url = "https://api.modrinth.com/maven"
}
}
// forRepositories(fg.repository) // Uncomment when using ForgeGradle
filter {
includeGroup "maven.modrinth"
}
}
}
// Standard Gradle dependency
dependencies {
implementation "maven.modrinth:HBhB8m4j:wiOydzpp"
}
// Legacy Loom dependency
dependencies {
modImplementation "maven.modrinth:HBhB8m4j:wiOydzpp"
}

