Jump to content

[1.12.x/1.11.x] [SOLVED] JSON rendering& collision boxes


Bektor

Recommended Posts

Hi,

 

I've got the problem that I've got some JSON model for my block. This model is actually based on

submodels to be displayed correctly.

 

Having said that, the base model is a normal cube, just smaller. The submodel extends the base model to one side

until it reaches the end of the block.

 

However, with this setup I've got the following problems:

  • How to display a model with it's submodel in inventory?
  • How can I properly align my models to my set collision boxes, as currently it always fails to match on one side (especially the ending points of a cable connection)
  • How can I move the submodel around, as I would have to move it around (I guess) to be always on the correct side of the block, like on the west side or the top side or the south side or the east side etc.

 

The code:

Spoiler

public class BlockCable extends Block {
    
    /** Whether this fence connects in the northern direction */
    public static final PropertyBool NORTH = PropertyBool.create("north");
    /** Whether this fence connects in the eastern direction */
    public static final PropertyBool EAST = PropertyBool.create("east");
    /** Whether this fence connects in the southern direction */
    public static final PropertyBool SOUTH = PropertyBool.create("south");
    /** Whether this fence connects in the western direction */
    public static final PropertyBool WEST = PropertyBool.create("west");
    // TODO: up and down
    private static final AxisAlignedBB BOX_CENTER = new AxisAlignedBB(.25d, .25d, .25d, .75d, .75d, .75d);
    private static final AxisAlignedBB BOX_DOWN = new AxisAlignedBB(.25d, 0d, .25d, .75d, .25d, .75d);
    private static final AxisAlignedBB BOX_UP = new AxisAlignedBB(.25d, .75d, .25d, .75d, 1d, .75d);
    private static final AxisAlignedBB BOX_NORTH = new AxisAlignedBB(.25d, .25d, 0d, .75d, .75d, .25d);
    private static final AxisAlignedBB BOX_SOUTH = new AxisAlignedBB(.25d, .25d, .75d, .75d, .75d, 1);
    private static final AxisAlignedBB BOX_WEST = new AxisAlignedBB(0d, .25d, .25d, .25d, .75d, .75d);
    private static final AxisAlignedBB BOX_EAST = new AxisAlignedBB(.75d, .25d, .25d, 1d, .75d, .75d);
    
    // TODO: remove unused code
    private static final AxisAlignedBB[] BOX_FACES = { BOX_DOWN, BOX_UP, BOX_NORTH, BOX_SOUTH, BOX_WEST, BOX_EAST };
    
	public BlockCable() {
		super(Material.IRON);
		this.setHardness(.25f);
		this.setResistance(3f);
		
		this.setDefaultState(this.blockState.getBaseState().withProperty(NORTH, false).withProperty(EAST, false).withProperty(SOUTH, false).withProperty(WEST, false));
		this.setCreativeTab(ModCreativeTabs.mcpowerTab);
	}
	
	@Override
	public boolean isFullCube(IBlockState state) {
	    return false;
	}
	
	@Override
	public boolean isFullBlock(IBlockState state) {
	    return false;
	}
	
	@Override
	public boolean isOpaqueCube(IBlockState state) {
	    return false;
	}
	
	@Override
	public void addCollisionBoxToList(IBlockState state, World worldIn, BlockPos pos, AxisAlignedBB entityBox, 
	        List<AxisAlignedBB> collidingBoxes, Entity entityIn, boolean p_185477_7_) {
	    
	    Block.addCollisionBoxToList(pos, entityBox, collidingBoxes, BOX_CENTER);
	    if(state.getValue(NORTH)) {
	        Block.addCollisionBoxToList(pos, entityBox, collidingBoxes, BOX_NORTH);
	        return;
	    } else if(state.getValue(EAST)) {
	        Block.addCollisionBoxToList(pos, entityBox, collidingBoxes, BOX_EAST);
	        return;
	    } else if(state.getValue(WEST)) {
	        Block.addCollisionBoxToList(pos, entityBox, collidingBoxes, BOX_WEST);
	        return;
	    } else if(state.getValue(SOUTH)) {
	        Block.addCollisionBoxToList(pos, entityBox, collidingBoxes, BOX_SOUTH);
	        return;
	    }
	}
	
