1.12.2 Probleme avec rendu du joueur.



  • Bonjour.
    J'ai suivi le tutoriel de Gugu (https://www.minecraftforgefrance.fr/topic/3139/renderplayerevent-modifier-le-model-du-joueur)

    Sauf que j'ai des petit probleme ( https://imgur.com/a/HdobIN5 )

    (Forge 1.12.2)


  • Moddeurs confirmés Rédacteurs Administrateurs

    Bonsoir,

    Ta classe RenderCustomPlayer doit extends RenderPlayer.



  • @robin4002 Merci. cela a résolu un problème avec le doRender sauf que j'ai toujours ce problème ( https://imgur.com/8Vg35FO )

    si je efface new ModelCustomPlayer(0.0F, useSmallArms) (d’après le conseil de eclipse) et le jeux commence a frezze et spam ceci dans la console https://hastebin.com/ababazowaw.rb
    j'ai remarque que ceci (

       at net.minecraftforge.fml.common.eventhandler.ASMEventHandler.invoke(ASMEventHandler.java:90) ~[ASMEventHandler.class:?]
       at net.minecraftforge.fml.common.eventhandler.EventBus.post(EventBus.java:182) ~[EventBus.class:?]
       at net.minecraft.client.renderer.entity.RenderPlayer.doRender(RenderPlayer.java:63) ~[RenderPlayer.class:?]
       at Mini.Life.sportday.PlayetChange.PlayerScale.preRenderPlayer(PlayerScale.java:40) ~[PlayerScale.class:?] ```
    ) se répété bcp de fois.

  • Moddeurs confirmés Rédacteurs Administrateurs

    Ah oui, effectivement, en fait il ne faut pas extends RenderPlayer, sinon tu te retrouve à avoir l'event appelé en boucle.
    Dans le tutoriel gugu dis qu'il faut recopier tout le contenu de la classe RenderPlayer et juste changer le constructeur (donc je suppose qu'il faut extends RenderLiving ou RenderEntity).



  • Il te faudra copier/coller l'intégralité de la classe RenderPlayer dans une classe custom (RenderCustomPlayer )
    En veillant à virer les hooks de forge, dans les méthodes de rendu
    Supprime juste les lignes à forge post() un event.

    Et par la suite il te faudra réécrire certains Layer

    Après quoi, ce sera bon !



  • Voici la solution merci a Ama et Robin

    RenderCustomPlayer.java

    package ml.test.sportday;
    
    import net.minecraft.client.entity.AbstractClientPlayer;
    import net.minecraft.client.model.ModelBiped;
    import net.minecraft.client.model.ModelPlayer;
    import net.minecraft.client.renderer.GlStateManager;
    import net.minecraft.client.renderer.entity.RenderLivingBase;
    import net.minecraft.client.renderer.entity.RenderManager;
    import net.minecraft.client.renderer.entity.RenderPlayer;
    import net.minecraft.client.renderer.entity.layers.LayerArrow;
    import net.minecraft.client.renderer.entity.layers.LayerBipedArmor;
    import net.minecraft.client.renderer.entity.layers.LayerCape;
    import net.minecraft.client.renderer.entity.layers.LayerCustomHead;
    import net.minecraft.client.renderer.entity.layers.LayerDeadmau5Head;
    import net.minecraft.client.renderer.entity.layers.LayerElytra;
    import net.minecraft.client.renderer.entity.layers.LayerEntityOnShoulder;
    import net.minecraft.client.renderer.entity.layers.LayerHeldItem;
    import net.minecraft.entity.player.EnumPlayerModelParts;
    import net.minecraft.item.EnumAction;
    import net.minecraft.item.ItemStack;
    import net.minecraft.scoreboard.Score;
    import net.minecraft.scoreboard.ScoreObjective;
    import net.minecraft.scoreboard.Scoreboard;
    import net.minecraft.util.EnumHandSide;
    import net.minecraft.util.ResourceLocation;
    import net.minecraft.util.math.MathHelper;
    import net.minecraft.util.math.Vec3d;
    import net.minecraftforge.fml.relauncher.Side;
    import net.minecraftforge.fml.relauncher.SideOnly;
    
    @SideOnly(Side.CLIENT)
    public class RenderCustomPlayer extends RenderLivingBase<AbstractClientPlayer>
    {
        /** this field is used to indicate the 3-pixel wide arms */
        private final boolean smallArms;
    
        public RenderCustomPlayer(RenderManager renderManager)
        {
            this(renderManager, false);
        }
    
        public RenderCustomPlayer(RenderManager renderManager, boolean useSmallArms)
        {
        	
            super(renderManager, new ModelCustomPlayer(0.0F, useSmallArms), 0.5F);
            this.smallArms = useSmallArms;
            this.addLayer(new LayerBipedArmor(this));
            this.addLayer(new LayerHeldItem(this));
            this.addLayer(new LayerArrow(this));
            this.addLayer(new LayerCustomHead(this.getMainModel().bipedHead));
            this.addLayer(new LayerElytra(this));
            this.addLayer(new LayerEntityOnShoulder(renderManager));
        }
    
        public ModelPlayer getMainModel()
        {
            return (ModelPlayer)super.getMainModel();
        }
    
        /**
         * Renders the desired {@code T} type Entity.
         */
        public void doRender(AbstractClientPlayer entity, double x, double y, double z, float entityYaw, float partialTicks)
        {
        
            if (!entity.isUser() || this.renderManager.renderViewEntity == entity)
            {
                double d0 = y;
    
                if (entity.isSneaking())
                {
                    d0 = y - 0.125D;
                }
    
                this.setModelVisibilities(entity);
                GlStateManager.enableBlendProfile(GlStateManager.Profile.PLAYER_SKIN);
                super.doRender(entity, x, d0, z, entityYaw, partialTicks);
                GlStateManager.disableBlendProfile(GlStateManager.Profile.PLAYER_SKIN);
            }
           //net.minecraftforge.common.MinecraftForge.EVENT_BUS.post(new net.minecraftforge.client.event.RenderPlayerEvent.Post(entity, this, partialTicks, x, y, z));
        }
    
        private void setModelVisibilities(AbstractClientPlayer clientPlayer)
        {
            ModelPlayer modelplayer = this.getMainModel();
    
            if (clientPlayer.isSpectator())
            {
                modelplayer.setVisible(false);
                modelplayer.bipedHead.showModel = true;
                modelplayer.bipedHeadwear.showModel = true;
            }
            else
            {
                ItemStack itemstack = clientPlayer.getHeldItemMainhand();
                ItemStack itemstack1 = clientPlayer.getHeldItemOffhand();
                modelplayer.setVisible(true);
                modelplayer.bipedHeadwear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.HAT);
                modelplayer.bipedBodyWear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.JACKET);
                modelplayer.bipedLeftLegwear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.LEFT_PANTS_LEG);
                modelplayer.bipedRightLegwear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.RIGHT_PANTS_LEG);
                modelplayer.bipedLeftArmwear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.LEFT_SLEEVE);
                modelplayer.bipedRightArmwear.showModel = clientPlayer.isWearing(EnumPlayerModelParts.RIGHT_SLEEVE);
                modelplayer.isSneak = clientPlayer.isSneaking();
                ModelBiped.ArmPose modelbiped$armpose = ModelBiped.ArmPose.EMPTY;
                ModelBiped.ArmPose modelbiped$armpose1 = ModelBiped.ArmPose.EMPTY;
    
                if (!itemstack.isEmpty())
                {
                    modelbiped$armpose = ModelBiped.ArmPose.ITEM;
    
                    if (clientPlayer.getItemInUseCount() > 0)
                    {
                        EnumAction enumaction = itemstack.getItemUseAction();
    
                        if (enumaction == EnumAction.BLOCK)
                        {
                            modelbiped$armpose = ModelBiped.ArmPose.BLOCK;
                        }
                        else if (enumaction == EnumAction.BOW)
                        {
                            modelbiped$armpose = ModelBiped.ArmPose.BOW_AND_ARROW;
                        }
                    }
                }
    
                if (!itemstack1.isEmpty())
                {
                    modelbiped$armpose1 = ModelBiped.ArmPose.ITEM;
    
                    if (clientPlayer.getItemInUseCount() > 0)
                    {
                        EnumAction enumaction1 = itemstack1.getItemUseAction();
    
                        if (enumaction1 == EnumAction.BLOCK)
                        {
                            modelbiped$armpose1 = ModelBiped.ArmPose.BLOCK;
                        }
                        // FORGE: fix MC-88356 allow offhand to use bow and arrow animation
                        else if (enumaction1 == EnumAction.BOW)
                        {
                            modelbiped$armpose1 = ModelBiped.ArmPose.BOW_AND_ARROW;
                        }
                    }
                }
    
                if (clientPlayer.getPrimaryHand() == EnumHandSide.RIGHT)
                {
                    modelplayer.rightArmPose = modelbiped$armpose;
                    modelplayer.leftArmPose = modelbiped$armpose1;
                }
                else
                {
                    modelplayer.rightArmPose = modelbiped$armpose1;
                    modelplayer.leftArmPose = modelbiped$armpose;
                }
            }
        }
    
        /**
         * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
         */
        public ResourceLocation getEntityTexture(AbstractClientPlayer entity)
        {
            return entity.getLocationSkin();
        }
    
        public void transformHeldFull3DItemLayer()
        {
            GlStateManager.translate(0.0F, 0.1875F, 0.0F);
        }
    
        /**
         * Allows the render to do state modifications necessary before the model is rendered.
         */
        protected void preRenderCallback(AbstractClientPlayer entitylivingbaseIn, float partialTickTime)
        {
            float f = 0.9375F;
            GlStateManager.scale(0.9375F, 0.9375F, 0.9375F);
        }
    
        protected void renderEntityName(AbstractClientPlayer entityIn, double x, double y, double z, String name, double distanceSq)
        {
            if (distanceSq < 100.0D)
            {
                Scoreboard scoreboard = entityIn.getWorldScoreboard();
                ScoreObjective scoreobjective = scoreboard.getObjectiveInDisplaySlot(2);
    
                if (scoreobjective != null)
                {
                    Score score = scoreboard.getOrCreateScore(entityIn.getName(), scoreobjective);
                    this.renderLivingLabel(entityIn, score.getScorePoints() + " " + scoreobjective.getDisplayName(), x, y, z, 64);
                    y += (double)((float)this.getFontRendererFromRenderManager().FONT_HEIGHT * 1.15F * 0.025F);
                }
            }
    
            super.renderEntityName(entityIn, x, y, z, name, distanceSq);
        }
    
        public void renderRightArm(AbstractClientPlayer clientPlayer)
        {
            float f = 1.0F;
            GlStateManager.color(1.0F, 1.0F, 1.0F);
            float f1 = 0.0625F;
            ModelPlayer modelplayer = this.getMainModel();
            this.setModelVisibilities(clientPlayer);
            GlStateManager.enableBlend();
            modelplayer.swingProgress = 0.0F;
            modelplayer.isSneak = false;
            modelplayer.setRotationAngles(0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, clientPlayer);
            modelplayer.bipedRightArm.rotateAngleX = 0.0F;
            modelplayer.bipedRightArm.render(0.0625F);
            modelplayer.bipedRightArmwear.rotateAngleX = 0.0F;
            modelplayer.bipedRightArmwear.render(0.0625F);
            GlStateManager.disableBlend();
        }
    
        public void renderLeftArm(AbstractClientPlayer clientPlayer)
        {
            float f = 1.0F;
            GlStateManager.color(1.0F, 1.0F, 1.0F);
            float f1 = 0.0625F;
            ModelPlayer modelplayer = this.getMainModel();
            this.setModelVisibilities(clientPlayer);
            GlStateManager.enableBlend();
            modelplayer.isSneak = false;
            modelplayer.swingProgress = 0.0F;
            modelplayer.setRotationAngles(0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F, clientPlayer);
            modelplayer.bipedLeftArm.rotateAngleX = 0.0F;
            modelplayer.bipedLeftArm.render(0.0625F);
            modelplayer.bipedLeftArmwear.rotateAngleX = 0.0F;
            modelplayer.bipedLeftArmwear.render(0.0625F);
            GlStateManager.disableBlend();
        }
    
        /**
         * Sets a simple glTranslate on a LivingEntity.
         */
        protected void renderLivingAt(AbstractClientPlayer entityLivingBaseIn, double x, double y, double z)
        {
            if (entityLivingBaseIn.isEntityAlive() && entityLivingBaseIn.isPlayerSleeping())
            {
                super.renderLivingAt(entityLivingBaseIn, x + (double)entityLivingBaseIn.renderOffsetX, y + (double)entityLivingBaseIn.renderOffsetY, z + (double)entityLivingBaseIn.renderOffsetZ);
            }
            else
            {
                super.renderLivingAt(entityLivingBaseIn, x, y, z);
            }
        }
    
        protected void applyRotations(AbstractClientPlayer entityLiving, float p_77043_2_, float rotationYaw, float partialTicks)
        {
            if (entityLiving.isEntityAlive() && entityLiving.isPlayerSleeping())
            {
                GlStateManager.rotate(entityLiving.getBedOrientationInDegrees(), 0.0F, 1.0F, 0.0F);
                GlStateManager.rotate(this.getDeathMaxRotation(entityLiving), 0.0F, 0.0F, 1.0F);
                GlStateManager.rotate(270.0F, 0.0F, 1.0F, 0.0F);
            }
            else if (entityLiving.isElytraFlying())
            {
                super.applyRotations(entityLiving, p_77043_2_, rotationYaw, partialTicks);
                float f = (float)entityLiving.getTicksElytraFlying() + partialTicks;
                float f1 = MathHelper.clamp(f * f / 100.0F, 0.0F, 1.0F);
                GlStateManager.rotate(f1 * (-90.0F - entityLiving.rotationPitch), 1.0F, 0.0F, 0.0F);
                Vec3d vec3d = entityLiving.getLook(partialTicks);
                double d0 = entityLiving.motionX * entityLiving.motionX + entityLiving.motionZ * entityLiving.motionZ;
                double d1 = vec3d.x * vec3d.x + vec3d.z * vec3d.z;
    
                if (d0 > 0.0D && d1 > 0.0D)
                {
                    double d2 = (entityLiving.motionX * vec3d.x + entityLiving.motionZ * vec3d.z) / (Math.sqrt(d0) * Math.sqrt(d1));
                    double d3 = entityLiving.motionX * vec3d.z - entityLiving.motionZ * vec3d.x;
                    GlStateManager.rotate((float)(Math.signum(d3) * Math.acos(d2)) * 180.0F / (float)Math.PI, 0.0F, 1.0F, 0.0F);
                }
            }
            else
            {
                super.applyRotations(entityLiving, p_77043_2_, rotationYaw, partialTicks);
            }
        }
    }
    
    

    ModelCustomPlayer.java

    package ml.test.sportday;
    
    import net.minecraft.client.model.ModelPlayer;
    import net.minecraft.entity.Entity;
    
    public class ModelCustomPlayer extends ModelPlayer {
    	 
        public ModelCustomPlayer(float modelSize, boolean smallArmsIn) {
        super(modelSize, smallArmsIn);
        }
     
        @Override
        public void setRotationAngles(float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scaleFactor, Entity entityIn)
        {
            super.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scaleFactor, entityIn);
            copyModelAngles(this.bipedLeftLeg, this.bipedLeftLegwear);
            copyModelAngles(this.bipedRightLeg, this.bipedRightLegwear);
            copyModelAngles(this.bipedLeftArm, this.bipedLeftArmwear);
            copyModelAngles(this.bipedRightArm, this.bipedRightArmwear);
            copyModelAngles(this.bipedBody, this.bipedBodyWear);
     
            this.bipedLeftArm.rotateAngleZ = -0.5f;
            this.bipedRightArm.rotateAngleZ = 1.9f;
            this.bipedLeftLeg.rotateAngleZ = -0.9f;
            this.bipedRightLeg.rotateAngleZ = 0.1f;
        }
    }
    

Log in to reply