diff --git a/JAVA_MIGRATION.md b/JAVA_MIGRATION.md index bd7cf0e..84ab901 100644 --- a/JAVA_MIGRATION.md +++ b/JAVA_MIGRATION.md @@ -1193,3 +1193,12 @@ generated-trait compatibility work. Scala-runtime removal remains a later projec - A clean build passes all 252 plain-JVM tests and the Java 8 Forge server passes all 110 tests. All nine supported public surfaces match the reference; both retained trait helpers and all seven trait closures are bytecode-identical. Only three private factory table-initializer closures disappear. `microblock/TMicroOcclusion.scala` is next. +- Characterized `MicroOcclusion` against untouched Scala. Five plain-JVM cases freeze the facade, companion, three + generated-trait surfaces, all valid shrink-side mappings, exhaustive priority/size/transparency decisions, render + masks, traversal ranges and the complete `TMicroOcclusion` decision matrix. +- Ported only the concrete facade and companion to Java. `JMicroShrinkRender`, `TMicroOcclusion` and the stateful + `TMicroOcclusionClient` remain Scala; both trait helpers and all five retained Scala types have bytecode-identical + disassembly. Direct Java iteration removes the sole private shrink closure. +- A clean build passes all 257 plain-JVM tests and the Java 8 Forge server passes all 110 tests. All seven supported + public surfaces and WR-CBE's static `recalcBounds` descriptor match the reference. `microblock/MicroblockGenerator.scala` + is next. diff --git a/JAVA_MIGRATION_DIVERGENCES.md b/JAVA_MIGRATION_DIVERGENCES.md index 3f2613b..b1eeb3d 100644 --- a/JAVA_MIGRATION_DIVERGENCES.md +++ b/JAVA_MIGRATION_DIVERGENCES.md @@ -2954,3 +2954,46 @@ identical `javap -c -p -s` output after the port. - Raw `javap` comparison confirms identical callable public names/descriptors for all nine supported types, the exact nested-grid relationship, and bytecode-identical retained trait helpers and closures. - Actual client rendering, breaking overlay and hollow highlight geometry remain on the manual checklist. + +## 2026-09-02 — Micro occlusion Java port + +The concrete `MicroOcclusion` facade and companion are now Java. `JMicroShrinkRender`, `TMicroOcclusion` and the +stateful `TMicroOcclusionClient` remain Scala in `TMicroOcclusion.scala`, preserving their generated-trait, +super-accessor and mutable render-state surfaces without involving the generator. + +### Observable behavior + +No known runtime divergence. Axis shrink remains non-expanding and keeps `-1` as a no-op. Shape priority remains +cover, corner, then edge/post; priority class, size, transparency and slot tie-breaking retain their original order, +including transparency taking precedence over size only for covers. Every valid face/corner/edge `shrinkSide` +mapping is unchanged. + +`shrinkFrom` still either contracts the render bounds or masks a fully covered opaque face. Recalculation still +visits slots 0 through 5 for covers, 0 through 14 for corners, and 0 through 26 for edges/posts. The original Scala +`TMicroOcclusion` material, size, opposite-part and edge/corner decisions are unchanged. + +### ABI and reflection compatibility + +All seven supported facade, companion, trait and `$class` types keep their hierarchy and callable public +names/descriptors. WR-CBE's load-bearing static +`MicroOcclusion.recalcBounds(JMicroShrinkRender, Cuboid6): int` call remains exact, as does the +`JMicroShrinkRender` interface. The downstream inventory contains no references to the private implementation +closure or trait helpers. + +The five retained Scala types and helpers have bytecode-identical `javap -p -c -s` output. Accepted classfile-only +differences in the two Java types are ordinary Java singleton initialization, constructors and removed Scala +signature/marker attributes. + +### Compiler artifacts + +`MicroOcclusion$$anonfun$shrink$1` disappears. Direct Java slot iteration needs no closure, and the downstream +inventory contains no reference to it. + +### Validation + +- `MicroOcclusionCharacterizationTest`: 5 plain-JVM tests, unchanged from the Scala baseline. +- Clean complete plain-JVM suite: 257 tests, 0 failures, 0 errors. +- Java 8 Forge dedicated-server suite: 110 tests, 0 failures, 0 errors. +- Raw `javap` comparison confirms identical callable public names/descriptors for all seven supported types and + bytecode-identical retained trait/helper disassembly. +- Actual neighbour-driven shrink and render-bound refresh remain on the manual checklist. diff --git a/JAVA_MIGRATION_HANDOFF.md b/JAVA_MIGRATION_HANDOFF.md index 47e9d2a..92302e7 100644 --- a/JAVA_MIGRATION_HANDOFF.md +++ b/JAVA_MIGRATION_HANDOFF.md @@ -12,8 +12,8 @@ what breaks, and what is left. The other documents hold the reasoning. | `JAVA_MIGRATION_MANUAL_CHECKS.md` | What no automated test can cover, and must be checked by hand in a client | | `JAVA_MIGRATION_PROFILE.md` | The focused baseline, first measured result, findings, and exact rerun command | -Branch: `algent/java`. Base: `master`. 144 commits including the API-cleanup plan and separate characterization and -port commits through the Hollow microblock factory. +Branch: `algent/java`. Base: `master`. 146 commits including the API-cleanup plan and separate characterization and +port commits through micro occlusion. ## The one rule that matters @@ -67,7 +67,7 @@ awk -F'"' '/ bounds.min.y) { + renderBounds.max.y = bounds.min.y; + } + return; + case 2: + if (renderBounds.min.z < bounds.max.z) { + renderBounds.min.z = bounds.max.z; + } + return; + case 3: + if (renderBounds.max.z > bounds.min.z) { + renderBounds.max.z = bounds.min.z; + } + return; + case 4: + if (renderBounds.min.x < bounds.max.x) { + renderBounds.min.x = bounds.max.x; + } + return; + case 5: + if (renderBounds.max.x > bounds.min.x) { + renderBounds.max.x = bounds.min.x; + } + return; + default: + throw new MatchError(side); + } + } + + public int shrinkFrom(JMicroShrinkRender part, JMicroShrinkRender other, Cuboid6 renderBounds) { + if (shrinkTest(part, other)) { + shrink(renderBounds, other.getBounds(), shrinkSide(part.getSlot(), other.getSlot())); + } else if (other.getSlot() < 6 && !other.isTransparent()) { + boolean coversFace; + switch (other.getSlot()) { + case 0: + coversFace = renderBounds.min.y <= 0; + break; + case 1: + coversFace = renderBounds.max.y >= 1; + break; + case 2: + coversFace = renderBounds.min.z <= 0; + break; + case 3: + coversFace = renderBounds.max.z >= 1; + break; + case 4: + coversFace = renderBounds.min.x <= 0; + break; + case 5: + coversFace = renderBounds.max.x >= 1; + break; + default: + throw new MatchError(other.getSlot()); + } + if (coversFace) { + return 1 << other.getSlot(); + } + } + return 0; + } + + public int shrink(JMicroShrinkRender part, Cuboid6 renderBounds, int slots) { + int renderMask = 0; + TileMultipart tile = ((TMultiPart) part).tile(); + for (int slot = 0; slot < slots; slot++) { + if (slot != part.getSlot()) { + TMultiPart other = tile.partMap(slot); + if (other instanceof JMicroShrinkRender) { + renderMask |= shrinkFrom(part, (JMicroShrinkRender) other, renderBounds); + } + } + } + return renderMask; + } + + public int shrinkSide(int firstSlot, int secondSlot) { + if (secondSlot < 6) { + return secondSlot; + } + if (firstSlot < 15) { + int firstCorner = firstSlot - 7; + int secondCorner = secondSlot - 7; + switch (firstCorner ^ secondCorner) { + case 1: + return secondCorner & 1; + case 2: + return 2 | (secondCorner & 2) >> 1; + case 4: + return 4 | (secondCorner & 4) >> 2; + default: + return -1; + } + } + if (secondSlot < 15) { + int firstEdge = firstSlot - 15; + int secondCorner = secondSlot - 7; + int edgeBits = unpackEdgeBits(firstEdge); + if ((secondCorner & edgeAxisMask(firstEdge)) != edgeBits) { + return -1; + } + return (firstEdge & 0xC) >> 1 | (secondCorner & ~edgeBits) >> (firstEdge >> 2); + } + + int firstEdge = firstSlot - 15; + int secondEdge = secondSlot - 15; + int firstBits = unpackEdgeBits(firstEdge); + int secondBits = unpackEdgeBits(secondEdge); + if ((firstEdge & 0xC) == (secondEdge & 0xC)) { + switch (firstBits ^ secondBits) { + case 1: + return (secondBits & 1) == 0 ? 0 : 1; + case 2: + return (secondBits & 2) == 0 ? 2 : 3; + case 4: + return (secondBits & 4) == 0 ? 4 : 5; + default: + return -1; + } + } + + int mask = edgeAxisMask(firstEdge) & edgeAxisMask(secondEdge); + if ((firstBits & mask) != (secondBits & mask)) { + return -1; + } + switch (firstEdge >> 2) { + case 0: + return (secondBits & 1) == 0 ? 0 : 1; + case 1: + return (secondBits & 2) == 0 ? 2 : 3; + case 2: + return (secondBits & 4) == 0 ? 4 : 5; + default: + throw new IllegalArgumentException("Switch Falloff"); + } + } + + public int recalcBounds(JMicroShrinkRender part, Cuboid6 renderBounds) { + if (part.getSlot() < 6) { + return shrink(part, renderBounds, 6); + } + if (part.getSlot() < 15) { + return shrink(part, renderBounds, 15); + } + return shrink(part, renderBounds, 27); + } + + public int shapePriority(int slot) { + if (slot < 6) { + return 2; + } + if (slot < 15) { + return 1; + } + return 0; + } + + public boolean shrinkTest(JMicroShrinkRender first, JMicroShrinkRender second) { + if (first.getPriorityClass() != second.getPriorityClass()) { + return first.getPriorityClass() < second.getPriorityClass(); + } + + int firstShape = shapePriority(first.getSlot()); + int secondShape = shapePriority(second.getSlot()); + if (firstShape != secondShape) { + return firstShape < secondShape; + } + if (first.getSlot() < 6) { + if (first.isTransparent() != second.isTransparent()) { + return first.isTransparent(); + } + if (first.getSize() != second.getSize()) { + return first.getSize() < second.getSize(); + } + } else { + if (first.getSize() != second.getSize()) { + return first.getSize() < second.getSize(); + } + if (first.isTransparent() != second.isTransparent()) { + return first.isTransparent(); + } + } + return first.getSlot() < second.getSlot(); + } +} diff --git a/src/main/scala/codechicken/microblock/MicroOcclusion.java b/src/main/scala/codechicken/microblock/MicroOcclusion.java new file mode 100644 index 0000000..a6d3fd6 --- /dev/null +++ b/src/main/scala/codechicken/microblock/MicroOcclusion.java @@ -0,0 +1,36 @@ +package codechicken.microblock; + +import codechicken.lib.vec.Cuboid6; + +public final class MicroOcclusion { + + private MicroOcclusion() {} + + public static void shrink(Cuboid6 renderBounds, Cuboid6 bounds, int side) { + MicroOcclusion$.MODULE$.shrink(renderBounds, bounds, side); + } + + public static int shrinkFrom(JMicroShrinkRender part, JMicroShrinkRender other, Cuboid6 renderBounds) { + return MicroOcclusion$.MODULE$.shrinkFrom(part, other, renderBounds); + } + + public static int shrink(JMicroShrinkRender part, Cuboid6 renderBounds, int slots) { + return MicroOcclusion$.MODULE$.shrink(part, renderBounds, slots); + } + + public static int shrinkSide(int firstSlot, int secondSlot) { + return MicroOcclusion$.MODULE$.shrinkSide(firstSlot, secondSlot); + } + + public static int recalcBounds(JMicroShrinkRender part, Cuboid6 renderBounds) { + return MicroOcclusion$.MODULE$.recalcBounds(part, renderBounds); + } + + public static int shapePriority(int slot) { + return MicroOcclusion$.MODULE$.shapePriority(slot); + } + + public static boolean shrinkTest(JMicroShrinkRender first, JMicroShrinkRender second) { + return MicroOcclusion$.MODULE$.shrinkTest(first, second); + } +} diff --git a/src/main/scala/codechicken/microblock/TMicroOcclusion.scala b/src/main/scala/codechicken/microblock/TMicroOcclusion.scala index 4aa2fca..046d174 100644 --- a/src/main/scala/codechicken/microblock/TMicroOcclusion.scala +++ b/src/main/scala/codechicken/microblock/TMicroOcclusion.scala @@ -5,156 +5,6 @@ import codechicken.lib.vec.Cuboid6 import codechicken.multipart.PartMap._ import codechicken.lib.data.MCDataInput -/** Suite of classes for performing microblock style occlusion and shrink - * rendering. Use at your own peril. - */ -object MicroOcclusion { - def shrink(renderBounds: Cuboid6, b: Cuboid6, side: Int) = side match { - case -1 => - case 0 => if (renderBounds.min.y < b.max.y) renderBounds.min.y = b.max.y - case 1 => if (renderBounds.max.y > b.min.y) renderBounds.max.y = b.min.y - case 2 => if (renderBounds.min.z < b.max.z) renderBounds.min.z = b.max.z - case 3 => if (renderBounds.max.z > b.min.z) renderBounds.max.z = b.min.z - case 4 => if (renderBounds.min.x < b.max.x) renderBounds.min.x = b.max.x - case 5 => if (renderBounds.max.x > b.min.x) renderBounds.max.x = b.min.x - } - - def shrinkFrom( - p: JMicroShrinkRender, - other: JMicroShrinkRender, - renderBounds: Cuboid6 - ): Int = { - if (shrinkTest(p, other)) { - shrink( - renderBounds, - other.getBounds, - shrinkSide(p.getSlot, other.getSlot) - ) - } else if ( - other.getSlot < 6 && !other.isTransparent - ) // other gets full face, we didn't shrink, flag rendermask - { - if ( - other.getSlot match { - case 0 => renderBounds.min.y <= 0 - case 1 => renderBounds.max.y >= 1 - case 2 => renderBounds.min.z <= 0 - case 3 => renderBounds.max.z >= 1 - case 4 => renderBounds.min.x <= 0 - case 5 => renderBounds.max.x >= 1 - } - ) - return 1 << other.getSlot - } - return 0 - } - - def shrink(p: JMicroShrinkRender, renderBounds: Cuboid6, m: Int): Int = { - var renderMask = 0 - val part = p.asInstanceOf[TMultiPart] - val tile = part.tile - for (i <- 0 until m) - if (i != p.getSlot) - tile.partMap(i) match { - case other: JMicroShrinkRender => - renderMask |= shrinkFrom(p, other, renderBounds) - case _ => - } - return renderMask - } - - def shrinkSide(s1: Int, s2: Int): Int = { - if (s2 < 6) // other is a cover - return s2 - if (s1 < 15) // both corners - { - val c1 = s1 - 7 - val c2 = s2 - 7 - return c1 ^ c2 match // different axis bits will become 1, same 0 - { - case 1 => c2 & 1 - case 2 => 2 | (c2 & 2) >> 1 - case 4 => 4 | (c2 & 4) >> 2 - case _ => -1 - } - } - if (s2 < 15) // edge, other corner - { - val e1 = s1 - 15 - val c2 = s2 - 7 - val ebits = unpackEdgeBits(e1) - if ((c2 & edgeAxisMask(e1)) != ebits) - return -1 - - return (e1 & 0xc) >> 1 | (c2 & (~ebits)) >> (e1 >> 2) - } - // both edges - { - val e1 = s1 - 15 - val e2 = s2 - 15 - val e1bits = unpackEdgeBits(e1) - val e2bits = unpackEdgeBits(e2) - if ((e1 & 0xc) == (e2 & 0xc)) // same axis - { - return e1bits ^ e2bits match { - case 1 => if ((e2bits & 1) == 0) 0 else 1 - case 2 => if ((e2bits & 2) == 0) 2 else 3 - case 4 => if ((e2bits & 4) == 0) 4 else 5 - case _ => -1 - } - } else { - val mask = edgeAxisMask(e1) & edgeAxisMask(e2) - if ((e1bits & mask) != (e2bits & mask)) - return -1 - - return e1 >> 2 match { - case 0 => if ((e2bits & 1) == 0) 0 else 1 - case 1 => if ((e2bits & 2) == 0) 2 else 3 - case 2 => if ((e2bits & 4) == 0) 4 else 5 - } - } - } - - throw new IllegalArgumentException("Switch Falloff") - } - - def recalcBounds(p: JMicroShrinkRender, renderBounds: Cuboid6) = { - if (p.getSlot < 6) - shrink(p, renderBounds, 6) - else if (p.getSlot < 15) - shrink(p, renderBounds, 15) - else - shrink(p, renderBounds, 27) - } - - def shapePriority(slot: Int): Int = - if (slot < 6) - return 2 - else if (slot < 15) - return 1 - else - return 0 - - def shrinkTest(a: JMicroShrinkRender, b: JMicroShrinkRender): Boolean = { - if (a.getPriorityClass != b.getPriorityClass) - return a.getPriorityClass < b.getPriorityClass - - val shape1 = shapePriority(a.getSlot) - val shape2 = shapePriority(b.getSlot) - - if (shape1 != shape2) return shape1 < shape2 - if (a.getSlot < 6) // transparency takes precedence for covers - { - if (a.isTransparent != b.isTransparent) return a.isTransparent - if (a.getSize != b.getSize) return a.getSize < b.getSize - } else { - if (a.getSize != b.getSize) return a.getSize < b.getSize - if (a.isTransparent != b.isTransparent) return a.isTransparent - } - return a.getSlot < b.getSlot - } -} - trait JMicroShrinkRender { def getPriorityClass: Int def getSlot: Int @@ -184,15 +34,13 @@ trait TMicroOcclusionClient extends TMicroOcclusion with JMicroShrinkRender { def recalcBounds() { renderBounds = getBounds.copy - renderMask = MicroOcclusion.recalcBounds(this, renderBounds) + renderMask = MicroOcclusion$.MODULE$.recalcBounds(this, renderBounds) } override def getPriorityClass = 0 } trait TMicroOcclusion extends TMultiPart { - import MicroOcclusion._ - def getSlot: Int def getSize: Int def getMaterial: Int @@ -206,8 +54,8 @@ trait TMicroOcclusion extends TMultiPart { return true val mpart = npart.asInstanceOf[TMicroOcclusion] - val shape1 = shapePriority(getSlot) - val shape2 = shapePriority(mpart.getSlot) + val shape1 = MicroOcclusion$.MODULE$.shapePriority(getSlot) + val shape2 = MicroOcclusion$.MODULE$.shapePriority(mpart.getSlot) if (mpart.getSize + getSize > 8) // intersecting if opposite {