Hello

I'm currently working on the mod that let players make blocks emit light. To achive this I am swaping original block with a custom one that uses texture of the original block. Original block state is stored in tile entity. I'm also using IBakedModel in conjunction with ModelBakeEvent to dynamically generate a model. It's all working fine but I have encountered some lesser rendering issues that I don't know are possible to fix

 

1. SOLVED. Transparent blocks like Ice that are directly behind my block are rendering sides (see picture below). This is probably imposible to fix due to BlockBreakable#shouldSideBeRendered implementation. (Opposite case is fine - fixed in my block's shouldSideBeRendered method).

Spoiler

 

2. My block is lacking shades (since it's emitting light) and looks "out of place" when next to "normal" blocks, especially when looking from the side . See picture below. 

Spoiler

 

3. Rendering gliches when in third person.

Spoiler

 

4. SOLVED. I cannot set block particles (like block break particles). I have no access to extendedState in getParticleTexture method in my bakedModel, so I can't get the texture of original block. 

 

The code of my mod is available on GitHub, especially Block and bakedModel.

 

If anyone has an idea how to fix any of above issues I will be really gratefull. Thanks!

Edited April 22, 20196 yr by Pyre540
Issue solved

1. Override doesSideBlockRendering

2. Have ambientOcclusion be true in your model

Hey, thanks for answer

8 hours ago, Cadiboo said:

1. Override doesSideBlockRendering

Thanks, that works great

    @Override
    public boolean doesSideBlockRendering(IBlockState state, IBlockAccess world, BlockPos pos, EnumFacing face) {
        IBlockState neighbourState = world.getBlockState(pos.offset(face));
        Block neighbourBlock = neighbourState.getBlock();
        Block originalBlock = getOriginalBlock(world, pos);

        if ((originalBlock.getBlockLayer() == BlockRenderLayer.TRANSLUCENT || originalBlock.getBlockLayer() == BlockRenderLayer.CUTOUT)
                && ((neighbourBlock == this && originalBlock == getOriginalBlock(world, pos.offset(face))) || originalBlock == neighbourBlock)) {
            return true;
        }
        return super.doesSideBlockRendering(state, world, pos, face);
    }

 

8 hours ago, Cadiboo said:

2. Have ambientOcclusion be true in your model

That unfortunately didn't help

{
  "parent": "block/cube_all",
  "ambientocclusion": true,
  "textures": {
    "all": "minecraft:blocks/glowstone"
  }
}

 

I also fixed the issue with particle textures (issue 4):

Spoiler

    @Override
    public boolean addLandingEffects(IBlockState state, WorldServer world, BlockPos blockPosition, IBlockState iblockstate, EntityLivingBase entity, int numberOfParticles) {
        IBlockState originalState = getTileEntitySafely(world, blockPosition).getOriginalBlockState();
        float f = (float) MathHelper.ceil(entity.fallDistance - 3.0F);
        double d0 = Math.min((double)(0.2F + f / 15.0F), 2.5D);
        int numOfParticles = (int)(150.0D * d0);
        world.spawnParticle(EnumParticleTypes.BLOCK_DUST, entity.posX, entity.posY, entity.posZ, numOfParticles,
                0.0D, 0.0D, 0.0D, 0.15000000596046448D, Block.getStateId(originalState));
        return true;
    }

    @Override
    public boolean addRunningEffects(IBlockState state, World world, BlockPos pos, Entity entity) {
        if (world.isRemote) {
            IBlockState originalState = getTileEntitySafely(world, pos).getOriginalBlockState();
            world.spawnParticle(EnumParticleTypes.BLOCK_CRACK,
                    entity.posX + ((double)world.rand.nextFloat() - 0.5D) * (double)entity.width,
                    entity.getEntityBoundingBox().minY + 0.1D,
                    entity.posZ + ((double)world.rand.nextFloat() - 0.5D) * (double)entity.width,
                    -entity.motionX * 4.0D, 1.5D, -entity.motionZ * 4.0D, Block.getStateId(originalState));
        }
        return true;
    }

    @SideOnly(Side.CLIENT)
    @Override
    public boolean addHitEffects(IBlockState state, World world, RayTraceResult target, ParticleManager manager) {
        BlockPos pos = target.getBlockPos();
        EnumFacing side = target.sideHit;
        IBlockState originalState = getTileEntitySafely(world, pos).getOriginalBlockState();

        int i = pos.getX();
        int j = pos.getY();
        int k = pos.getZ();

        AxisAlignedBB axisalignedbb = originalState.getBoundingBox(world, pos);
        double d0 = (double) i + world.rand.nextDouble() * (axisalignedbb.maxX - axisalignedbb.minX - 0.20000000298023224D) + 0.10000000149011612D + axisalignedbb.minX;
        double d1 = (double) j + world.rand.nextDouble() * (axisalignedbb.maxY - axisalignedbb.minY - 0.20000000298023224D) + 0.10000000149011612D + axisalignedbb.minY;
        double d2 = (double) k + world.rand.nextDouble() * (axisalignedbb.maxZ - axisalignedbb.minZ - 0.20000000298023224D) + 0.10000000149011612D + axisalignedbb.minZ;

        switch (side) {
            case DOWN:
                d1 = (double) j + axisalignedbb.minY - 0.10000000149011612D;
                break;
            case UP:
                d1 = (double) j + axisalignedbb.maxY + 0.10000000149011612D;
                break;
            case NORTH:
                d2 = (double) k + axisalignedbb.minZ - 0.10000000149011612D;
                break;
            case SOUTH:
                d2 = (double) k + axisalignedbb.maxZ + 0.10000000149011612D;
                break;
            case WEST:
                d0 = (double) i + axisalignedbb.minX - 0.10000000149011612D;
                break;
            case EAST:
                d0 = (double) i + axisalignedbb.maxX + 0.10000000149011612D;
        }

        ParticleDigging.Factory factory = new ParticleDigging.Factory();
        ParticleDigging particle = (ParticleDigging) factory.createParticle(1, world, d0, d1, d2,
                0.0D, 0.0D, 0.0D, Block.getStateId(originalState));
        particle.setBlockPos(pos).multiplyVelocity(0.2F).multipleParticleScaleBy(0.6F);
        manager.addEffect(particle);

        return true;
    }

    @SideOnly(Side.CLIENT)
    @Override
    public boolean addDestroyEffects(World world, BlockPos pos, ParticleManager manager) {
        IBlockState state = getTileEntitySafely(world, pos).getOriginalBlockState();
        ParticleDigging.Factory factory = new ParticleDigging.Factory();
        for (int j = 0; j < 4; ++j) {
            for (int k = 0; k < 4; ++k) {
                for (int l = 0; l < 4; ++l) {
                    double d0 = ((double) j + 0.5D) / 4.0D;
                    double d1 = ((double) k + 0.5D) / 4.0D;
                    double d2 = ((double) l + 0.5D) / 4.0D;

                    ParticleDigging particle = (ParticleDigging) factory.createParticle(0, world,
                            (double) pos.getX() + d0, (double) pos.getY() + d1, (double) pos.getZ() + d2,
                            d0 - 0.5D, d1 - 0.5D, d2 - 0.5D, Block.getStateId(state));
                    particle.setBlockPos(pos);
                    manager.addEffect(particle);
                }
            }
        }
        return true;
    }

 

 

So 2 down and 2 to go

Edited April 12, 20196 yr by Pyre540

Is there a way to "force" Minecraft to render block using BlockModelRenderer#renderModelSmooth method directly instead of BlockModelRenderer#renderModel method?

Set the game settings smooth lighting to smooth

I'm sorry I should be more specific with my question. I'm trying to do something with issue #2. In BlockModelRenderer#renderModel there is a flag that determines if the block should be rendered "Smooth" or "Flat".

boolean flag = Minecraft.isAmbientOcclusionEnabled() && stateIn.getLightValue(worldIn, posIn) == 0 && modelIn.isAmbientOcclusion(stateIn);

Ambient Occlusion is enabled in the game and in my model. The problem is that my block is emitting light so stateIn.getLightValue(worldIn, posIn) is greater then 0. In my last post I was asking if I could "force" the game to use renderModelSmooth method directly to bypass light value check.

I can achive the effect I want quite easly by doing somthing like that in my block: 

Spoiler

    @Override
    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
        return getTileEntitySafely(worldIn, pos).getOriginalBlockState();
    }

