fix more cosmetics rendering bugs 💀

Author: Wyvest

src/main/kotlin/org/polyfrost/polyplus/client/bedrock/model/BedrockEffectBoneTreeBuilder.kt

@@ -16,6 +16,7 @@ internal class BedrockEffectBoneTreeBuilder(
     private val textureHeight = geometry.description.textureHeight
     private val childrenByParent = geometry.childrenByParent()
     private val built = mutableMapOf<String, BedrockBoneRenderer>()
+    private val visiting = mutableSetOf<String>()
 
     val bones: Map<String, BedrockBoneRenderer> get() = built
 
@@ -24,7 +25,11 @@ internal class BedrockEffectBoneTreeBuilder(
 
         val bone = geometry.bones[name] ?: error("Missing bone $name")
         val effectiveLevel = bone.lightLevel.takeIf { it >= 0 } ?: parentLevel
-        val children = (childrenByParent[name] ?: emptyList()).map { buildBone(it, effectiveLevel) }
+        check(visiting.add(name)) { "Cyclic bone parenting detected at $name" }
+        val children = (childrenByParent[name] ?: emptyList())
+            .filter { it != name && it !in visiting }
+            .map { buildBone(it, effectiveLevel) }
+        visiting.remove(name)
         val position = bone.initialEffectPosition(geometry.bones, playerGeometry)
         val rotation = bone.initialEffectRotation()
 

src/main/kotlin/org/polyfrost/polyplus/client/bedrock/render/BedrockMesh.kt

@@ -95,7 +95,7 @@ class BedrockMesh private constructor(
             val modelMaxY = -(minY - pivot.y) + inflate
 
             var modelMinZ = minZ
-            var modelMaxZ = minZ + depth
+            var modelMaxZ = minZ + depth + 2f * inflate
             if (depth < BILLBOARD_EPSILON) {
                 val centerZ = (min(cube.origin.z, endZ) + max(cube.origin.z, endZ)) * 0.5f - pivot.z
                 modelMinZ = centerZ - BILLBOARD_HALF_THICKNESS
@@ -106,7 +106,7 @@ class BedrockMesh private constructor(
                 minX = minX,
                 minY = modelMinY,
                 minZ = modelMinZ,
-                maxX = minX + width,
+                maxX = minX + width + 2f * inflate,
                 maxY = modelMaxY,
                 maxZ = modelMaxZ,
             )
@@ -278,12 +278,12 @@ class BedrockMesh private constructor(
                 if (width >= BILLBOARD_EPSILON && height >= BILLBOARD_EPSILON) {
                     addFace(
                         arrayOf(north1, north0, north3, north2),
-                        u0 + uvDepth, v0 + uvDepth, u0 + uvDepth + uvWidth, v0 + uvDepth + uvHeight,
+                        u1, v1, u2, v2,
                         Direction.NORTH,
                     )
                     addFace(
                         arrayOf(south0, south1, south2, south3),
-                        u0 + uvDepth, v0 + uvDepth, u0 + uvDepth + uvWidth, v0 + uvDepth + uvHeight,
+                        u3, v1, u4, v2,
                         Direction.SOUTH,
                     )
                 }

src/main/kotlin/org/polyfrost/polyplus/client/cosmetics/assets/AttachedCosmeticParser.kt

@@ -81,6 +81,10 @@ internal object AttachedCosmeticParser {
     }
 
     private fun applyAutoMirror(geometry: BedrockGeometry): BedrockGeometry {
+        if (geometry.bones.values.any { bone -> bone.cubes.any { it.mirror } }) {
+            return geometry
+        }
+
         val bones = geometry.bones.values
         val rewritten = geometry.bones.mapValues inner@{ (_, bone) ->
             if (bone.pivot.x <= 0f || bone.cubes.none { it.uv.faces.isEmpty() }) return@inner bone
@@ -150,19 +154,52 @@ internal object AttachedCosmeticParser {
             return geometry
         }
 
-        val boneNames = geometry.bones.keys
-        val renderable = geometry.renderableBoneNames()
-        val rewritten = geometry.bones.mapValues { (name, bone) ->
-            val isTopLevel = bone.parent.isEmpty() || bone.parent !in boneNames
-            if (!isTopLevel || name !in renderable) {
+        val prepared = if (slot == BodySlot.Boots) splitStraddlingLegBones(geometry) else geometry
+
+        val renderable = prepared.renderableBoneNames()
+        val rewritten = prepared.bones.mapValues { (name, bone) ->
+            if (name !in renderable || !isAttachmentRoot(prepared, bone)) {
                 return@mapValues bone
             }
-            val target = attachTargetFor(geometry, slot, bone) ?: return@mapValues bone
+            val target = attachTargetFor(prepared, slot, bone) ?: return@mapValues bone
             bone.copy(parent = target.serializedName)
         }
-        return geometry.copy(bones = rewritten)
+        return prepared.copy(bones = rewritten)
+    }
+
+    private fun isAttachmentRoot(geometry: BedrockGeometry, bone: BedrockBone): Boolean {
+        if (bone.cubes.isEmpty()) return false
+        var parent = geometry.bones[bone.parent]
+        while (parent != null) {
+            if (parent.cubes.isNotEmpty()) return false
+            parent = geometry.bones[parent.parent]
+        }
+        return true
+    }
+
+    private fun splitStraddlingLegBones(geometry: BedrockGeometry): BedrockGeometry {
+        val hasChild = geometry.bones.values.mapTo(hashSetOf()) { it.parent }
+        val renderable = geometry.renderableBoneNames()
+        val result = LinkedHashMap<String, BedrockBone>(geometry.bones.size)
+        for ((name, bone) in geometry.bones) {
+            if (name !in renderable || name in hasChild || bone.cubes.isEmpty()) {
+                result[name] = bone
+                continue
+            }
+            val right = bone.cubes.filter { cubeCenterX(it) < 0f }
+            val left = bone.cubes.filter { cubeCenterX(it) >= 0f }
+            if (right.isEmpty() || left.isEmpty()) {
+                result[name] = bone
+                continue
+            }
+            result["${name}_r"] = bone.copy(name = "${name}_r", cubes = right)
+            result["${name}_l"] = bone.copy(name = "${name}_l", cubes = left)
+        }
+        return geometry.copy(bones = result)
     }
 
+    private fun cubeCenterX(cube: BedrockCube): Float = cube.origin.x + cube.size.x * 0.5f
+
     private fun attachTargetFor(geometry: BedrockGeometry, slot: BodySlot, bone: BedrockBone): PlayerModelBone? {
         if (slot == BodySlot.Boots) {
             legForBone(geometry, bone)?.let { return it }

src/main/kotlin/org/polyfrost/polyplus/client/gui/PolyPlusCosmeticsScreen.kt

@@ -817,9 +817,12 @@ private fun PreviewPanel(
             .border(1.dp, LocalTheme.current.borderColor, RoundedCornerShape(12.dp)),
     ) {
         Box(modifier = Modifier.weight(1f).fillMaxHeight()) {
+            val hasHeadCosmetic = CosmeticCatalog.localEquipped().equipped
+                .containsKey(org.polyfrost.polyplus.client.network.http.responses.BodySlot.Hat)
             PlayerPreview(
                 Modifier.align(Alignment.Center).size(190.dp, 330.dp),
                 source = PlayerPreviewSource.LocalLive,
+                verticalAnchor = if (hasHeadCosmetic) 0.64f else 0.5f,
             )
             if (selected != null) {
                 Column(Modifier.align(Alignment.TopStart).padding(18.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
@@ -1275,7 +1278,7 @@ private fun CosmeticThumbnail(item: CosmeticUiItem, modifier: Modifier) {
                 source = source,
                 allowDrag = false,
                 modelScale = 0.42f,
-                verticalAnchor = 0.52f,
+                verticalAnchor = if (item.type == CosmeticType.Hat) 0.64f else 0.52f,
                 previewKey = "card-${item.groupId}",
             )
         }
@@ -1344,9 +1347,13 @@ private fun BundlePreviewPanel(
             .background(cardBrush())
             .border(1.dp, LocalTheme.current.borderColor, RoundedCornerShape(12.dp)),
     ) {
+        val bundleSource = rememberBundlePreviewSource(bundleView)
+        val bundleHasHat = (bundleSource as? PlayerPreviewSource.Override)
+            ?.equipment?.get(org.polyfrost.polyplus.client.network.http.responses.BodySlot.Hat) != null
         PlayerPreview(
             Modifier.align(Alignment.Center).size(190.dp, 300.dp),
-            source = rememberBundlePreviewSource(bundleView),
+            source = bundleSource,
+            verticalAnchor = if (bundleHasHat) 0.64f else 0.5f,
         )
     }
 }

src/main/kotlin/org/polyfrost/polyplus/client/gui/PolyPlusMainMenuScreen.kt

@@ -121,6 +121,18 @@ class PolyPlusMainMenuScreen : ComposeScreen(RenderMode.CONTINUOUS) {
     }
     //?}
 
+    //? if <26.1 {
+    /*override fun renderBackground(ctx: net.minecraft.client.gui.GuiGraphics, mouseX: Int, mouseY: Int, tickDelta: Float) {
+        if (mainMenuPanoramaEnabled()) return
+        super.renderBackground(ctx, mouseX, mouseY, tickDelta)
+    }
+    *///?} else {
+    override fun extractBackground(ctx: net.minecraft.client.gui.GuiGraphicsExtractor, mouseX: Int, mouseY: Int, tickDelta: Float) {
+        if (mainMenuPanoramaEnabled()) return
+        super.extractBackground(ctx, mouseX, mouseY, tickDelta)
+    }
+    //?}
+
     @Composable
     override fun compose() {
         val mc = net.minecraft.client.Minecraft.getInstance()

src/main/kotlin/org/polyfrost/polyplus/client/gui/preview/PlayerPreviewRenderer.kt

@@ -183,6 +183,17 @@ object PlayerPreviewRenderer {
         return cols
     }
 
+    private fun topFadeRows(h: Int): FloatArray {
+        val rows = FloatArray(h)
+        val fadePx = h * EDGE_FADE_FRACTION
+        for (r in 0 until h) {
+            val d = r + 0.5f // distance from top edge (pixel center)
+            val t = if (fadePx <= 0f) 1f else (d / fadePx).coerceIn(0f, 1f)
+            rows[r] = t * t * t * (t * (t * 6f - 15f) + 10f)
+        }
+        return rows
+    }
+
     private fun scaleByte(v: Int, f: Float): Byte {
         val s = (v * f).toInt()
         return (if (s > 255) 255 else s).toByte()
@@ -542,13 +553,16 @@ object PlayerPreviewRenderer {
     private fun toImageBitmap(data: java.nio.ByteBuffer, w: Int, h: Int, pixelSize: Int): ImageBitmap {
         val out = ByteArray(w * h * 4)
         val fade = edgeFadeColumns(w)
+        val rowFade = topFadeRows(h)
         for (y in 0 until h) {
-            val dstRow = (h - 1 - y) * w
+            val outRow = h - 1 - y
+            val dstRow = outRow * w
             val srcRow = y * w
+            val rf = rowFade[outRow]
             for (x in 0 until w) {
                 val si = (srcRow + x) * pixelSize
                 val di = (dstRow + x) * 4
-                val f = fade[x]
+                val f = fade[x] * rf
                 out[di] = scaleByte(data.get(si + 2).toInt() and 0xFF, f)
                 out[di + 1] = scaleByte(data.get(si + 1).toInt() and 0xFF, f)
                 out[di + 2] = scaleByte(data.get(si).toInt() and 0xFF, f)
@@ -895,8 +909,11 @@ object PlayerPreviewRenderer {
         try {
             val out = ByteArray(w * h * 4)
             val fade = edgeFadeColumns(w)
+            val rowFade = topFadeRows(h)
             for (y in 0 until h) {
-                val dstRow = (h - 1 - y) * w
+                val outRow = h - 1 - y
+                val dstRow = outRow * w
+                val rf = rowFade[outRow]
                 for (x in 0 until w) {
                     //? if >= 1.21.4 {
                     val px = img.getPixel(x, y)
@@ -905,7 +922,7 @@ object PlayerPreviewRenderer {
                     /*val px = img.getPixelRGBA(x, y)
                     *///?}
                     val di = (dstRow + x) * 4
-                    val f = fade[x]
+                    val f = fade[x] * rf
                     out[di] = scaleByte((px ushr 16) and 0xFF, f)
                     out[di + 1] = scaleByte((px ushr 8) and 0xFF, f)
                     out[di + 2] = scaleByte(px and 0xFF, f)