Jump to content

Player ModelRederer [1.16.5]


Yurim64

Recommended Posts

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 by Yurim64
Link to comment
Share on other sites

  • Yurim64 changed the title to Player ModelRederer [1.16.5]

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.