Résolu Problèmes de rendus de blocs

[bin4r1s]

Bonjour,
En mettant un mod à jour de la 1.7.10 à la 1.8.8, j’ai rencontré certains problèmes avec mes blocs, et deux problèmes restent sans solution aujourd’hui :

• Le rendu dans l’inventaire d’un bloc avec plusieurs variantes
• Un problème de texture bien étrange pour le rendu dans le monde d’un autre bloc

Tout d’abord, le problème de rendu dans l’inventaire :
J’ai rajouté de nouveaux types de planches, sauf que le rendu dans l’inventaire ne fonctionne pas (en fait, je n’ai aucune idée de comment ça peut fonctionner, j’ai testé plusieurs choses trouvées sur Internet, mais aucune ne m’a été utile). Le bloc en lui-même fonctionne, donc je ne fournis pas la classe du bloc ni la classe principale.

Classe de l’ItemBlock :

public class ItemBlockPlanks extends ItemBlock
{
    public ItemBlockPlanks(Block block)
    {
        super(block);
        this.setMaxDamage(0);
        this.setHasSubtypes(true);
    }

    @Override
    public int getMetadata(int meta)
    {
        return meta;
    }

    @Override
    public String getUnlocalizedName(ItemStack stack)
    {
        BlockPlanks.EnumType type = BlockPlanks.EnumType.byMetadata(stack.getMetadata());
        return Dragons.MODID + ":" + type.getName() + "_planks";
    }
}

ClientProxy.java (méthode appelée à l’initialisation)   :

// J'ai essayé deux choses :

// this.registerBlockTexture(Dragons.planks, 0, "frozen_planks"); (il s'agit de la méthode présentée dans le tutoriel pour créer un bloc basique)
// this.registerBlockTexture(Dragons.planks, 1, "yolo_planks");

ModelBakery.registerItemVariants(GameRegistry.findItem(Dragons.MODID, "planks"), new ResourceLocation(Dragons.MODID + ":frozen_planks"), new ResourceLocation(Dragons.MODID + ":yolo_planks"));

Conçernant les jsons, dans le dossier models/item, j’ai deux fichiers “planks.json” et “frozen_planks.json” qui pointent tous deux vers le rendu du bloc “frozen_planks.json”

Il s’agit très probablement d’un problème d’enregistrement dans le ClientProxy, étant donné que dans les logs on peut lire que la variante planks#inventory n’est pas enregistrée, seulement je ne vois pas trop comment faire avec des variantes.

Mon deuxième problème concerne le rendu d’une texture sur un bloc.
Il est censé afficher la texture “fire_invoker_eye_empty”, sauf que quand on s’approche de lui (et donc que le jeu n’applique plus la diminution de résolution des textures en fonction de la distance), c’est la texture “fire_invoker_eye” qui s’affiche, sans aucune raison apparente.

fire_invoker_receptacle.json (blockstates) :

{
    "variants": {
        "eye=false,facing=south": { "model": "dragons:fire_invoker_receptacle_empty" },
        "eye=false,facing=west": { "model": "dragons:fire_invoker_receptacle_empty", "y": 90 },
        "eye=false,facing=north": { "model": "dragons:fire_invoker_receptacle_empty", "y": 180 },
        "eye=false,facing=east": { "model": "dragons:fire_invoker_receptacle_empty", "y": 270 },
        "eye=true,facing=south": { "model": "dragons:fire_invoker_receptacle_filled" },
        "eye=true,facing=west": { "model": "dragons:fire_invoker_receptacle_filled", "y": 90 },
        "eye=true,facing=north": { "model": "dragons:fire_invoker_receptacle_filled", "y": 180 },
        "eye=true,facing=east": { "model": "dragons:fire_invoker_receptacle_filled", "y": 270 }
    }
}

fire_invoker_receptacle_empty.json (models/block) :