	@Override
	public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
	    return state.withProperty(NORTH, this.canCableConnectTo(worldIn, pos, EnumFacing.NORTH))
	            .withProperty(EAST, this.canCableConnectTo(worldIn, pos, EnumFacing.EAST))
	            .withProperty(WEST, this.canCableConnectTo(worldIn, pos, EnumFacing.WEST))
	            .withProperty(SOUTH, this.canCableConnectTo(worldIn, pos, EnumFacing.SOUTH));
	}
	
	private boolean canCableConnectTo(IBlockAccess worldIn, BlockPos pos, EnumFacing facing) {
	    return worldIn.getBlockState(pos.offset(facing)).getBlock() == ModBlocks.cable ||
	            worldIn.getBlockState(pos.offset(facing)).getBlock() == ModBlocks.transfer;
	}
	
	@Override
	public int getMetaFromState(IBlockState state) {
	    return 0;
	}
	
	@Override
	protected BlockStateContainer createBlockState() {
	    return new BlockStateContainer(this, new IProperty[] {NORTH, EAST, WEST, SOUTH});
	}

 

Cable.json (blockstate)


{
	"forge_marker": 1,
	"defaults": {
		"model": "justanotherenergy:cable_base",
		"textures": { "all": "justanotherenergy:blocks/cable" }
	},
	"variants": {
	   "north": {
	       "true": {
	       },
	       "false": {
	       }
	   },
	   "east": {
           "true": {
           },
           "false": {
           }
       },
       "south": {
           "true": {
           },
           "false": {
           }
       },
       "west": {
           "true": {
               "submodel": "justanotherenergy:cable_side",
               "y": 90
           },
           "false": {
           }
       },
       "inventory": [{ "transform": "forge:default-block" }]
	}
}

 

cable base (base model)


{
    "textures": { "particle": "justanotherenergy:blocks/cable" },
    "elements": [
        {
            "from": [ 4, 4, 4 ],
            "to": [ 12, 12, 12 ],
            "faces": {
                "down": { "texture": "#all" },
                "up": { "texture": "#all" },
                "north": { "texture": "#all" },
                "south": { "texture": "#all" },
                "west": { "texture": "#all" },
                "east": { "texture": "#all" }
            }
        }
    ]
}

 

cable side (submodel)


{
    "textures": { "all": "justanotherenergy:blocks/cable" },
    "elements": [
        {
            "from": [ 4, 4, 0 ],
            "to": [ 12, 12, 4 ],
            "faces": {
                "down": { "texture": "#all" },
                "up": { "texture": "#all" },
                "north": { "texture": "#all" },
                "south": { "texture": "#all" },
                "west": { "texture": "#all" },
                "east": { "texture": "#all" }
            }
        }
    ]
}

 

 

Thx in advance.

Bektor

Edited by Bektor

Developer of Primeval Forest.

Link to comment
Share on other sites

 

1) are you wanting to rotate the model or have multiple connections possible?  Think the variants need to account for each possible, so "north=false,south=false,west=false,east=false"->say center model, "north=true,south=false,west=false,east=false" -> different model., "north=true,south=true,east=false,west=false" -> different model ... so if that is desired, you need to account for all possible combos and point each one at different model.

 

1) If rotating: use the FACING property in your class, instead of a bool for each direction, unless it was going to have multiple directions possible, but your addcollisionbox function only allows a single direction.

 

2) you need a conversion for the blockstate metas  (getStateFromMeta(int) & getMetaFromState(IBlockState)

 

3) if you are just rotating the model, easier, just rotate the model in the y.

 

here is code from a rope that I made that rotates and moves the collision around

