Player ModelRederer [1.16.5]

[Yurim64]

Hi!

I would like to render the second layer of the player skins in 3D, but when I even try to change the position of the player's hat, nothing changes.
Here is the Class:

public class SkinLayerRenderer extends LivingRenderer<AbstractClientPlayerEntity, PlayerModel<AbstractClientPlayerEntity>> {

    public SkinLayerRenderer(EntityRendererManager p_i46102_1_) {
        this(p_i46102_1_, false);
    }

    public SkinLayerRenderer(EntityRendererManager p_i46103_1_, boolean p_i46103_2_) {
        super(p_i46103_1_, new PlayerModel<>(0.0F, p_i46103_2_), 0.5F);
        this.addLayer(new BipedArmorLayer<>(this, new BipedModel(0.5F), new BipedModel(1.0F)));
        this.addLayer(new HeldItemLayer<>(this));
        this.addLayer(new ArrowLayer<>(this));
        this.addLayer(new Deadmau5HeadLayer(this));
        this.addLayer(new CapeLayer(this));
        this.addLayer(new HeadLayer<>(this, .5f, .5f, .5f)); //index = 5
        this.addLayer(new ElytraLayer<>(this));
        this.addLayer(new ParrotVariantLayer<>(this));
        this.addLayer(new SpinAttackEffectLayer<>(this));
        this.addLayer(new BeeStingerLayer<>(this));
    }

    public void render(AbstractClientPlayerEntity player, float f1, float f2, MatrixStack matrix, IRenderTypeBuffer buffer, int n) {
        this.setModelProperties(player);
        this.model.hat.visible = true;
        this.model.hat.y = 10;
        this.model.hat.z = 10;
        this.model.hat.x = 10;
        super.render(player, f1, f2, matrix, buffer, n);
    }

    public Vector3d getRenderOffset(AbstractClientPlayerEntity player, float f1) {
        return player.isCrouching() ? new Vector3d(0.0D, -0.125D, 0.0D) : super.getRenderOffset(player, f1);
    }

    private void setModelProperties(AbstractClientPlayerEntity player) {
        PlayerModel<AbstractClientPlayerEntity> playermodel = this.getModel();
        if (player.isSpectator()) {
            playermodel.setAllVisible(false);
            playermodel.head.visible = true;
            playermodel.hat.visible = true;
        } else {
            playermodel.setAllVisible(true);
            playermodel.hat.visible = player.isModelPartShown(PlayerModelPart.HAT);
            playermodel.jacket.visible = player.isModelPartShown(PlayerModelPart.JACKET);
            playermodel.leftPants.visible = player.isModelPartShown(PlayerModelPart.LEFT_PANTS_LEG);
            playermodel.rightPants.visible = player.isModelPartShown(PlayerModelPart.RIGHT_PANTS_LEG);
            playermodel.leftSleeve.visible = player.isModelPartShown(PlayerModelPart.LEFT_SLEEVE);
            playermodel.rightSleeve.visible = player.isModelPartShown(PlayerModelPart.RIGHT_SLEEVE);
            playermodel.crouching = player.isCrouching();
            BipedModel.ArmPose bipedmodel$armpose = getArmPose(player, Hand.MAIN_HAND);
            BipedModel.ArmPose bipedmodel$armpose1 = getArmPose(player, Hand.OFF_HAND);
            if (bipedmodel$armpose.isTwoHanded()) {
                bipedmodel$armpose1 = player.getOffhandItem().isEmpty() ? BipedModel.ArmPose.EMPTY : BipedModel.ArmPose.ITEM;
            }

            if (player.getMainArm() == HandSide.RIGHT) {
                playermodel.rightArmPose = bipedmodel$armpose;
                playermodel.leftArmPose = bipedmodel$armpose1;
            } else {
                playermodel.rightArmPose = bipedmodel$armpose1;
                playermodel.leftArmPose = bipedmodel$armpose;
            }
        }

    }

    private static BipedModel.ArmPose getArmPose(AbstractClientPlayerEntity player, Hand hand) {
        ItemStack itemstack = player.getItemInHand(hand);
        if (itemstack.isEmpty()) {
            return BipedModel.ArmPose.EMPTY;
        } else {
            if (player.getUsedItemHand() == hand && player.getUseItemRemainingTicks() > 0) {
                UseAction useaction = itemstack.getUseAnimation();
                if (useaction == UseAction.BLOCK) {
                    return BipedModel.ArmPose.BLOCK;
                }

                if (useaction == UseAction.BOW) {
                    return BipedModel.ArmPose.BOW_AND_ARROW;
                }

                if (useaction == UseAction.SPEAR) {
                    return BipedModel.ArmPose.THROW_SPEAR;
                }

                if (useaction == UseAction.CROSSBOW && hand == player.getUsedItemHand()) {
                    return BipedModel.ArmPose.CROSSBOW_CHARGE;
                }
            } else if (!player.swinging && itemstack.getItem() == Items.CROSSBOW && CrossbowItem.isCharged(itemstack)) {
                return BipedModel.ArmPose.CROSSBOW_HOLD;
            }

            return BipedModel.ArmPose.ITEM;
        }
    }