{
   "parent": "dragons:block/invoker_receptacle",
   "textures": {
      "material": "blocks/nether_brick",
      "eye": "dragons:blocks/fire_invoker_eye_empty"
   }
}

fire_invoker_receptacle_filled.json (models/block) :

{
    "parent": "dragons:block/invoker_receptacle",
    "textures": {
        "material": "blocks/nether_brick",
        "eye": "dragons:blocks/fire_invoker_eye"
    }
}

Ici je n’ai absolument aucune idée de l’origine du problème.

Merci d’avance ^^

Version de Forge : 1.8.8-11.15.0.1655

[robin4002]

Salut,

Pour les blocs avec variantes (demi-dalle ici), j’ai ça :

       ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(NHGBlocks.HARDENED_CLAY_1_SIMPLE), new ItemMeshDefinition()
       {
           @Override
           public ModelResourceLocation getModelLocation(ItemStack stack)
           {
               return new ModelResourceLocation(ModNanotechHungerGames.MODID + ":block_hardened_clay_slab_" + BlockSlabClay1.EnumType.byMetadata(stack.getItemDamage()).toString(), "inventory");
           }
       });

La fonction byMetadata renvoies l’EnumType en fonction du metadata et toString() le nom de cette enum (et donc le nom de l’item, qui est utilisé du-coup pour le nom du json).

Et pour ton souci de rendu, je n’ai pas comprit le problème. Un screenshot serait pas mal.

[bin4r1s]

Pour le rendu d’item ça n’a pas fonctionné (code adapté, au cas où j’aurais fait une boulette sans m’en rendre compte) :

ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(Dragons.planks), new ItemMeshDefinition(){
     @Override
     public ModelResourceLocation getModelLocation(ItemStack stack)
     {
           return new ModelResourceLocation(Dragons.MODID + ":" + BlockPlanks.EnumType.byMetadata(stack.getItemDamage()).toString() + "_planks", "inventory");
     }
});

J’ai toujours l’erreur : “Model definition for location dragons:planks#inventory not found”

Concernant le bloc avec un rendu de texture bizarre :

[robin4002]

Ah oui, il faut aussi enregistrer les variantes :

ResourceLocation[] slab1variant = new ResourceLocation[8];
for(int i = 0; i < BlockSlabClay1.EnumType.values().length; i++)
{
slab1variant* = new ResourceLocation(ModNanotechHungerGames.MODID, "block_hardened_clay_slab_" + BlockSlabClay1.EnumType.values()*);
}
ModelBakery.registerItemVariants(Item.getItemFromBlock(NHGBlocks.HARDENED_CLAY_1_SIMPLE), slab1variant);

Il faut que se soit appelé uniquement en client depuis preinit (idem pour l’autre code).

Pour ton deuxième problème, en gros il utilise la mauvaise texture ?
Tu as quoi dans le json invoker_receptacle ?

[bin4r1s]

Toujours non-fonctionnel
Petite évolution cependant :

Model definition for location dragons:frozen_planks#inventory not found
Model definition for location dragons:planks#variant=yolo not found

       ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(Dragons.planks), new ItemMeshDefinition()
       {
           @Override
           public ModelResourceLocation getModelLocation(ItemStack stack)
           {
               return new ModelResourceLocation(Dragons.MODID + ":" + BlockPlanks.EnumType.byMetadata(stack.getItemDamage()).toString() + "_planks", "inventory");
           }
       });

ResourceLocation[] planksVariants = new ResourceLocation[2];
       for(int i = 0; i < BlockPlanks.EnumType.values().length; i++)
       {
           planksVariants* = new ResourceLocation(Dragons.MODID, BlockPlanks.EnumType.values()* + "_planks");
       }
       ModelBakery.registerItemVariants(Item.getItemFromBlock(Dragons.planks), planksVariants);

invoker_receptacle.json :