public class BlockRope extends BlockBase{
	public static final PropertyDirection FACING = BlockHorizontal.FACING;
	public static final PropertyBool TOP=PropertyBool.create("top");
	
	
	protected static final AxisAlignedBB BASE_AABB_TOP = new AxisAlignedBB(0, 0.0D, 0D, 1D, 0.25D, 1D);
	protected static final AxisAlignedBB BASE_AABB_NORTH = new AxisAlignedBB(.4D, 0.0D, 0D, .6D, 1D, .2D);
	protected static final AxisAlignedBB BASE_AABB_SOUTH = new AxisAlignedBB(.4D, 0.0D, .8D, .6D, 1D, 1D);
	
	protected static final AxisAlignedBB BASE_AABB_EAST = new AxisAlignedBB(.8D, 0.0D, .4D, 1D, 1D, .6D);
	protected static final AxisAlignedBB BASE_AABB_WEST = new AxisAlignedBB(0D, 0.0D, .4D, .2D, 1D, .6D);
	
	public BlockRope() {
		super(Material.CLOTH, "rope",false);
		this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(TOP, true));
		
		this.setHardness(2F);
		
	}
	
	
	
	@Override
	public boolean isSideSolid(IBlockState base_state, IBlockAccess world, BlockPos pos, EnumFacing side) {
		if(base_state.getValue(TOP)==true){
			return false;
		}
		
		return true;
	}



	@Override
	public IBlockState getStateFromMeta(int meta) {
		int adjust=meta>>1; 
		EnumFacing enumfacing = EnumFacing.getFront(adjust);

	        if (enumfacing.getAxis() == EnumFacing.Axis.Y)
	        {
	            enumfacing = EnumFacing.NORTH;
	        }
	        
	        int top=meta&1;
	        boolean tb=false;
	        if(top==1){
	        	tb=true;
	        }

	        return this.getDefaultState().withProperty(FACING, enumfacing).withProperty(TOP, tb);
	}
	@Override
	public int getMetaFromState(IBlockState state) {
		boolean top=state.getValue(TOP);
		EnumFacing facing=state.getValue(FACING);
		
		int meta=((EnumFacing)state.getValue(FACING)).getIndex();
		meta=meta<<1;
		if(top){
			meta+=1;
		}
		return meta;
	}
	
	


@Override
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
	if(state.getValue(TOP)==true){
		return BASE_AABB_TOP;
	}
	switch(state.getValue(FACING)){
	
	case EAST:
		return BASE_AABB_EAST;
		
	case NORTH:
		return BASE_AABB_NORTH;
		
	case SOUTH:
		return BASE_AABB_SOUTH;
		
	
	case WEST:
		return BASE_AABB_WEST;
		
	default:
		break;
	
	}
	return BASE_AABB_TOP;
}




@Override
public void addCollisionBoxToList(IBlockState state, World worldIn, BlockPos pos, AxisAlignedBB entityBox,
		List<AxisAlignedBB> collidingBoxes, Entity entityIn, boolean p_185477_7_) {
	 
	if(state.getValue(TOP)==true){
		addCollisionBoxToList(pos, entityBox, collidingBoxes, BASE_AABB_TOP);
	}
	else{
		switch(state.getValue(FACING)){
		case NORTH:
			addCollisionBoxToList(pos, entityBox, collidingBoxes, BASE_AABB_NORTH);
			break;
		case SOUTH:
			addCollisionBoxToList(pos, entityBox, collidingBoxes, BASE_AABB_SOUTH);
			break;
		case EAST:
			addCollisionBoxToList(pos, entityBox, collidingBoxes, BASE_AABB_EAST);
			break;
		case WEST:
			addCollisionBoxToList(pos, entityBox, collidingBoxes, BASE_AABB_WEST);
		
		default:
			break;
		}
		
	}
	
	 
}

 

 

hope that helps.

{
    "variants": {
        "facing=north,top=true": { "model": "dadmod:rope_top" },
        "facing=east,top=true":  { "model": "dadmod:rope_top", "y": 90 },
        "facing=south,top=true": { "model": "dadmod:rope_top", "y": 180 },
        "facing=west,top=true":  { "model": "dadmod:rope_top", "y": 270 },
        "facing=north,top=false": { "model": "dadmod:rope_side" },
        "facing=east,top=false":  { "model": "dadmod:rope_side", "y": 90 },
        "facing=south,top=false": { "model": "dadmod:rope_side", "y": 180 },
        "facing=west,top=false":  { "model": "dadmod:rope_side", "y": 270 }
    }
}

 

