diff --git a/src/functionalTest/java/codechicken/multipart/test/HollowMicroblockClientFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/HollowMicroblockClientFunctionalTest.java new file mode 100644 index 0000000..73b1b74 --- /dev/null +++ b/src/functionalTest/java/codechicken/multipart/test/HollowMicroblockClientFunctionalTest.java @@ -0,0 +1,268 @@ +package codechicken.multipart.test; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; + +import net.minecraft.util.IIcon; + +import org.junit.jupiter.api.Test; + +import codechicken.lib.data.MCDataInput; +import codechicken.lib.raytracer.IndexedCuboid6; +import codechicken.lib.vec.Cuboid6; +import codechicken.lib.vec.Vector3; +import codechicken.microblock.HollowMicroClass$; +import codechicken.microblock.HollowMicroblock$class; +import codechicken.microblock.HollowMicroblockClient; +import codechicken.microblock.HollowMicroblockClient$class; +import codechicken.microblock.ISidedHollowConnect; +import codechicken.microblock.MicroMaterialRegistry; +import codechicken.microblock.MicroMaterialRegistry.IMicroMaterial; +import codechicken.microblock.Microblock; +import codechicken.microblock.TMicroOcclusionClient$class; +import codechicken.multipart.TMultiPart; +import codechicken.multipart.TileMultipart; +import scala.Function5; +import scala.runtime.AbstractFunction5; +import scala.runtime.BoxedUnit; + +class HollowMicroblockClientFunctionalTest { + + @Test + void realBoundsAndLiveCenterConnectorDriveClientMaskAndRimsOnAllFortyTwoShapes() { + ClientProbe part = new ClientProbe(MicroMaterialRegistry.materialID("minecraft:stone")); + SlotTile tile = new SlotTile(); + part.bind(tile); + for (int size = 1; size <= 7; size++) { + for (int side = 0; side < 6; side++) { + part.setShape(size, side); + for (int opening : new int[] { 1, 8, 11 }) { + tile.connector.size = opening; + part.recalcBounds(); + assertEquals(opening << 8, part.renderMask()); + assertEquals(side, tile.connector.side); + Cuboid6 physical = part.getBounds(); + assertNotSame(physical, part.renderBounds()); + assertBounds(physical, part.renderBounds()); + int[] calls = { 0 }; + double[] volume = { 0 }; + part.renderHollow( + new Vector3(), + 0, + part.renderBounds(), + 0, + false, + new AbstractFunction5() { + + @Override + public BoxedUnit apply(Vector3 pos, IMicroMaterial material, Object pass, Cuboid6 box, + Object mask) { + assertSame(part.getIMaterial(), material); + assertEquals(0, pass); + // The first two callbacks draw internal walls; the last four span the rim volume. + if (calls[0]++ >= 2) volume[0] += (box.max.x - box.min.x) * (box.max.y - box.min.y) + * (box.max.z - box.min.z); + return BoxedUnit.UNIT; + } + }); + assertEquals(6, calls[0]); + assertEquals(size / 8D * (1 - opening / 16D * (opening / 16D)), volume[0], 1e-12); + } + tile.connected = false; + part.recalcBounds(); + assertEquals(8 << 8, part.renderMask()); + tile.connected = true; + } + } + } + + private static void assertBounds(Cuboid6 expected, Cuboid6 actual) { + assertArrayEquals( + new double[] { expected.min.x, expected.min.y, expected.min.z, expected.max.x, expected.max.y, + expected.max.z }, + new double[] { actual.min.x, actual.min.y, actual.min.z, actual.max.x, actual.max.y, actual.max.z }, + 1e-12); + } + + private static final class Connector extends TMultiPart implements ISidedHollowConnect { + + int size; + int side; + + @Override + public String getType() { + return "test:hollow_connector"; + } + + @Override + public int getHollowSize(int side) { + this.side = side; + return size; + } + } + + private static final class SlotTile extends TileMultipart { + + final Connector connector = new Connector(); + boolean connected = true; + + @Override + public TMultiPart partMap(int slot) { + return slot == 6 && connected ? connector : null; + } + } + + /** Uses client helpers with real Forge factories; the dedicated server strips client factory creation. */ + private static final class ClientProbe extends Microblock implements HollowMicroblockClient { + + Cuboid6 bounds; + int mask; + + ClientProbe(int material) { + super(material); + HollowMicroblockClient$class.$init$(this); + } + + @Override + public HollowMicroClass$ microClass() { + return HollowMicroClass$.MODULE$; + } + + @Override + public int itemClassID() { + return microClass().getClassId(); + } + + @Override + public int redstoneConductionMap() { + return HollowMicroblock$class.redstoneConductionMap(this); + } + + @Override + public int getSlotMask() { + return 1 << getSlot(); + } + + @Override + public boolean edgeCornerOcclusionTest(codechicken.microblock.TMicroOcclusion edge, + codechicken.microblock.TMicroOcclusion corner) { + return codechicken.microblock.TMicroOcclusion$class.edgeCornerOcclusionTest(this, edge, corner); + } + + @Override + public List getCollisionBoxes() { + return HollowMicroblock$class.getCollisionBoxes(this); + } + + @Override + public List getSubParts() { + return HollowMicroblock$class.getSubParts(this); + } + + @Override + public Cuboid6 getBounds() { + return HollowMicroblock$class.getBounds(this); + } + + @Override + public int getSlot() { + return getShape(); + } + + @Override + public int getHollowSize() { + return HollowMicroblock$class.getHollowSize(this); + } + + @Override + public List getPartialOcclusionBoxes() { + return HollowMicroblock$class.getPartialOcclusionBoxes(this); + } + + @Override + public Iterable getOcclusionBoxes() { + return HollowMicroblock$class.getOcclusionBoxes(this); + } + + @Override + public boolean allowCompleteOcclusion() { + return true; + } + + @Override + public boolean solid(int side) { + return false; + } + + @Override + public Cuboid6 renderBounds() { + return bounds; + } + + @Override + public void renderBounds_$eq(Cuboid6 value) { + bounds = value; + } + + @Override + public int renderMask() { + return mask; + } + + @Override + public void renderMask_$eq(int value) { + mask = value; + } + + @Override + public int getPriorityClass() { + return 0; + } + + @Override + public IIcon getBrokenIcon(int side) { + throw new AssertionError("icon lookup"); + } + + @Override + public void recalcBounds() { + HollowMicroblockClient$class.recalcBounds(this); + } + + @Override + public void render(Vector3 pos, int pass) { + HollowMicroblockClient$class.render(this, pos, pass); + } + + @Override + public void renderHollow(Vector3 pos, int pass, Cuboid6 c, int sideMask, boolean face, + Function5 f) { + HollowMicroblockClient$class.renderHollow(this, pos, pass, c, sideMask, face, f); + } + + public void codechicken$microblock$HollowMicroblockClient$$super$recalcBounds() { + TMicroOcclusionClient$class.recalcBounds(this); + } + + public boolean codechicken$microblock$HollowMicroblock$$super$occlusionTest(TMultiPart other) { + return super.occlusionTest(other); + } + + public boolean codechicken$microblock$TMicroOcclusion$$super$occlusionTest(TMultiPart other) { + return super.occlusionTest(other); + } + + public void codechicken$microblock$TMicroOcclusionClient$$super$onAdded() { + super.onAdded(); + } + + public void codechicken$microblock$TMicroOcclusionClient$$super$onPartChanged(TMultiPart other) { + super.onPartChanged(other); + } + + public void codechicken$microblock$TMicroOcclusionClient$$super$read(MCDataInput packet) { + super.read(packet); + } + } +} diff --git a/src/test/fixtures/README.md b/src/test/fixtures/README.md index 1b71894..09c48ab 100644 --- a/src/test/fixtures/README.md +++ b/src/test/fixtures/README.md @@ -265,3 +265,21 @@ Compiled with Scala 2.11.5 under Java 8, `-target:jvm-1.8`, against the untouche | --- | --- | | `ReferenceHollowMicroblockBase` | `a329f86030d4706ba07a478d36a2fe9fd6b4e2bcaac76bd92e128769cd91110e` | | `ReferenceScalaHollowMicroblock` | `3df6e92864c984ad973a115c56495deee8fb8a8c4014dbd34786a2caf754c7f6` | + +### `ReferenceScalaHollowMicroblockClient` + +`scala/codechicken/multipart/compat/ReferenceScalaHollowMicroblockClient.scala` freezes the hollow client +forwarders and a real recalculation predecessor. Tests observe initialization, mask read/super order, render +selection, callback dispatch and snapshots, rim geometry/masks, breaking pipelines and highlight commands. +A child loader redirects only rendering-service calls to record their effects; trait control flow and virtual +part calls remain intact. This tests drawing commands, not actual GPU output. + +Compiled with Scala 2.11.5 under Java 8, `-target:jvm-1.8`, against the untouched dev jar at `940609b` +(SHA-256 `04838fb3e100503437092fa018872d324e1765c267d5f8dc83b9831b73e66593`). Source SHA-256 is +`0dcef588bb0ee808d5ec7fba1716b2d2fd6cc6464e7650d9d29f6400d5673149`. Frozen class files under +`src/test/resources/compat/` have these SHA-256s; do not regenerate against the port: + +| Class | SHA-256 | +| --- | --- | +| `ReferenceHollowClientBase` | `fe39f52cd776ded56adceb27ed011f3f72d405ee363dcb54877717e18de16450` | +| `ReferenceScalaHollowMicroblockClient` | `5b11e01e3995bc314ffa10d129da7277e386edfe08520370e6b3ee40bdd18c67` | diff --git a/src/test/fixtures/scala/codechicken/multipart/compat/ReferenceScalaHollowMicroblockClient.scala b/src/test/fixtures/scala/codechicken/multipart/compat/ReferenceScalaHollowMicroblockClient.scala new file mode 100644 index 0000000..09948e0 --- /dev/null +++ b/src/test/fixtures/scala/codechicken/multipart/compat/ReferenceScalaHollowMicroblockClient.scala @@ -0,0 +1,53 @@ +package codechicken.multipart.compat + +import codechicken.lib.vec.{Cuboid6, Vector3} +import codechicken.microblock.{CommonMicroblockClient, HollowMicroblockClient, Microblock} +import codechicken.microblock.MicroMaterialRegistry.IMicroMaterial + +abstract class ReferenceHollowClientBase extends Microblock(41) with CommonMicroblockClient { + var events: java.util.List[String] = new java.util.ArrayList[String]() + var failSuper = false + var superMask = 0x12345665 + renderMask = 0x123401 + override def recalcBounds() { + events.add("super") + renderMask = superMask + if (failSuper) throw new IllegalStateException("super") + } +} + +/** Frozen client forwarders expose the original trait linearization and render callback dispatch. */ +class ReferenceScalaHollowMicroblockClient extends ReferenceHollowClientBase with HollowMicroblockClient { + var bounds = new Cuboid6(0.1, 0.2, 0.3, 0.9, 0.8, 0.7) + var selectedMaterial: IMicroMaterial = null + var transparent = false + var slot = 0 + var slotAdvance = 0 + var hollowSize = 8 + var changeMaskOnSize = false + var rawShape: Byte = 48 + var shapeAdvance = 0 + var runHollow = false + var afterHollow: Runnable = null + var draws: java.util.List[Array[Object]] = new java.util.ArrayList[Array[Object]]() + override def getBounds = { events.add("bounds"); bounds } + override def getIMaterial = { events.add("material"); selectedMaterial } + override def isTransparent = { events.add("transparent"); transparent } + override def getSlot = { events.add("slot"); val result = slot; slot += slotAdvance; result } + override def getHollowSize = { + events.add("size") + if (changeMaskOnSize) renderMask = 0xdeadbeef + hollowSize + } + override def shape = { events.add("shape"); val result = rawShape; rawShape = (rawShape + shapeAdvance).toByte; result } + override def x = { events.add("x"); 2 } + override def y = { events.add("y"); -3 } + override def z = { events.add("z"); 4 } + override def renderHollow(pos: Vector3, pass: Int, c: Cuboid6, mask: Int, face: Boolean, + f: (Vector3, IMicroMaterial, Int, Cuboid6, Int) => Unit) { + events.add("hollow") + draws.add(Array[Object](pos, Int.box(pass), c, Int.box(mask), Boolean.box(face), f)) + if (afterHollow != null) afterHollow.run() + if (runHollow) super.renderHollow(pos, pass, c, mask, face, f) + } +} diff --git a/src/test/java/codechicken/microblock/HollowMicroblockClientCharacterizationTest.java b/src/test/java/codechicken/microblock/HollowMicroblockClientCharacterizationTest.java new file mode 100644 index 0000000..0e67ae8 --- /dev/null +++ b/src/test/java/codechicken/microblock/HollowMicroblockClientCharacterizationTest.java @@ -0,0 +1,538 @@ +package codechicken.microblock; + +import static org.junit.jupiter.api.Assertions.*; +import static org.objectweb.asm.Opcodes.*; + +import java.io.InputStream; +import java.lang.reflect.Proxy; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Collections; +import java.util.List; +import java.util.Scanner; + +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.entity.Entity; +import net.minecraft.util.IIcon; + +import org.junit.jupiter.api.Test; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Type; + +import codechicken.lib.render.CCRenderState; +import codechicken.lib.render.CCRenderState.IVertexOperation; +import codechicken.lib.render.uv.IconTransformation; +import codechicken.lib.vec.Cuboid6; +import codechicken.lib.vec.Rotation; +import codechicken.lib.vec.Transformation; +import codechicken.lib.vec.Translation; +import codechicken.lib.vec.Vector3; +import codechicken.microblock.MicroMaterialRegistry.IMicroMaterial; +import scala.Function5; +import scala.MatchError; +import scala.runtime.AbstractFunction5; +import scala.runtime.BoxedUnit; + +/** Executes original frozen forwarders, replacing only GPU-facing services with a call recorder. */ +public class HollowMicroblockClientCharacterizationTest { + + @Test + void initializationOrsTheDefaultOpeningAndRecalculationPreservesSuperLowBits() throws Exception { + Fixture f = new Fixture(); + assertEquals(0x123c01, f.client.renderMask()); + for (int size : new int[] { -1, 0, 8, 11, Integer.MAX_VALUE }) { + f.set("hollowSize", int.class, size); + f.set("changeMaskOnSize", boolean.class, true); + f.events.clear(); + f.client.recalcBounds(); + assertEquals(0x65 | size << 8, f.client.renderMask()); + assertEquals(Arrays.asList("super", "size"), f.events); + } + f.set("failSuper", boolean.class, true); + f.events.clear(); + assertEquals("super", assertThrows(IllegalStateException.class, f.client::recalcBounds).getMessage()); + assertEquals(Collections.singletonList("super"), f.events); + assertEquals(0x12345665, f.client.renderMask()); + } + + @Test + void renderChoosesPhysicalTransparentAndOpaqueCallsWithLiveSlotDispatch() throws Exception { + Fixture f = new Fixture(); + Cuboid6 render = new Cuboid6(0, 0, 0, 0.5, 0.5, 0.5); + f.client.renderBounds_$eq(render); + f.client.renderMask_$eq(0x851); + for (int pass : new int[] { -1, -2, 0, 1 }) { + for (boolean transparent : new boolean[] { false, true }) { + f.set("transparent", boolean.class, transparent); + f.set("slot", int.class, 2); + f.set("slotAdvance", int.class, 1); + f.clear(); + f.client.render(f.pos, pass); + assertEquals(pass == -1 || transparent ? 1 : 2, f.draws.size()); + f.assertDraw( + 0, + pass, + pass == -1 ? f.bounds : render, + pass == -1 ? 0 : transparent ? 0x851 : 0x855, + false); + if (pass == -1) assertEquals(Arrays.asList("bounds", "hollow"), f.events); + else if (transparent) assertEquals(Arrays.asList("transparent", "hollow"), f.events); + else { + f.assertDraw(1, pass, Cuboid6.full, ~(1 << 3), true); + assertEquals(Arrays.asList("transparent", "slot", "hollow", "slot", "hollow"), f.events); + assertNotSame(f.draws.get(0)[5], f.draws.get(1)[5]); + } + } + } + } + + @Test + void renderCallbacksInvokeMaterialDrawingAndFirstFailurePreventsTheSecondCall() throws Exception { + Fixture f = new Fixture(); + List sides = new ArrayList<>(); + IMicroMaterial material = (IMicroMaterial) Proxy.newProxyInstance( + getClass().getClassLoader(), + new Class[] { IMicroMaterial.class }, + (proxy, method, args) -> { + assertEquals("renderMicroFace", method.getName()); + assertSame(f.pos, args[0]); + assertEquals(7, args[1]); + assertSame(f.bounds, args[2]); + sides.add(MicroblockRender.face().get().side); + return null; + }); + for (int pass : new int[] { -1, 0 }) { + for (boolean transparent : new boolean[] { false, true }) { + f.set("transparent", boolean.class, transparent); + f.clear(); + f.client.render(f.pos, pass); + for (Object[] draw : f.draws) { + sides.clear(); + callback(draw).apply(f.pos, material, 7, f.bounds, 0x15); + assertEquals(Arrays.asList(1, 3, 5), sides); + } + } + } + f.set("transparent", boolean.class, false); + f.set("afterHollow", Runnable.class, (Runnable) () -> { throw new IllegalStateException("draw"); }); + f.clear(); + assertEquals("draw", assertThrows(IllegalStateException.class, () -> f.client.render(f.pos, 0)).getMessage()); + assertEquals(1, f.draws.size()); + } + + @Test + void rimCallbacksKeepAllSixOrderedBoundsAndFaceMasksOnEveryAxis() throws Exception { + Fixture f = new Fixture(); + f.set("runHollow", boolean.class, true); + f.client.renderMask_$eq(8 << 8); + // Literal reference geometry at opening size 8, independent of callback implementation. + double[][][] geometry = { + { { .25, .2, .75, .75, .8, .7 }, { .25, .2, .3, .75, .8, .25 }, { .75, .2, .25, .9, .8, .75 }, + { .1, .2, .25, .25, .8, .75 }, { .1, .2, .75, .9, .8, .7 }, { .1, .2, .3, .9, .8, .25 } }, + { { .75, .25, .3, .9, .75, .7 }, { .1, .25, .3, .25, .75, .7 }, { .25, .75, .3, .75, .8, .7 }, + { .25, .2, .3, .75, .25, .7 }, { .75, .2, .3, .9, .8, .7 }, { .1, .2, .3, .25, .8, .7 } }, + { { .1, .75, .25, .9, .8, .75 }, { .1, .2, .25, .9, .25, .75 }, { .1, .25, .75, .9, .75, .7 }, + { .1, .25, .3, .9, .75, .25 }, { .1, .75, .3, .9, .8, .7 }, { .1, .2, .3, .9, .25, .7 } } }; + int[][] masks0 = { { 59, 55, 12, 12, 4, 8 }, { 47, 31, 48, 48, 16, 32 }, { 62, 61, 3, 3, 1, 2 } }; + int[][] masks63 = { { 59, 55, 47, 31, 63, 63 }, { 47, 31, 62, 61, 63, 63 }, { 62, 61, 59, 55, 63, 63 } }; + int[] faceMask = { 60, 51, 15 }; + for (int side = 0; side < 6; side++) { + f.set("slot", int.class, side); + for (boolean face : new boolean[] { false, true }) { + for (int mask : new int[] { 0, 63, -1 }) { + List boxes = new ArrayList<>(); + List masks = new ArrayList<>(); + f.clear(); + f.client.renderHollow(f.pos, 7, f.bounds, mask, face, collect((pos, mat, pass, box, bits) -> { + assertSame(f.pos, pos); + assertNull(mat); + assertEquals(7, pass); + boxes.add(box); + masks.add(bits); + })); + assertEquals(Arrays.asList("hollow", "material", "slot"), f.events); + assertEquals(6, boxes.size()); + for (int i = 0; i < 6; i++) { + assertArrayEquals(geometry[side / 2][i], coords(boxes.get(i)), 0); + assertEquals( + (mask == 0 ? masks0 : masks63)[side / 2][i] | (face ? faceMask[side / 2] : 0), + masks.get(i)); + for (int j = 0; j < i; j++) assertNotSame(boxes.get(i), boxes.get(j)); + } + } + } + } + } + + @Test + void rimRenderingSnapshotsMaterialMaskAndCoordinatesBeforeCallbacksAndPreservesFailures() throws Exception { + Fixture f = new Fixture(); + f.set("runHollow", boolean.class, true); + List boxes = new ArrayList<>(); + for (int size : new int[] { -8, 0, 11, 32 }) { + f.client.renderMask_$eq(size << 8 | 0x55); + boxes.clear(); + f.client.renderHollow(f.pos, 0, Cuboid6.full, 0, false, collect((pos, mat, pass, box, mask) -> { + boxes.add(box); + f.client.renderMask_$eq(0); + f.setUnchecked("slot", int.class, 5); + })); + assertEquals(0.5 - size / 32D, boxes.get(0).min.x); + assertEquals(0.5 + size / 32D, boxes.get(0).max.x); + f.set("slot", int.class, 0); + } + IMicroMaterial material = (IMicroMaterial) Proxy.newProxyInstance( + getClass().getClassLoader(), + new Class[] { IMicroMaterial.class }, + (proxy, method, args) -> { throw new AssertionError("material invoked"); }); + f.set("selectedMaterial", IMicroMaterial.class, material); + f.client.renderMask_$eq(8 << 8); + Cuboid6 mutable = f.bounds.copy(); + boxes.clear(); + f.client.renderHollow(f.pos, 0, mutable, 0, false, collect((pos, mat, pass, box, mask) -> { + assertSame(material, mat); + boxes.add(box); + mutable.max.x = 99; + f.setUnchecked("selectedMaterial", IMicroMaterial.class, null); + })); + assertEquals(.9, boxes.get(5).max.x); + f.clear(); + assertThrows(NullPointerException.class, () -> f.client.renderHollow(null, 0, null, 0, false, null)); + assertEquals(Arrays.asList("hollow", "material"), f.events); + for (int side : new int[] { -1, 6, 32 }) { + f.set("slot", int.class, side); + assertThrows(MatchError.class, () -> f.client.renderHollow(null, 0, f.bounds, 0, false, null)); + } + f.set("slot", int.class, 0); + int[] calls = { 0 }; + assertThrows( + IllegalStateException.class, + () -> f.client.renderHollow(null, 0, f.bounds, 0, false, collect((pos, mat, pass, box, mask) -> { + calls[0]++; + throw new IllegalStateException("callback"); + }))); + assertEquals(1, calls[0]); + } + + @Test + void highlightEmitsOrderedStateChangesTransformAndExpandedOutlines() throws Exception { + Fixture f = new Fixture(); + f.set("rawShape", byte.class, (byte) 32); + f.set("shapeAdvance", int.class, 1); + assertTrue(f.part.drawHighlight(null, null, 0.625F)); + assertEquals( + Arrays.asList( + "size", + "shape", + "enable:3042", + "blend:770:771", + "disable:3553", + "color:0.0:0.0:0.0:0.4", + "line:2.0", + "depth:false", + "push", + "world:0.625", + "x", + "y", + "z", + "translate:2.0:-3.0:4.0", + "shape", + "rotation", + "outline", + "outline", + "pop", + "depth:true", + "enable:3553", + "disable:3042"), + f.events); + assertArrayEquals( + new double[] { -.001, -.001, -.001, 1.001, .251, 1.001 }, + coords(RenderRecorder.outlines.get(0)), + 1e-12); + assertArrayEquals( + new double[] { .251, .001, .251, .749, .249, .749 }, + coords(RenderRecorder.outlines.get(1)), + 1e-12); + Vector3 expected = new Vector3(.2, .3, .4).apply(Rotation.sideRotations[1].at(Vector3.center)); + Vector3 actual = new Vector3(.2, .3, .4).apply(RenderRecorder.rotation); + assertEquals(expected, actual); + } + + @Test + void highlightFailuresStopAtTheOriginalPointWithoutInventingCleanup() throws Exception { + Fixture f = new Fixture(); + f.set("rawShape", byte.class, (byte) 38); + assertThrows(ArrayIndexOutOfBoundsException.class, () -> f.part.drawHighlight(null, null, 0)); + assertEquals("shape", f.events.get(f.events.size() - 1)); + assertFalse(f.events.contains("pop")); + assertTrue(RenderRecorder.outlines.isEmpty()); + f.clear(); + f.set("rawShape", byte.class, (byte) 32); + RenderRecorder.failOutline = true; + assertThrows(IllegalStateException.class, () -> f.part.drawHighlight(null, null, 0)); + assertEquals("outline", f.events.get(f.events.size() - 1)); + assertFalse(f.events.contains("pop")); + } + + @Test + void breakingBuildsTranslationAndIconPipelineAndDispatchesItsCuboidCallback() throws Exception { + Fixture f = new Fixture(); + RenderBlocks render = new RenderBlocks(); + IIcon icon = (IIcon) Proxy.newProxyInstance( + getClass().getClassLoader(), + new Class[] { IIcon.class }, + (proxy, method, args) -> { throw new AssertionError("icon sampled"); }); + render.overrideBlockTexture = icon; + f.part.drawBreaking(render); + assertEquals(Arrays.asList("state", "reset", "x", "y", "z", "pipeline", "bounds", "hollow"), f.events); + assertEquals(2, RenderRecorder.pipeline.length); + Vector3 translated = new Vector3().apply((Translation) RenderRecorder.pipeline[0]); + assertEquals(new Vector3(2, -3, 4), translated); + assertSame(icon, ((IconTransformation) RenderRecorder.pipeline[1]).icon); + Object[] draw = f.draws.get(0); + assertNull(draw[0]); + assertEquals(0, draw[1]); + assertSame(f.bounds, draw[2]); + assertEquals(0, draw[3]); + assertEquals(false, draw[4]); + callback(draw).apply(null, null, 0, f.bounds, 37); + assertSame(f.bounds, RenderRecorder.breakBox); + assertEquals(37, RenderRecorder.breakMask); + f.clear(); + assertThrows(NullPointerException.class, () -> f.part.drawBreaking(null)); + assertEquals(Arrays.asList("state", "reset", "x", "y", "z"), f.events); + } + + private interface Draw { + + void accept(Vector3 pos, IMicroMaterial material, int pass, Cuboid6 box, int mask); + } + + private static Function5 collect(Draw draw) { + return new AbstractFunction5() { + + @Override + public BoxedUnit apply(Vector3 pos, IMicroMaterial material, Object pass, Cuboid6 box, Object mask) { + draw.accept(pos, material, (Integer) pass, box, (Integer) mask); + return BoxedUnit.UNIT; + } + }; + } + + @SuppressWarnings("unchecked") + private static Function5 callback(Object[] draw) { + return (Function5) draw[5]; + } + + private static double[] coords(Cuboid6 c) { + return new double[] { c.min.x, c.min.y, c.min.z, c.max.x, c.max.y, c.max.z }; + } + + private static final class Fixture extends ClassLoader { + + final List events = new ArrayList<>(); + final List draws; + final Microblock part; + final HollowMicroblockClient client; + final Cuboid6 bounds; + final Vector3 pos = new Vector3(2, 3, 4); + + @SuppressWarnings("unchecked") + Fixture() throws Exception { + super(Microblock.class.getClassLoader()); + for (String name : new String[] { "ReferenceHollowClientBase", "ReferenceScalaHollowMicroblockClient" }) { + byte[] bytes; + try (Scanner scanner = new Scanner( + getResourceAsStream("compat/" + name + ".class.b64"), + StandardCharsets.US_ASCII.name()).useDelimiter("\\A")) { + bytes = Base64.getMimeDecoder().decode(scanner.next()); + } + defineClass(null, bytes, 0, bytes.length); + } + part = (Microblock) loadClass("codechicken.multipart.compat.ReferenceScalaHollowMicroblockClient") + .getConstructor().newInstance(); + client = (HollowMicroblockClient) part; + bounds = (Cuboid6) part.getClass().getMethod("bounds").invoke(part); + draws = (List) part.getClass().getMethod("draws").invoke(part); + set("events", List.class, events); + RenderRecorder.events = events; + RenderRecorder.outlines.clear(); + RenderRecorder.failOutline = false; + } + + void set(String name, Class type, Object value) throws Exception { + part.getClass().getMethod(name + "_$eq", type).invoke(part, value); + } + + void setUnchecked(String name, Class type, Object value) { + try { + set(name, type, value); + } catch (Exception ex) { + throw new AssertionError(ex); + } + } + + void clear() { + events.clear(); + draws.clear(); + RenderRecorder.outlines.clear(); + } + + void assertDraw(int index, int pass, Cuboid6 c, int mask, boolean face) { + Object[] draw = draws.get(index); + assertSame(pos, draw[0]); + assertEquals(pass, draw[1]); + assertSame(c, draw[2]); + assertEquals(mask, draw[3]); + assertEquals(face, draw[4]); + } + + @Override + protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException { + if (!name.startsWith("codechicken.microblock.HollowMicroblockClient$") + && !name.startsWith("codechicken.microblock.HollowMicroblockClientLogic")) + return super.loadClass(name, resolve); + Class loaded = findLoadedClass(name); + if (loaded == null) { + try (InputStream input = getResourceAsStream(name.replace('.', '/') + ".class")) { + if (input == null) throw new ClassNotFoundException(name); + ClassReader reader = new ClassReader(input); + ClassWriter writer = new ClassWriter(0); + reader.accept(new ClassVisitor(ASM5, writer) { + + @Override + public MethodVisitor visitMethod(int access, String method, String desc, String sig, + String[] exceptions) { + return new MethodVisitor(ASM5, super.visitMethod(access, method, desc, sig, exceptions)) { + + @Override + public void visitMethodInsn(int opcode, String owner, String method, String descriptor, + boolean itf) { + String target = Type.getInternalName(RenderRecorder.class); + if (owner.equals("org/lwjgl/opengl/GL11") + || owner.equals("codechicken/lib/render/RenderUtils") + || owner.equals("codechicken/lib/render/BlockRenderer")) { + super.visitMethodInsn(opcode, target, method, descriptor, false); + return; + } + if (owner.equals("codechicken/lib/vec/Transformation") + && method.equals("glApply")) { + super.visitMethodInsn( + INVOKESTATIC, + target, + "glApply", + "(Lcodechicken/lib/vec/Transformation;)V", + false); + return; + } + if (owner.equals("codechicken/lib/render/CCRenderState")) { + if (opcode == INVOKEVIRTUAL) + descriptor = "(Lcodechicken/lib/render/CCRenderState;" + + descriptor.substring(1); + super.visitMethodInsn(INVOKESTATIC, target, method, descriptor, false); + return; + } + super.visitMethodInsn(opcode, owner, method, descriptor, itf); + } + }; + } + }, 0); + byte[] bytes = writer.toByteArray(); + loaded = defineClass(name, bytes, 0, bytes.length); + } catch (java.io.IOException ex) { + throw new ClassNotFoundException(name, ex); + } + } + if (resolve) resolveClass(loaded); + return loaded; + } + } + + public static final class RenderRecorder { + + static List events; + static final List outlines = new ArrayList<>(); + static Transformation rotation; + static boolean failOutline; + static IVertexOperation[] pipeline; + static Cuboid6 breakBox; + static int breakMask; + + public static void glEnable(int value) { + events.add("enable:" + value); + } + + public static void glDisable(int value) { + events.add("disable:" + value); + } + + public static void glBlendFunc(int a, int b) { + events.add("blend:" + a + ":" + b); + } + + public static void glColor4f(float a, float b, float c, float d) { + events.add("color:" + a + ":" + b + ":" + c + ":" + d); + } + + public static void glLineWidth(float value) { + events.add("line:" + value); + } + + public static void glDepthMask(boolean value) { + events.add("depth:" + value); + } + + public static void glPushMatrix() { + events.add("push"); + } + + public static void glPopMatrix() { + events.add("pop"); + } + + public static void glTranslated(double x, double y, double z) { + events.add("translate:" + x + ":" + y + ":" + z); + } + + public static void translateToWorldCoords(Entity player, float frame) { + assertNull(player); + events.add("world:" + frame); + } + + public static void glApply(Transformation value) { + events.add("rotation"); + rotation = value; + } + + public static void drawCuboidOutline(Cuboid6 box) { + events.add("outline"); + outlines.add(box); + if (failOutline) throw new IllegalStateException("outline"); + } + + public static CCRenderState instance() { + events.add("state"); + return CCRenderState.instance(); + } + + public static void resetInstance(CCRenderState state) { + events.add("reset"); + } + + public static void setPipelineInstance(CCRenderState state, IVertexOperation[] operations) { + events.add("pipeline"); + pipeline = operations; + } + + public static void renderCuboid(Cuboid6 box, int mask) { + events.add("break"); + breakBox = box; + breakMask = mask; + } + } +} diff --git a/src/test/resources/compat/ReferenceHollowClientBase.class.b64 b/src/test/resources/compat/ReferenceHollowClientBase.class.b64 new file mode 100644 index 0000000..4be5afa --- /dev/null +++ b/src/test/resources/compat/ReferenceHollowClientBase.class.b64 @@ -0,0 +1 @@ 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 diff --git a/src/test/resources/compat/ReferenceScalaHollowMicroblockClient.class.b64 b/src/test/resources/compat/ReferenceScalaHollowMicroblockClient.class.b64 new file mode 100644 index 0000000..6dd9f44 --- /dev/null +++ b/src/test/resources/compat/ReferenceScalaHollowMicroblockClient.class.b64 @@ -0,0 +1 @@ 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