Beta 2

Optimised cloak texture size

gradle.properties

@@ -6,7 +6,7 @@ yarn_mappings=1.21.4+build.7
 loader_version=0.16.10
 fabric_version=0.114.0+1.21.4
 
-mod_version = 0.0.5-beta1
+mod_version = 0.0.5-beta2
 maven_group = org.saturnclient
 archives_base_name = saturnclient
 

src/main/java/org/saturnclient/saturnclient/cosmetics/CloakFeatureRenderer.java

@@ -13,10 +13,6 @@ import net.minecraft.client.render.entity.equipment.EquipmentModelLoader;
 import net.minecraft.client.render.entity.equipment.EquipmentModel.LayerType;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
-import net.minecraft.client.render.entity.model.BipedEntityModel;
-import net.minecraft.client.render.entity.model.EntityModelLayers;
-import net.minecraft.client.render.entity.model.LoadedEntityModels;
-import net.minecraft.client.render.entity.model.PlayerCapeModel;
 import net.minecraft.client.render.entity.model.PlayerEntityModel;
 import net.minecraft.client.render.entity.state.PlayerEntityRenderState;
 import net.minecraft.client.util.math.MatrixStack;
@@ -29,18 +25,58 @@ import net.minecraft.util.Identifier;
 import net.minecraft.util.math.RotationAxis;
 import net.minecraft.util.math.Vec3d;
 
+/**
+ * The cloak renderer
+ * - **Efficient**: uses a image only consisting of the cloak texture, 16x8
+ * whitespace.
+ * - **Curving**: Curves when player velocity increases.
+ * - **Wavey**: Makes the cloak feel like wind, when jump sprinting.
+ */
 public class CloakFeatureRenderer extends FeatureRenderer<PlayerEntityRenderState, PlayerEntityModel> {
     private final EquipmentModelLoader equipmentModelLoader;
-    private final BipedEntityModel<PlayerEntityRenderState> model;
     private static final int PARTS = 16;
     private float currentVelocity = 0.0f;
 
+    private static final float TEX_W = 176f;
+    private static final float TEX_H = 138f;
+
+    private static final class PxRect {
+        final int x, y, w, h;
+
+        PxRect(int x, int y, int w, int h) {
+            this.x = x;
+            this.y = y;
+            this.w = w;
+            this.h = h;
+        }
+
+        float u1() {
+            return x / TEX_W;
+        }
+
+        float v1() {
+            return y / TEX_H;
+        }
+
+        float u2() {
+            return (x + w) / TEX_W;
+        }
+
+        float v2() {
+            return (y + h) / TEX_H;
+        }
+    }
+
+    private static final PxRect FRONT_RECT = new PxRect(8, 8, 80, 128);
+    private static final PxRect BACK_RECT = new PxRect(96, 8, 80, 128);
+    private static final PxRect LEFT_EDGE_RECT = new PxRect(0, 8, 8, 128);
+    private static final PxRect RIGHT_EDGE_RECT = new PxRect(88, 8, 8, 128);
+    private static final PxRect TOP_RECT = new PxRect(8, 0, 80, 8);
+    private static final PxRect BOTTOM_RECT = new PxRect(88, 0, 80, 8);
+
     public CloakFeatureRenderer(FeatureRendererContext<PlayerEntityRenderState, PlayerEntityModel> context,
-            LoadedEntityModels modelLoader,
             EquipmentModelLoader equipmentModelLoader) {
         super(context);
-        this.model = new PlayerCapeModel<PlayerEntityRenderState>(
-                modelLoader.getModelPart(EntityModelLayers.PLAYER_CAPE));
         this.equipmentModelLoader = equipmentModelLoader;
     }
 
@@ -63,97 +99,65 @@ public class CloakFeatureRenderer extends FeatureRenderer<PlayerEntityRenderStat
         MatrixStack.Entry entry = matrixStack.peek();
 
         if (!flipWinding) {
-            // Counter-clockwise winding (front face)
-            // Vertex 1 (bottom-left)
-            vertexConsumer
-                    .vertex(entry.getPositionMatrix(), (float) bottomLeft.x, (float) bottomLeft.y,
+            // CCW
+            vertexConsumer.vertex(entry.getPositionMatrix(), (float) bottomLeft.x, (float) bottomLeft.y,
                     (float) bottomLeft.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u1, v2)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u1, v2).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 2 (bottom-right)
-            vertexConsumer
-                    .vertex(entry.getPositionMatrix(), (float) bottomRight.x, (float) bottomRight.y,
+            vertexConsumer.vertex(entry.getPositionMatrix(), (float) bottomRight.x, (float) bottomRight.y,
                     (float) bottomRight.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u2, v2)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u2, v2).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 3 (top-right)
             vertexConsumer.vertex(entry.getPositionMatrix(), (float) topRight.x, (float) topRight.y,
                     (float) topRight.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u2, v1)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u2, v1).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 4 (top-left)
             vertexConsumer.vertex(entry.getPositionMatrix(), (float) topLeft.x, (float) topLeft.y,
                     (float) topLeft.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u1, v1)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u1, v1).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
         } else {
-            // Clockwise winding (back face) - reverse vertex order
-            // Vertex 4 (top-left)
+            // CW
             vertexConsumer.vertex(entry.getPositionMatrix(), (float) topLeft.x, (float) topLeft.y,
                     (float) topLeft.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u1, v1)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u1, v1).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 3 (top-right)
             vertexConsumer.vertex(entry.getPositionMatrix(), (float) topRight.x, (float) topRight.y,
                     (float) topRight.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u2, v1)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u2, v1).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 2 (bottom-right)