Edited by aw_wolfe
Link to comment
Share on other sites

22 hours ago, aw_wolfe said:

1) are you wanting to rotate the model or have multiple connections possible?

I want the submodel to extend the base model to have connections between blocks. Basically think about Minecraft fences. They got one base model and one submodel (except that they don't define it as submodel). My problem is now, to place the submodel at the right position of the base model for the correct connection. The difference however is that Minecraft uses multipart while I am using submodels to achieve the same effect.

 

22 hours ago, aw_wolfe said:

but your addcollisionbox function only allows a single direction.

 

Hm... how could I solve this the most efficient way?

 

22 hours ago, aw_wolfe said:

hope that helps.


{
    "variants": {
        "facing=north,top=true": { "model": "dadmod:rope_top" },
        "facing=east,top=true":  { "model": "dadmod:rope_top", "y": 90 },
        "facing=south,top=true": { "model": "dadmod:rope_top", "y": 180 },
        "facing=west,top=true":  { "model": "dadmod:rope_top", "y": 270 },
        "facing=north,top=false": { "model": "dadmod:rope_side" },
        "facing=east,top=false":  { "model": "dadmod:rope_side", "y": 90 },
        "facing=south,top=false": { "model": "dadmod:rope_side", "y": 180 },
        "facing=west,top=false":  { "model": "dadmod:rope_side", "y": 270 }
    }
}

The only problem with this code is that it replaced the whole model while I don't want the model to be replaced, but another model (submodel) beeing added to it.

Edited by Bektor

Developer of Primeval Forest.

Link to comment
Share on other sites

ok, so not just a rotation, but why doesn't the fence functionality work for you? I guess I don't understand why the multipart doesn't work for what you want. (not saying it should, just that I'm not understanding based on what I think you are trying to do)

 

here is the json for a fence blockstate

 

{
    "multipart": [
        {   "apply": { "model": "acacia_fence_post" }},
        {   "when": { "north": "true" },
            "apply": { "model": "acacia_fence_side", "uvlock": true }
        },
        {   "when": { "east": "true" },
            "apply": { "model": "acacia_fence_side", "y": 90, "uvlock": true }
        },
        {   "when": { "south": "true" },
            "apply": { "model": "acacia_fence_side", "y": 180, "uvlock": true }
        },
        {   "when": { "west": "true" },
            "apply": { "model": "acacia_fence_side", "y": 270, "uvlock": true }
        }
    ]
}

it has a center (fence post), then applies mulitpart models based on north,east,south,west.  This give you your center, with fences/connections in the different directions base on setting the blockstate PropertyBool (north, south, east, west). Each direction could be a different model.

 

If you want different images/icons for the item in inventory based on what connections the blockstate had, then I think you need to create a custom Item that holds the data. Can transfer when block breaks into the entityitem.  And then create the proper blockstate upon placement. The item then can set the icon based on the subitem...haven't done that in a while, so not 100% that is best route, but quick search should resovle that.

 

For the collision boxes, if more than 1 direction possible, then don't use if/else if/else if/else because only 1 will get selected.  Use multiple ifs

if(north==true) //add north collision

if(south==true) //add south collision

etc..

Link to comment
Share on other sites

10 minutes ago, aw_wolfe said:

I guess I don't understand why the multipart doesn't work for what you want. (not saying it should, just that I'm not understanding based on what I think you are trying to do)

 

I never tried it with multipart. I don't even know what's the difference between multipart and the submodel stuff is. I just read about the submodels in the Forge documentation and then applied it to my block even before I looked at other JSONs like the one from the fences.

Developer of Primeval Forest.

Link to comment
Share on other sites

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.

Announcements



×
×
  • Create New...

Important Information

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