But that is obviously bad (at least I think it is) and can probably cause hard to find bugs in the future, so I'm trying to avoid that.

Can I achive this effect in some other way? For example by getting rid of my block's model completly and using TESR/FastTESR to just render "original" block model?

Ok so I finally got some time to play with FastTESR idea and it ended up pretty well - I achieved the effect I wanted on almost all blocks. The biggest issue with this approach turned out to be transparent blocks. They were really glitchy due to rendering order. So I end up rendering them in the correct order (furthest to nearest) in RenderWorldLastEvent and the rest (solid, cutout...) in FastTESR. At first everything looked very good, but unfortunately I found 2 new issues.

1. Transparent blocks look good during the day, but at night or in another dark environment they are too bright.

Spoiler

2. Looking at my block through another transparent block, my block has a different color (has ambient acclusion?). I probably can live with this issue but if someone know how to fix this, it would be great

Spoiler

 

My last concern is performance, but I don't think I can do something with it in current approach.

 

My FastTESR:

public class FastTESREnlightenedBlock extends FastTESR<TileEntityEnlightenedBlock> {

    private BlockRendererDispatcher blockRenderer;

    @Override
    public void renderTileEntityFast(TileEntityEnlightenedBlock te, double x, double y, double z, float partialTicks, int destroyStage, float partial, BufferBuilder buffer) {

        IBlockState originalBlockState = te.getOriginalBlockState();

        if (originalBlockState.getBlock().getBlockLayer() == BlockRenderLayer.TRANSLUCENT) {
            return;
        }

        if(blockRenderer == null) {
            blockRenderer = Minecraft.getMinecraft().getBlockRendererDispatcher();
        }

        BlockPos pos = te.getPos();
        World world = te.getWorld();
        IBlockState blockState = world.getBlockState(pos);
        IBakedModel model = blockRenderer.getModelForState(originalBlockState);

        buffer.setTranslation(x - pos.getX(), y - pos.getY(), z - pos.getZ());

        if (Minecraft.isAmbientOcclusionEnabled()) {
            blockRenderer.getBlockModelRenderer().renderModelSmooth(world, model, blockState, pos, buffer, true, MathHelper.getPositionRandom(pos));
        } else {
            blockRenderer.getBlockModelRenderer().renderModelFlat(world, model, blockState, pos, buffer, true, MathHelper.getPositionRandom(pos));
        }
    }
}

 