    public ResourceLocation getTextureLocation(AbstractClientPlayerEntity player) {
        return player.getSkinTextureLocation();
    }

    protected void scale(AbstractClientPlayerEntity player, MatrixStack matrix, float f) {
        float f1 = 0.9375F;
        matrix.scale(0.9375F, 0.9375F, 0.9375F);
    }

    protected void renderNameTag(AbstractClientPlayerEntity player, ITextComponent text, MatrixStack matrix, IRenderTypeBuffer buffer, int n) {
        double d0 = this.entityRenderDispatcher.distanceToSqr(player);
        matrix.pushPose();
        if (d0 < 100.0D) {
            Scoreboard scoreboard = player.getScoreboard();
            ScoreObjective scoreobjective = scoreboard.getDisplayObjective(2);
            if (scoreobjective != null) {
                Score score = scoreboard.getOrCreatePlayerScore(player.getScoreboardName(), scoreobjective);
                super.renderNameTag(player, (new StringTextComponent(Integer.toString(score.getScore()))).append(" ").append(scoreobjective.getDisplayName()), matrix, buffer, n);
                matrix.translate(0.0D, (double) (9.0F * 1.15F * 0.025F), 0.0D);
            }
        }

        super.renderNameTag(player, text, matrix, buffer, n);
        matrix.popPose();
    }

    public void renderRightHand(MatrixStack matrix, IRenderTypeBuffer buffer, int n, AbstractClientPlayerEntity player) {
        this.renderHand(matrix, buffer, n, player, (this.model).rightArm, (this.model).rightSleeve);
    }

    public void renderLeftHand(MatrixStack matrix, IRenderTypeBuffer buffer, int n, AbstractClientPlayerEntity player) {
        this.renderHand(matrix, buffer, n, player, (this.model).leftArm, (this.model).leftSleeve);
    }

    private void renderHand(MatrixStack matrix, IRenderTypeBuffer buffer, int n, AbstractClientPlayerEntity player, ModelRenderer arm, ModelRenderer sleeve) {
        PlayerModel<AbstractClientPlayerEntity> playermodel = this.getModel();
        this.setModelProperties(player);
        playermodel.attackTime = 0.0F;
        playermodel.crouching = false;
        playermodel.swimAmount = 0.0F;
        playermodel.setupAnim(player, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F);
        arm.xRot = 0.0F;
        arm.render(matrix, buffer.getBuffer(RenderType.entitySolid(player.getSkinTextureLocation())), n, OverlayTexture.NO_OVERLAY);
        sleeve.xRot = 0.0F;
        sleeve.render(matrix, buffer.getBuffer(RenderType.entityTranslucent(player.getSkinTextureLocation())), n, OverlayTexture.NO_OVERLAY);
    }

    protected void setupRotations(AbstractClientPlayerEntity player, MatrixStack matrix, float x, float y, float z) {
        float f = player.getSwimAmount(z);
        if (player.isFallFlying()) {
            super.setupRotations(player, matrix, x, y, z);
            float f1 = (float) player.getFallFlyingTicks() + z;
            float f2 = MathHelper.clamp(f1 * f1 / 100.0F, 0.0F, 1.0F);
            if (!player.isAutoSpinAttack()) {
                matrix.mulPose(Vector3f.XP.rotationDegrees(f2 * (-90.0F - player.xRot)));
            }

            Vector3d vector3d = player.getViewVector(z);
            Vector3d vector3d1 = player.getDeltaMovement();
            double d0 = Entity.getHorizontalDistanceSqr(vector3d1);
            double d1 = Entity.getHorizontalDistanceSqr(vector3d);
            if (d0 > 0.0D && d1 > 0.0D) {
                double d2 = (vector3d1.x * vector3d.x + vector3d1.z * vector3d.z) / Math.sqrt(d0 * d1);
                double d3 = vector3d1.x * vector3d.z - vector3d1.z * vector3d.x;
                matrix.mulPose(Vector3f.YP.rotation((float) (Math.signum(d3) * Math.acos(d2))));
            }
        } else if (f > 0.0F) {
            super.setupRotations(player, matrix, x, y, z);
            float f3 = player.isInWater() ? -90.0F - player.xRot : -90.0F;
            float f4 = MathHelper.lerp(f, 0.0F, f3);
            matrix.mulPose(Vector3f.XP.rotationDegrees(f4));
            if (player.isVisuallySwimming()) {
                matrix.translate(0.0D, -1.0D, (double) 0.3F);
            }
        } else {
            super.setupRotations(player, matrix, x, y, z);
        }

    }
}

Can someone help me?

Edited May 6, 2021 by Yurim64