-            vertexConsumer
-                    .vertex(entry.getPositionMatrix(), (float) bottomRight.x, (float) bottomRight.y,
+            vertexConsumer.vertex(entry.getPositionMatrix(), (float) bottomRight.x, (float) bottomRight.y,
                     (float) bottomRight.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u2, v2)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u2, v2).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
-
-            // Vertex 1 (bottom-left)
-            vertexConsumer
-                    .vertex(entry.getPositionMatrix(), (float) bottomLeft.x, (float) bottomLeft.y,
+            vertexConsumer.vertex(entry.getPositionMatrix(), (float) bottomLeft.x, (float) bottomLeft.y,
                     (float) bottomLeft.z)
-                    .color(255, 255, 255, 255)
-                    .texture(u1, v2)
-                    .overlay(overlay)
-                    .light(light)
+                    .color(255, 255, 255, 255).texture(u1, v2).overlay(overlay).light(light)
                     .normal(normalX, normalY, normalZ);
         }
     }
 
+    private float getCurve(int i, float curveMagnitude, PlayerEntityRenderState playerState) {
+        float powCurve = (float) Math.pow((double) (PARTS - i) / PARTS, 2) * curveMagnitude;
+        float waveFreq = 0.6f;
+        float phase = (playerState.age + playerState.handSwingProgress) * 0.4f;
+        float sineAmplitude = 0.02f;
+        float sineCurve = (float) Math.sin(i * waveFreq + phase) * sineAmplitude;
+        float t = Math.min(1.0f, Math.max(0.0f, (curveMagnitude - 0.3f) / 0.2f));
+        t = t * t * (3 - 2 * t);
+        return (1.0f - t) * powCurve + t * (powCurve + sineCurve);
+    }
+
     private void renderCape(MatrixStack matrixStack, VertexConsumer vertexConsumer,
-            PlayerEntityRenderState playerState, int light, int overlay, float rotation,
-            float curveMagnitude) {
-        float capeWidth = 10.0f / 16.0f; // 10 pixels wide
-        float capeHeight = 16.0f / 16.0f; // 16 pixels tall
-        float capeDepth = 1.0f / 16.0f; // 1 pixel deep
+            PlayerEntityRenderState playerState, int light, int overlay,
+            float rotation, float curveMagnitude) {
+        float capeWidth = 10.0f / 16.0f;
+        float capeHeight = 16.0f / 16.0f;
+        float capeDepth = 1.0f / 16.0f;
         float capePartHeight = capeHeight / PARTS;
 
         matrixStack.push();
         matrixStack.translate(0.0f, 1.25, 0.125f);
-
         matrixStack.translate(0, -capeHeight, 0);
         matrixStack.multiply(RotationAxis.POSITIVE_X.rotationDegrees(rotation));
         matrixStack.translate(0, capeHeight, 0);
@@ -164,101 +168,112 @@ public class CloakFeatureRenderer extends FeatureRenderer<PlayerEntityRenderStat
         float z1 = 0.0f;
         float z2 = capeDepth;
 
-        float frontU1 = 1.0f / 64.0f; // Start at pixel 1
-        float frontU2 = 11.0f / 64.0f; // End at pixel 11 (10 pixels wide)
-        float frontV1 = 1.0f / 32.0f; // Start at pixel 1
-        float frontV2 = 17.0f / 32.0f; // End at pixel 17 (16 pixels tall)
+        final float frontU1 = FRONT_RECT.u1();
+        final float frontU2 = FRONT_RECT.u2();
+        final float frontV1 = FRONT_RECT.v1();
+        final float frontV2 = FRONT_RECT.v2();
+        final float frontPartV = (frontV2 - frontV1) / PARTS;
 
-        // Back face UV (inside of cape) - typically offset in cape texture
-        float backU1 = 12.0f / 64.0f; // Back texture starts after front
-        float backU2 = 22.0f / 64.0f; // 10 pixels wide
-        float backV2 = 17.0f / 32.0f;
+        final float backU1 = BACK_RECT.u1();
+        final float backU2 = BACK_RECT.u2();
+        final float backV1 = BACK_RECT.v1();
+        final float backV2 = BACK_RECT.v2();
+        final float backPartV = (backV2 - backV1) / PARTS;
 
-        // Top face UV (edge along shoulders)
-        float topU1 = 1.0f / 64.0f; // Start at pixel 1
-        float topU2 = 11.0f / 64.0f; // End at pixel 11
-        float topV1 = 0.0f / 32.0f; // Start at pixel 0
-        float topV2 = 1.0f / 32.0f; // End at pixel 1
+        final float leftU1 = LEFT_EDGE_RECT.u1();
+        final float leftU2 = LEFT_EDGE_RECT.u2();
+        final float leftV1 = LEFT_EDGE_RECT.v1();
+        final float leftV2 = LEFT_EDGE_RECT.v2();
+        final float leftPartV = (leftV2 - leftV1) / PARTS;
 
-        // Bottom face UV (lower edge of cape)
-        float bottomU1 = 11.0f / 64.0f; // Start at pixel 11
-        float bottomU2 = 22.0f / 64.0f; // End at pixel 22
-        float bottomV1 = 0.0f / 32.0f; // Start at pixel 0
-        float bottomV2 = 1.0f / 32.0f; // End at pixel 1
+        final float rightU1 = RIGHT_EDGE_RECT.u1();
+        final float rightU2 = RIGHT_EDGE_RECT.u2();
+        final float rightV1 = RIGHT_EDGE_RECT.v1();
+        final float rightV2 = RIGHT_EDGE_RECT.v2();
+        final float rightPartV = (rightV2 - rightV1) / PARTS;
+
+        final float topU1 = TOP_RECT.u1();
+        final float topU2 = TOP_RECT.u2();
+        final float topV1 = TOP_RECT.v1();
+        final float topV2 = TOP_RECT.v2();
+
+        final float bottomU1 = BOTTOM_RECT.u1();
+        final float bottomU2 = BOTTOM_RECT.u2();
+        final float bottomV1 = BOTTOM_RECT.v1();
+        final float bottomV2 = BOTTOM_RECT.v2();
 
         for (int i = 0; i < PARTS; i++) {
             float y3 = -(capePartHeight * i);
             float y4 = -(capePartHeight * (i + 1));
-            float totalVHeight = frontV2 - frontV1;
-            float partVHeight = totalVHeight / PARTS;
 
-            float curveOffsetTop = (float) Math.pow((double) (PARTS - i) / PARTS, 2) * curveMagnitude;
-            float curveOffsetBottom = (float) Math.pow((double) (PARTS - i - 1) / PARTS, 2)
-                    * curveMagnitude;
+            float curveOffsetTop = getCurve(i, curveMagnitude, playerState);
+            float curveOffsetBottom = getCurve(i + 1, curveMagnitude, playerState);
 
-            // FRONT FACE
-            this.renderCapeQuad(vertexConsumer, matrixStack,
-                    new Vec3d(x2, y4, z2 + curveOffsetBottom), new Vec3d(x1, y4, z2 +
-                            curveOffsetBottom),
-                    new Vec3d(x1, y3, z2 + curveOffsetTop), new Vec3d(x2, y3, z2 +
-                            curveOffsetTop),
-                    frontU1, frontV2 - (partVHeight * i), frontU2, frontV2 - (partVHeight * (i +
-                            1)),
+            // FRONT FACE (outside)
+            this.renderCapeQuad(
+                    vertexConsumer, matrixStack,
+                    new Vec3d(x2, y4, z2 + curveOffsetBottom),
+                    new Vec3d(x1, y4, z2 + curveOffsetBottom),
+                    new Vec3d(x1, y3, z2 + curveOffsetTop), new Vec3d(x2, y3, z2 + curveOffsetTop),
+                    frontU1, frontV2 - (frontPartV * i),
+                    frontU2, frontV2 - (frontPartV * (i + 1)),
                     light, overlay,
                     0.0f, 0.0f, 1.0f, false);
 
-            // BACK FACE
-            this.renderCapeQuad(vertexConsumer, matrixStack,
+            // BACK FACE (inside)
+            this.renderCapeQuad(
+                    vertexConsumer, matrixStack,
                     new Vec3d(x1, y4, z1 + curveOffsetBottom),
                     new Vec3d(x2, y4, z1 + curveOffsetBottom),
                     new Vec3d(x2, y3, z1 + curveOffsetTop), new Vec3d(x1, y3, z1 + curveOffsetTop),
-                    backU1, backV2 - (partVHeight * i), backU2, backV2 - (partVHeight * (i + 1)),
+                    backU1, backV2 - (backPartV * i),
+                    backU2, backV2 - (backPartV * (i + 1)),
                     light, overlay,
                     0.0f, 0.0f, 1.0f, false);
 
-            // LEFT FACE
-            this.renderCapeQuad(vertexConsumer, matrixStack,
+            // LEFT FACE (thickness at x2)
+            this.renderCapeQuad(
+                    vertexConsumer, matrixStack,
                     new Vec3d(x2, y4, z1 + curveOffsetBottom),
                     new Vec3d(x2, y4, z2 + curveOffsetBottom),
                     new Vec3d(x2, y3, z2 + curveOffsetTop), new Vec3d(x2, y3, z1 + curveOffsetTop),
-                    0.0f, frontV2 - (partVHeight * i), 1.0f / 64.0f,
-                    frontV2 - (partVHeight * (i + 1)),
+                    leftU1, leftV2 - (leftPartV * i),
+                    leftU2, leftV2 - (leftPartV * (i + 1)),
                     light, overlay,
                     1.0f, 0.0f, 0.0f, false);
 
-            // RIGHT FACE
-            this.renderCapeQuad(vertexConsumer, matrixStack,
+            // RIGHT FACE (thickness at x1)
+            this.renderCapeQuad(
+                    vertexConsumer, matrixStack,
                     new Vec3d(x1, y4, z2 + curveOffsetBottom),
                     new Vec3d(x1, y4, z1 + curveOffsetBottom),
                     new Vec3d(x1, y3, z1 + curveOffsetTop), new Vec3d(x1, y3, z2 + curveOffsetTop),
-                    frontU2, frontV2 - (partVHeight * i), frontU2 + 1.0f / 64.0f,
-                    frontV2 - (partVHeight * (i + 1)),
+                    rightU1, rightV2 - (rightPartV * i),
+                    rightU2, rightV2 - (rightPartV * (i + 1)),
                     light, overlay,
                     -1.0f, 0.0f, 0.0f, false);
         }
 
-        // TOP FACE
+        // TOP FACE (shoulders edge) – use its dedicated strip
         matrixStack.push();
         matrixStack.translate(0.0f, y2 + capeDepth, 0.0f);
         matrixStack.multiply(net.minecraft.util.math.RotationAxis.POSITIVE_X.rotationDegrees(90.0f));
         matrixStack.translate(0.0f, -y2, 0.0f);
-        this.renderCapeQuad(vertexConsumer, matrixStack,
+        this.renderCapeQuad(
+                vertexConsumer, matrixStack,
                 new Vec3d(x2, y2 + capeDepth, z2), new Vec3d(x1, y2 + capeDepth, z2),
-                new Vec3d(x1, y2, z2),
-                new Vec3d(x2, y2, z2),
+                new Vec3d(x1, y2, z2), new Vec3d(x2, y2, z2),
                 topU1, topV1, topU2, topV2,
                 light, overlay,
                 0.0f, 1.0f, 0.0f, true);
         matrixStack.pop();
 
-        // BOTTOM FACE
-        float curveOffsetTop = (float) Math.pow(1.0f, 2) * curveMagnitude;
-        float curveOffsetBottom = (float) Math.pow(1.0f, 2) * curveMagnitude;
-
-        this.renderCapeQuad(vertexConsumer, matrixStack,
-                new Vec3d(x2, 0.0f, z2 + curveOffsetBottom),
-                new Vec3d(x1, 0.0f, z2 + curveOffsetBottom),
-                new Vec3d(x1, 0.0f, z1 + curveOffsetTop), new Vec3d(x2, 0.0f, z1 + curveOffsetTop),
+        // BOTTOM FACE – use bottom strip
+        float curveOffset = getCurve(0, curveMagnitude, playerState);
+        this.renderCapeQuad(
+                vertexConsumer, matrixStack,
+                new Vec3d(x2, 0.0f, z2 + curveOffset), new Vec3d(x1, 0.0f, z2 + curveOffset),
+                new Vec3d(x1, 0.0f, z1 + curveOffset), new Vec3d(x2, 0.0f, z1 + curveOffset),
                 bottomU1, bottomV1, bottomU2, bottomV2,
                 light, overlay,
                 0.0f, 0.0f, 1.0f, false);
@@ -282,9 +297,7 @@ public class CloakFeatureRenderer extends FeatureRenderer<PlayerEntityRenderStat
         }
 
         Identifier customCape = Cloaks.getCurrentCloakTexture(uuid);
-        if (customCape == null
-                || this.hasCustomModelForLayer(
-                        playerEntityRenderState.equippedChestStack,
+        if (customCape == null || this.hasCustomModelForLayer(playerEntityRenderState.equippedChestStack,
                 LayerType.WINGS)) {
             return;
         }
@@ -297,44 +310,44 @@ public class CloakFeatureRenderer extends FeatureRenderer<PlayerEntityRenderStat
         light = (skyLight << 20) | (blockLight << 4);
 
         matrixStack.push();
-
         VertexConsumer vertexConsumer = vertexConsumerProvider
                 .getBuffer(RenderLayer.getEntityAlpha(customCape));
 
-        if (SaturnClientConfig.bendyCloaks.value) {
-            float targetVelocity = ((6.0F
-                    + playerEntityRenderState.field_53537 / 2.0F
+        float targetVelocity = ((6.0F + playerEntityRenderState.field_53537 / 2.0F
                 + playerEntityRenderState.field_53536) * 0.02f);
         targetVelocity = Math.max(0.0f, targetVelocity - 0.1f);
 
         float accelerationRate = 0.02f;
         this.currentVelocity = this.currentVelocity
-                    + (targetVelocity - this.currentVelocity)
-                            * accelerationRate;
+                + (targetVelocity - this.currentVelocity) * accelerationRate;
 
         float rotation = this.currentVelocity * 72.0f;
         float curve = this.currentVelocity * 0.4f;
 
-            matrixStack.translate(0.0f, -0.25f, 0.0f);
-            if (this.hasCustomModelForLayer(
-                    playerEntityRenderState.equippedChestStack,
-                    LayerType.HUMANOID)) {
-                matrixStack.translate(0.0F, -0.053125F, 0.06875F);
+        if (playerEntityRenderState.sneaking && playerEntityRenderState.isInSneakingPose) {
+            matrixStack.translate(0, 0.24f, 0);
+            matrixStack.multiply(RotationAxis.POSITIVE_X.rotationDegrees(27.0f));
+            curve += 0.2f;
         }
 
-            renderCape(matrixStack, vertexConsumer, playerEntityRenderState, light,
-                    OverlayTexture.DEFAULT_UV,
-                    Math.min(rotation, 60.0f), Math.min(curve, 0.5f));
-        } else {
+        matrixStack.translate(0.0f, -0.25f, 0.0f);
         if (this.hasCustomModelForLayer(playerEntityRenderState.equippedChestStack,
                 LayerType.HUMANOID)) {
             matrixStack.translate(0.0F, -0.053125F, 0.06875F);
         }
-            ((PlayerEntityModel) this.getContextModel()).copyTransforms(this.model);
-            this.model.setAngles(playerEntityRenderState);
-            this.model.render(matrixStack, vertexConsumer, light, OverlayTexture.DEFAULT_UV);
+
+        if (playerEntityRenderState.isSwimming) {
+            curve = 0.0f;
+            rotation = 0.0f;
         }
 
+        if (!SaturnClientConfig.bendyCloaks.value) {
+            curve = 0.0f;
+        }
+
+        renderCape(matrixStack, vertexConsumer, playerEntityRenderState, light,
+                OverlayTexture.DEFAULT_UV, Math.min(rotation, 60.0f), Math.min(curve, 0.5f));
+
         matrixStack.pop();
     }
 }

src/main/java/org/saturnclient/saturnclient/mixin/PlayerEntityRendererMixin.java

@@ -25,6 +25,6 @@ public abstract class PlayerEntityRendererMixin
     @Inject(method = "<init>", at = @At("TAIL"))
     private void addCustomFeatureRenderer(EntityRendererFactory.Context ctx, boolean slim, CallbackInfo ci) {
         this.addFeature(new HatFeatureRenderer(this));
-        this.addFeature(new CloakFeatureRenderer(this, ctx.getEntityModels(), ctx.getEquipmentModelLoader()));
+        this.addFeature(new CloakFeatureRenderer(this, ctx.getEquipmentModelLoader()));
     }
 }