{
   "textures": {
       "particle": "#material",
       "material": "#material",
       "eye": "#eye"
   },
   "elements": [
       {   "from": [ 0, 0, 0 ],
           "to": [ 16, 1, 16 ],
           "faces": {
               "down":  { "uv": [ 0, 0, 16, 16 ], "texture": "#material" },
               "up":    { "uv": [ 0, 0, 16, 16 ], "texture": "#material" },
               "north": { "uv": [ 0, 0, 16, 1 ], "texture": "#material" },
               "south": { "uv": [ 0, 0, 16, 1 ], "texture": "#material" },
               "west":  { "uv": [ 0, 0, 16, 1 ], "texture": "#material" },
               "east":  { "uv": [ 0, 0, 16, 1 ], "texture": "#material" }
           }
       },
       {   "from": [ 4, 5, 4 ],
           "to": [ 12, 13, 12 ],
           "faces": {
               "down":  { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" },
               "up":    { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" },
               "north": { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" },
               "south": { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" },
               "west":  { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" },
               "east":  { "uv": [ 4, 4, 12, 12 ], "texture": "#eye" }
           }
       }
   ]
}

[robin4002]

Étrange, je ne vois pas d’où ça peut venir.
Tu peux m’envoyer un zip de ton dossier src ?

[LeBossMax2]

J’airais plutot pençé à

ModelResourceLocation[] planksVariants = new ModelResourceLocation[2];
for(int i = 0; i < BlockPlanks.EnumType.values().length; i++)
{
    planksVariants* = new ModelResourceLocation(Dragons.MODID + ":" + BlockPlanks.EnumType.values()* + "_planks", "inventory");
}

au lieux de

ResourceLocation[] planksVariants = new ResourceLocation[2];
for(int i = 0; i < BlockPlanks.EnumType.values().length; i++)
{
    planksVariants* = new ResourceLocation(Dragons.MODID, BlockPlanks.EnumType.values()* + "_planks");
}

[bin4r1s]

@LeBossMax2
ça n’a rien changé

@robin4002
Oui par MP

[robin4002]

Tu utilises des anciennes mapping, ça m’embête bien car ça me fait des erreurs partout.
De plus si tu es encore en 1.8.8, tu devrais passer en 1.8.9.

[bin4r1s]

Ok je vais voir pour passer en 1.8.9 mais en vérité la 1.8.8 n’était qu’une étape pour rendre le passage en 1.9.4 moins lourd… Mais bon je vais mettre à jour vers la 1.8.9, étant donné que la version que j’utilise est une Beta, ça pourrait aussi venir de forge (pour le problème de texture)

[robin4002]

Oui c’est aussi ce que je pensais, il y a mal de changement entre les versions pour 1.8.8 et la dernière version de forge 1.8.9.
Suffit de regarder le changelog pour voir les bugs corrigés. Et les mapping sont aussi plus complète.

Rester sur les versions intermédiaire n’est jamais une bonne chose.

[bin4r1s]

Maintenant ça fonctionne mieux (FML cherche les modèles dragons:frozen_planks#inventory & dragons:yolo_planks#inventory), mais après avoir créé les deux fichiers dans le dossier models/item, ceux-ci sont bien trouvés mais les blocs ne sont toujours pas bien rendus dans l’inventaire, et leur nom non localisé est devenu dragons:frozen_planks.name (sans “tile.” donc), ce qui me laisse à penser que ça ne vient pas des jsons (qui m’ont l’air tout à fait corrects, au passage) mais plutôt encore de l’enregistrement. FML recherche d’ailleurs toujours le modèle dragons:planks#xxxxx

Code :

ClientProxy.java

ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(Dragons.planks), new ItemMeshDefinition()
{
@Override
public ModelResourceLocation getModelLocation(ItemStack stack)
{
return new ModelResourceLocation(Dragons.MODID + ":" + BlockPlanks.EnumType.byMetadata(stack.getItemDamage()).toString() + "_planks", "inventory");
}
});

ResourceLocation[] planksVariants = new ResourceLocation[2];
for(int i = 0; i < BlockPlanks.EnumType.values().length; i++)
{
planksVariants* = new ResourceLocation(Dragons.MODID, BlockPlanks.EnumType.values()* + "_planks");
}
ModelBakery.registerItemVariants(Item.getItemFromBlock(Dragons.planks), planksVariants);

Les jsons (au cas où) :
frozen_planks.json (models/item) :

{
"parent": "dragons:block/frozen_planks",
"display": {
"thirdperson": {
"rotation": [ 10, -45, 170 ],
"translation": [ 0, 1.5, -2.75 ],
"scale": [ 0.375, 0.375, 0.375 ]
}
}
}

frozen_planks.json (blockstates) :

{
"variants": {
"variant=normal": { "model": "dragons:frozen_planks" }
}
}

Le frozen_planks.json du dossier models/block est ok, puisque le bloc est bien rendu dans le monde.

Nouvelle version de Forge : 1.8.9-11.15.1.1722 (recommandée)

[robin4002]

Tu peux envoyer la classe du bloc ?

[bin4r1s]

C’est basiquement la même chose que la classe des planches de Minecraft, à savoir :

BlockPlanks.java

package fr.bin4r1s.dragons.block;

import java.util.List;

import fr.bin4r1s.dragons.core.Dragons;
import net.minecraft.block.Block;
import net.minecraft.block.material.MapColor;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyEnum;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IStringSerializable;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class BlockPlanks extends Block
{
   public static final PropertyEnum <blockplanks.enumtype>VARIANT = PropertyEnum.<blockplanks.enumtype>create("variant", BlockPlanks.EnumType.class);

   public BlockPlanks()
   {
       super(Material.wood);
       this.setDefaultState(this.blockState.getBaseState().withProperty(VARIANT, BlockPlanks.EnumType.FROZEN));
       this.setCreativeTab(Dragons.dragonsTab);
   }

   public int damageDropped(IBlockState state)
   {
       return ((BlockPlanks.EnumType)state.getValue(VARIANT)).getMetadata();
   }

   @SideOnly(Side.CLIENT)
   public void getSubBlocks(Item itemIn, CreativeTabs tab, List <itemstack>list)
   {
       for (BlockPlanks.EnumType blockplanks$enumtype : BlockPlanks.EnumType.values())
       {
           list.add(new ItemStack(itemIn, 1, blockplanks$enumtype.getMetadata()));
       }
   }

   public IBlockState getStateFromMeta(int meta)
   {
       return this.getDefaultState().withProperty(VARIANT, BlockPlanks.EnumType.byMetadata(meta));
   }

   public MapColor getMapColor(IBlockState state)
   {
       return ((BlockPlanks.EnumType)state.getValue(VARIANT)).func_181070_c();
   }

   public int getMetaFromState(IBlockState state)
   {
       return ((BlockPlanks.EnumType)state.getValue(VARIANT)).getMetadata();
   }

   protected BlockState createBlockState()
   {
       return new BlockState(this, new IProperty[] {VARIANT});
   }

   public static enum EnumType implements IStringSerializable
   {
       FROZEN(0, "frozen", MapColor.woodColor),
       YOLO(1, "yolo", MapColor.woodColor);

       private static final BlockPlanks.EnumType[] META_LOOKUP = new BlockPlanks.EnumType[values().length];
       private final int meta;
       private final String name;
       private final String unlocalizedName;
       private final MapColor field_181071_k;

       private EnumType(int meta, String name, MapColor color)
       {
           this(meta, name, name, color);
       }

       private EnumType(int meta, String name, String unlocalizedName, MapColor color)
       {
           this.meta = meta;
           this.name = name;
           this.unlocalizedName = unlocalizedName;
           this.field_181071_k = color;
       }

       public int getMetadata()
       {
           return this.meta;
       }

       public MapColor func_181070_c()
       {
           return this.field_181071_k;
       }

       public String toString()
       {
           return this.name;
       }

       public static BlockPlanks.EnumType byMetadata(int meta)
       {
           if (meta < 0 || meta >= META_LOOKUP.length)
           {
               meta = 0;
           }

           return META_LOOKUP[meta];
       }

       public String getName()
       {
           return this.name;
       }

       public String getUnlocalizedName()
       {
           return this.unlocalizedName;
       }

       static
       {
           for (BlockPlanks.EnumType blockplanks$enumtype : values())
           {
               META_LOOKUP[blockplanks$enumtype.getMetadata()] = blockplanks$enumtype;
           }
       }
   }
}

Il y a quand même un ajout, l’ItemBlock :

ItemBlockPlanks.java

package fr.bin4r1s.dragons.block;

import fr.bin4r1s.dragons.core.Dragons;
import net.minecraft.block.Block;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;

public class ItemBlockPlanks extends ItemBlock
{
    public ItemBlockPlanks(Block block)
    {
        super(block);
        this.setMaxDamage(0);
        this.setHasSubtypes(true);
    }

    @Override
    public int getMetadata(int meta)
    {
        return meta;
    }

    @Override
    public String getUnlocalizedName(ItemStack stack)
    {
        BlockPlanks.EnumType type = BlockPlanks.EnumType.byMetadata(stack.getMetadata());
        return Dragons.MODID + ":" + type.getName() + "_planks";
    }
}

```</itemstack></blockplanks.enumtype></blockplanks.enumtype>

[robin4002]

Dans le json qui se trouve dans le dossier blockstate tu dois avoir une valeur par variante :

{
"variants": {
"variant=frozen": { "model": "dragons:frozen_planks" },
               "variant=yolo": { "model": "dragons:yolo_planks" }
}
}

et le json doit avoir le nom du bloc dans le registre.

[bin4r1s]

C’est déjà ce que je fais :

planks.json :

{
"variants": {
"variant=frozen": { "model": "dragons:frozen_planks" },
"variant=yolo": { "model": "nether_brick" }
}
}

Et je doute que ce soit ce fichier qui pose problème puisque le rendu dans le monde fonctionne très bien…

EDIT :

Finalement, après avoir testé plusieurs choses, il se trouve qu’effectivement, en enregistrant chaque metadata avec la fonction registerBlockTexture(block, meta, name), ça fonctionne mieux x)

       this.registerBlockTexture(Dragons.planks, 0, "frozen_planks");
       this.registerBlockTexture(Dragons.planks, 1, "yolo_planks");

       ResourceLocation[] planksVariants = new ResourceLocation[2];
        for(int i = 0; i < BlockPlanks.EnumType.values().length; i++)
        {
            planksVariants* = new ResourceLocation(Dragons.MODID, BlockPlanks.EnumType.values()* + "_planks");
        }
        ModelBakery.registerItemVariants(Item.getItemFromBlock(Dragons.planks), planksVariants);

Côté json, les blockstates sont gérés par planks.json, chaque meta a son propre modèle d’item et de bloc.

Voilà Sujet résolu

EDIT : Ah oui non, en fait j’ai toujours mon problème de texture (fire_invoker)

[bin4r1s]

Up. Des idées pour l’origine du problème ?

[robin4002]

Non je ne sais pas d’où ça pourrait venir

[bin4r1s]

Ok, demain je pars chez mes grands-parents donc j’aurais l’occasion de me pencher dessus (malgré l’absence de connexion Internet)

[bin4r1s]

Ok alors visiblement la solution était toute bête (mais quand même bizarre), il m’a suffit de renommer la version “fire_invoker_receptacle_empty” en “fire_invoker_receptacle” (et tout ce qui y faisait référence) pour que le modèle fonctionne… Étrange

Sujet résolu.