RenderWorldLastEvent:

    @SubscribeEvent
    public static void onRenderLastEvent(RenderWorldLastEvent event) {
        EntityPlayerSP player = Minecraft.getMinecraft().player;
        WorldClient world = Minecraft.getMinecraft().world;

        List<TileEntity> loadedTileEntityList = world.loadedTileEntityList;
        List<TileEntityEnlightenedBlock> alphas = loadedTileEntityList.stream()
                .filter(te -> te instanceof TileEntityEnlightenedBlock)
                //.filter(te -> canPlayerSeeTile(world, player, te))
                .map(te -> (TileEntityEnlightenedBlock)te)
                .filter(te -> te.getOriginalBlockState().getBlock().getBlockLayer() == BlockRenderLayer.TRANSLUCENT)
                .collect(Collectors.toList());

        if (alphas.isEmpty()) {
            return;
        }

        final double partialTicks = (double)event.getPartialTicks();
        final double playerX = player.prevPosX + (player.posX - player.prevPosX) * partialTicks;
        final double playerY = player.prevPosY + (player.posY - player.prevPosY) * partialTicks;
        final double playerZ = player.prevPosZ + (player.posZ - player.prevPosZ) * partialTicks;

        for (TileEntityEnlightenedBlock alpha : alphas) {
            alpha.setDistanceToPlayer(alpha.getDistanceSq(playerX, playerY, playerZ));
        }

        alphas.sort(Comparator.comparingDouble(TileEntityEnlightenedBlock::getDistanceToPlayer).reversed());

        for (TileEntityEnlightenedBlock alpha : alphas) {
            BlockPos pos = alpha.getPos();
            final double x = (double)pos.getX() - playerX;
            final double y = (double)pos.getY() - playerY;
            final double z = (double)pos.getZ() - playerZ;

            renderTransparentBlock(world, alpha, pos, x, y, z);
        }
    }

    private static void renderTransparentBlock(WorldClient world, TileEntityEnlightenedBlock alpha, BlockPos pos, double x, double y, double z) {
        GlStateManager.pushMatrix();
        RenderHelper.disableStandardItemLighting();
        if (Minecraft.isAmbientOcclusionEnabled()) {
            GlStateManager.shadeModel(GL11.GL_SMOOTH);
        } else {
            GlStateManager.shadeModel(GL11.GL_FLAT);
        }
        GlStateManager.disableLighting();
        GlStateManager.enableCull();
        GlStateManager.enableBlend();
        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        GlStateManager.disableAlpha();
        GlStateManager.enableDepth();
        GlStateManager.depthMask(false);

        GlStateManager.translate(x - alpha.getPos().getX(), y - alpha.getPos().getY(), z - alpha.getPos().getZ());

        IBlockState originalBlockState = alpha.getOriginalBlockState();
        IBlockState blockState = world.getBlockState(pos);
        BlockRendererDispatcher renderer = Minecraft.getMinecraft().getBlockRendererDispatcher();
        IBakedModel model = renderer.getModelForState(originalBlockState);

        Tessellator tessellator = Tessellator.getInstance();
        tessellator.getBuffer().begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
        if (Minecraft.isAmbientOcclusionEnabled()) {
            renderer.getBlockModelRenderer().renderModelSmooth(world, model, blockState, pos, tessellator.getBuffer(), true, MathHelper.getPositionRandom(pos));
        } else {
            renderer.getBlockModelRenderer().renderModelFlat(world, model, blockState, pos, tessellator.getBuffer(), true, MathHelper.getPositionRandom(pos));
        }
        tessellator.draw();

        RenderHelper.enableStandardItemLighting();
        GlStateManager.popMatrix();

        GlStateManager.enableLighting();
        GlStateManager.disableCull();
        GlStateManager.disableBlend();
        GlStateManager.enableAlpha();
        GlStateManager.depthMask(true);
    }

 

