Minecraft Forums

I am working on a mod that adds blocks to the game and I have one more block to do until the block is finished.

What I have as an example of what I'm going on about is that I have made a custom block and the grass_top texture renders white.

Here is a mod src that I am temporarily using to do what I can to make this block, as I have made the block but the grass doesn't render but only one color.

What it does is it adds one block and one thrown entity:

https://www.dropbox.com/s/dlkuta8wakmr5rd/src.zip?dl=0

If someone can get this mod src to work I would be very thankful and enjoy the ability to know how this grass texture stuff works.

Here's what it does when I use the default Minecraft grass top texture:

Here is a photo of what it does when I use my texture not being the default one and somewhere there's something that way:

Here is the code for the grass block that is some form of grass or something that way:

As my block updates it's light when placed and it returns that the material is grass and also the map color itself is also grass, it doesn't make sense to me how come my block does not work with the default minecraft grass_top texture being some color of green.

The only texture color I get from using the default texture is grey using grass_top.png and it should be rendering green.

This is not so in the newer version as the method has been removed and replaced or the method exists and would logically occur as deprecated or not.

I have looked at other .json models to where grass_top is the texture being the block or what it would be that way in the first photo.

the .json model code is different between the two photos, although when built and played with in the game using the same model in the first photo resulting in it rendering the way it does.

The code for the .json model in the first photo logically does have code specific to as the model having tint:

{   "parent": "minecraft:block/block",
    "textures": {
        "particle": "minecraft:blocks/dirt",
        "bottom": "minecraft:blocks/dirt",
        "top": "minecraft:blocks/grass_top",
        "side": "minecraft:blocks/grass_top",
        "overlay": "minecraft:blocks/grass_top"
    },
    "elements": [
        {   "from": [ 0, 15, 0 ],
            "to": [ 16, 16, 16 ],
            "faces": {
                "down":  { "uv": [ 0, 0, 16, 16 ], "texture": "#bottom", "cullface": "down" },
                "up":    { "uv": [ 0, 0, 16, 16 ], "texture": "#top",    "cullface": "up", "tintindex": 0 },
                "north": { "uv": [ 0, 15, 16, 16 ], "texture": "#side",   "cullface": "north" },
                "south": { "uv": [ 0, 15, 16, 16 ], "texture": "#side",   "cullface": "south" },
                "west":  { "uv": [ 0, 15, 16, 16 ], "texture": "#side",   "cullface": "west" },
                "east":  { "uv": [ 0, 15, 16, 16 ], "texture": "#side",   "cullface": "east" }
            }
        },
        {   "from": [ 0, 15, 0 ],
            "to": [ 16, 16, 16 ],
            "faces": {
                "north": { "uv": [ 0, 15, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "north" },
                "south": { "uv": [ 0, 15, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "south" },
                "west":  { "uv": [ 0, 15, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "west" },
                "east":  { "uv": [ 0, 15, 16, 16 ], "texture": "#overlay", "tintindex": 0, "cullface": "east" }
            }
        }
    ]
}

What it does is it updates the light level according to the block and then reflects that it's material is grass while at the same time not being a snowy block that way.

The code that is considerable of a 3x3 or expandable area of the block recognizing it's surrounding occuring as what's logical that way, although then based on the occurance of other blocks and the consideration of it facing upwards or downwards that way.

Which logically does explain that this is not a recursive loop being what is logically that way:

public class BlockGrass extends Block implements IGrowable
{
 public static final PropertyBool SNOWY = PropertyBool.create("snowy");

 protected BlockGrass()
 {
 super(Material.GRASS);
 this.setDefaultState(this.blockState.getBaseState().withProperty(SNOWY, Boolean.valueOf(false)));
 this.setTickRandomly(true);
 this.setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
 }

 /**
 * Get the actual Block state of this Block at the given position. This applies properties not visible in the
 * metadata, such as fence connections.
 */
 public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos)
 {
 Block block = worldIn.getBlockState(pos.up()).getBlock();
 return state.withProperty(SNOWY, Boolean.valueOf(block == Blocks.SNOW || block == Blocks.SNOW_LAYER));
 }

 public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
 {
 if (!worldIn.isRemote)
 {
 if (worldIn.getLightFromNeighbors(pos.up()) < 4 && worldIn.getBlockState(pos.up()).getLightOpacity(worldIn, pos.up()) > 2)
 {
 worldIn.setBlockState(pos, Blocks.DIRT.getDefaultState());
 }
 else
 {
 if (worldIn.getLightFromNeighbors(pos.up()) >= 9)
 {
 for (int i = 0; i < 4; ++i)
 {
 BlockPos blockpos = pos.add(rand.nextInt(3) - 1, rand.nextInt(5) - 3, rand.nextInt(3) - 1);

 if (blockpos.getY() >= 0 && blockpos.getY() < 256 && !worldIn.isBlockLoaded(blockpos))
 {
 return;
 }

 IBlockState iblockstate = worldIn.getBlockState(blockpos.up());
 IBlockState iblockstate1 = worldIn.getBlockState(blockpos);

 if (iblockstate1.getBlock() == Blocks.DIRT && iblockstate1.getValue(BlockDirt.VARIANT) == BlockDirt.DirtType.DIRT && worldIn.getLightFromNeighbors(blockpos.up()) >= 4 && iblockstate.getLightOpacity(worldIn, pos.up()) <= 2)
 {
 worldIn.setBlockState(blockpos, Blocks.GRASS.getDefaultState());
 }
 }
 }
 }
 }
 }

 /**
 * Get the Item that this Block should drop when harvested.
 */
 public Item getItemDropped(IBlockState state, Random rand, int fortune)
 {
 return Blocks.DIRT.getItemDropped(Blocks.DIRT.getDefaultState().withProperty(BlockDirt.VARIANT, BlockDirt.DirtType.DIRT), rand, fortune);
 }

 /**
 * Whether this IGrowable can grow
 */
 public boolean canGrow(World worldIn, BlockPos pos, IBlockState state, boolean isClient)
 {
 return true;
 }

 public boolean canUseBonemeal(World worldIn, Random rand, BlockPos pos, IBlockState state)
 {
 return true;
 }

 public void grow(World worldIn, Random rand, BlockPos pos, IBlockState state)
 {
 BlockPos blockpos = pos.up();

 for (int i = 0; i < 128; ++i)
 {
 BlockPos blockpos1 = blockpos;
 int j = 0;

 while (true)
 {
 if (j >= i / 16)
 {
 if (worldIn.isAirBlock(blockpos1))
 {
 if (rand.nextInt(8) == 0)
 {
 worldIn.getBiome(blockpos1).plantFlower(worldIn, rand, blockpos1);
 }
 else
 {
 IBlockState iblockstate1 = Blocks.TALLGRASS.getDefaultState().withProperty(BlockTallGrass.TYPE, BlockTallGrass.EnumType.GRASS);

 if (Blocks.TALLGRASS.canBlockStay(worldIn, blockpos1, iblockstate1))
 {
 worldIn.setBlockState(blockpos1, iblockstate1, 3);
 }
 }
 }

 break;
 }

 blockpos1 = blockpos1.add(rand.nextInt(3) - 1, (rand.nextInt(3) - 1) * rand.nextInt(3) / 2, rand.nextInt(3) - 1);

 if (worldIn.getBlockState(blockpos1.down()).getBlock() != Blocks.GRASS || worldIn.getBlockState(blockpos1).isNormalCube())
 {
 break;
 }

 ++j;
 }
 }
 }

 @SideOnly(Side.CLIENT)
 public BlockRenderLayer getBlockLayer()
 {
 return BlockRenderLayer.CUTOUT_MIPPED;
 }

 /**
 * Convert the BlockState into the correct metadata value
 */
 public int getMetaFromState(IBlockState state)
 {
 return 0;
 }

 protected BlockStateContainer createBlockState()
 {
 return new BlockStateContainer(this, new IProperty[] {SNOWY});
 }
}