Adequate item display in GUI and inventory for 3D OBJ loaded model in 1.11.2?

[ctbe]

Hi,

 

I have loaded the most simple block I could from a .obj file. It renders fine when loaded, but the model display in inventory and in hand is messed up. I loaded it with the adequate registers as:
 

//Initialization of the block
testBlock = new Block (Material.IRON);
//Registering the block
GameRegistry.register(testBlock);
        ItemBlock item = new ItemBlock(block);
        item.setRegistryName(block.getRegistryName());
        GameRegistry.register(item);
//Registering the renders
Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(testBlock), 0, new ModelResourceLocation(Item.getItemFromBlock(testBlock).getRegistryName(), "inventory"));
ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(testBlock), 0, new ModelResourceLocation(Item.getItemFromBlock(testBlock).getRegistryName(), "inventory"));

 

Where testBlock is of type Block. This is all in class TestBlock. The jsons are as follow,

 

assets/blockstates/testblock.json:

{
  "forge_marker": 1,
  "variants": {
    "normal": {
      "model": "ctfmy:testblock.obj"
    },
    "inventory": {
      "model": "ctfmy:testblock.obj"
    },
    "gui": {
      "model": "ctfmy:testblock.obj"
    }
  }
}

models/item/testblock.json
 

{
  "forge_marker"  : 1,
  "parent": "ctfmy:block/testblock.obj",
  "display":
  {
    "thirdperson_righthand":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "thirdperson_lefthand":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "firstperson_righthand":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "firstperson_lefthand":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "head":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "ground":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    },
    "gui":
    {
      "rotation": [-45,-45,0],
      "translation": [0,0,0],
      "scale": [0.1,0.1,0.1]
    }
  }
}

 

The testblock.obj and testblock.mtl are located in assets/models/block. The block looks and renders fine when placed. But when on hand or in inventory, it is ignoring the json files rotations translations and scales. In the hand it looks very huge, like when you still haven't given a texture to a block, but it displays the texture. In the inventory it displays as an out of bound front view of the model. The scales and rotation are being ignored.

 

How can I fix it?

Edited March 14, 2017 by ctbe
Correct indenting code and code correction

[Choonster]

12 minutes ago, diesieben07 said:

• Since your blockstate json contains an inventory variant, the item model will not be loaded at all. Forge will always first look into the blockstate json and only if it does not find an inventory variant there will load the item model. You need to specify the translations in the blockstate file.

 

I don't think this is true. Looking at ModelLoader#loadItemModels, Forge tries to load the item model first and only tries to load the model from the blockstates file if that throws an exception.

[ctbe]

2 hours ago, diesieben07 said:

• Don't use ItemModelMesher::register, only use ModelLoader.setCustomModelResourceLocation to register your models.

If I do that, not use the ItemModelMesher, an unknown black and purple texture gets loaded as well as the default black and purple block model. Making it appear black and purple on both, the inventory and in the hand. But thanks for the fast reply. I appreciate it.

I found what was going on. It was the json. It needs this format. I shortened it for the purpose of example. It's the one at assets/blockstates/testblock.json:

{
    "forge_marker"  :   1,
    "defaults"  :
     {
        "model" :   "MODID:model.obj"
     },
    "variants"  :
     {
        "normal"    :
         {
            "model" :   "MODID:model.obj"
         },
        "inventory" :
         [
            {
                "transform" :
                 {
                    "firstperson_righthand" :
                     {
                        "rotation" : [{"x"  : 0}, {"y"  : 0}, {"z"  : -45}],
                        "translation" : [-0.5, 0.0, 0.0],
                        "scale" :   [0.5, 0.5, 0.5]
                     },
                    "gui" :
                     {
                        "rotation" : [{"x"  : -45}, {"y"  : 0}, {"z"  : 45}],
                        "translation" : [0.0, 0.0, 0.0],
                        "scale" :   [0.5, 0.5, 0.5]
                     }

                 }
            }
         ]
     }
}

 

Notice the technical differences between the one I had before and this one now. This one declares inventory as an array with an internal object that has another internal object called transform. Then inside transform, you have the firstperson_righthand and gui objects. Inside those last objects that define how the item will be rendered in the GUI and in the first person right hand, you have rotation declared as an array with 3 objects inside, each representing XYZ. That differs from the original Minecraft json model in which rotation is an array with 3 values, not objects. Each of those XYZ objects are represented by a key:value in which the key is a string representing the axis and the value can be an integer (with sign) or a float. The parser takes care of converting it to the adequate types.

 

The item names that can be declared as objects inside transform to represent the way the model is displayed in GUI hands, etc. can be found at: http://minecraft.gamepedia.com/Model#Block_models under display. However, I don't know which one is the equivalent of ground in the Forge json. Writing ground as an object when the json is in Forge format makes nothing.

 

One final note. Forge, at least on 1.11.2, when parsing the json for the rotation and translation key, changes the XYZ coordinates to represent space as we are taught in math and science books at school. While Minecraft uses different coordinate variables to represent the axes in visible space. That causes confusion at the time of programming because Forge is parsing the json Z axis to be the Y Minecraft visible axis, and the Y axis to be the Minecraft Z visible axis. That axis exchange took me a while to notice, I hope it helps others.

[ctbe]

1 hour ago, diesieben07 said:

Then you are using ModelLoader incorrectly. You must call it's methods in preInit.

I tried that and it works. When called from preInit, the model displays okay in the gui and in the hands.

That is using ModelLoader.setCustomModelResourceLocation(...) as you said. Because on preInit, the RenderItem returned from Minecraft is null. Therefore, using ItemModelMesher at preInit will crash with a NullPointerException respective to the RenderItem. As you said, I removed it. It works well now by only calling ModelLoader at preInit.

Thanks.

P.S. The json was still wrong in my first post, but corrected in my second post. In case someone might have the same problem and is doing everything correctly in the Java code, except in the json of the blockstates. Hope it helps.