Full source code is available on GitHub

You might want to look at how Blocks are rendered in RenderChunk#rebuildChunk

Hey, thanks for reply.
I looked into that method, but unfortunately I don't think I know what part of code you had in mind and for which issue. Can you elaborate?

That’s the vanilla code that renders all the blocks for a chunk, translucency works right for it so I was thinking you might want to compare your code to it

I finally solved the issue with block brightness. It turned out to be really easy fix. All I had to do was add two lines of code:

Minecraft.getMinecraft().entityRenderer.enableLightmap();
//Rest of rendering stuff here
Minecraft.getMinecraft().entityRenderer.disableLightmap();

 

I also changed the structure of the code to call the drawing method for the transparent blocks only once. Here's updated code:

    @SubscribeEvent
    public static void onRenderLastEvent(RenderWorldLastEvent event) {
        EntityPlayerSP player = Minecraft.getMinecraft().player;
        WorldClient world = Minecraft.getMinecraft().world;

        List<TileEntity> loadedTileEntityList = world.loadedTileEntityList;
        List<TileEntityEnlightenedBlock> alphas = loadedTileEntityList.stream()
                .filter(te -> te instanceof TileEntityEnlightenedBlock)
                .map(te -> (TileEntityEnlightenedBlock)te)
                .filter(te -> te.getOriginalBlockState().getBlock().getBlockLayer() == BlockRenderLayer.TRANSLUCENT)
                .collect(Collectors.toList());

        if (alphas.isEmpty()) {
            return;
        }

        final double partialTicks = (double)event.getPartialTicks();
        final double playerX = player.prevPosX + (player.posX - player.prevPosX) * partialTicks;
        final double playerY = player.prevPosY + (player.posY - player.prevPosY) * partialTicks;
        final double playerZ = player.prevPosZ + (player.posZ - player.prevPosZ) * partialTicks;

        for (TileEntityEnlightenedBlock alpha : alphas) {
            alpha.setDistanceToPlayer(alpha.getDistanceSq(playerX, playerY, playerZ));
        }
        alphas.sort(Comparator.comparingDouble(TileEntityEnlightenedBlock::getDistanceToPlayer).reversed());

        preRenderTransparentBlocks();

        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder buffer = tessellator.getBuffer();
        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);

        for (TileEntityEnlightenedBlock alpha : alphas) {
            BlockPos pos = alpha.getPos();
            final double x = (double)pos.getX() - playerX;
            final double y = (double)pos.getY() - playerY;
            final double z = (double)pos.getZ() - playerZ;

            renderTransparentBlock(world, alpha, pos, x, y, z, buffer);
        }
        buffer.setTranslation(0, 0, 0);
        tessellator.draw();

        postRenderTransparentBlocks();
    }

    private static void preRenderTransparentBlocks() {
        Minecraft.getMinecraft().entityRenderer.enableLightmap();
        GlStateManager.pushMatrix();
        if (Minecraft.isAmbientOcclusionEnabled()) {
            GlStateManager.shadeModel(GL11.GL_SMOOTH);
        } else {
            GlStateManager.shadeModel(GL11.GL_FLAT);
        }
        GlStateManager.disableLighting();
        GlStateManager.enableCull();
        GlStateManager.enableBlend();
        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        GlStateManager.disableAlpha();
        GlStateManager.enableDepth();
        GlStateManager.depthMask(false);
    }

    private static void renderTransparentBlock(WorldClient world, TileEntityEnlightenedBlock alpha, BlockPos pos, double x, double y, double z, BufferBuilder buffer) {

        buffer.setTranslation(x - pos.getX(), y - pos.getY(), z - pos.getZ());

        IBlockState originalBlockState = alpha.getOriginalBlockState();
        IBlockState blockState = world.getBlockState(pos);
        BlockRendererDispatcher renderer = Minecraft.getMinecraft().getBlockRendererDispatcher();
        IBakedModel model = renderer.getModelForState(originalBlockState);

        if (Minecraft.isAmbientOcclusionEnabled()) {
            renderer.getBlockModelRenderer().renderModelSmooth(world, model, blockState, pos, buffer, true, MathHelper.getPositionRandom(pos));
        } else {
            renderer.getBlockModelRenderer().renderModelFlat(world, model, blockState, pos, buffer, true, MathHelper.getPositionRandom(pos));
        }
    }

    private static void postRenderTransparentBlocks() {
        GlStateManager.popMatrix();
        GlStateManager.enableLighting();
        GlStateManager.disableCull();
        GlStateManager.disableBlend();
        GlStateManager.enableAlpha();
        GlStateManager.depthMask(true);
        Minecraft.getMinecraft().entityRenderer.disableLightmap();
    }

 

That being said, I think this topic can be considered solved. The only issue left is the issue with looking at my block through another transparent block, but as I said, this is not a big deal and I can live with that