[1.7.10] Rendering (fake) Blocks in world for visual guides

[Wiggles]

Hello. I am trying to create visual block placement guides for building and schematics.

I'm not entirely sure how i should be rendering something like this, I'm wondering if I'm on the right track or if i should be trying an entirely different approach.

 

Currently I've been trying to utilize the RenderBlock.renderBlockByRenderType(); method.

The problem with that however is that I can't figure out how to render the blocks with metadata for that method.

 

Here are some examples of what I've got working so far.

The top is a debug of the target block being rendered as desired, through alpha blending etc.

On the bottom being highlighted is where the blocks would render when finished for a placement guide.

 

Right now I've been using an event for the rendering, here is the full test code

I would be passing a coordinate, and block information through this.

@SubscribeEvent
    public void Block_Render(RenderWorldLastEvent evt){
       
        Minecraft mc = Minecraft.getMinecraft();
          MovingObjectPosition mouseOver = Minecraft.getMinecraft().objectMouseOver;

            int mx = mouseOver.blockX;
            int my = mouseOver.blockY;
            int mz = mouseOver.blockZ;
           
            int hit;
            hit = mouseOver.sideHit;
            ForgeDirection direction = ForgeDirection.getOrientation(hit);
           
          World world = mc.thePlayer.worldObj;
          EntityPlayer player = mc.thePlayer;
          EntityClientPlayerMP p= mc.thePlayer;
            ChunkCoordinates coord;
            coord = player.getPlayerCoordinates();
           
            int px = (int) coord.posX;
            int py = (int) player.posY-1;
            int pz = (int) coord.posZ;
           
            double dx = p.lastTickPosX + (p.posX - p.lastTickPosX)
                    * evt.partialTicks;
            double dy = p.lastTickPosY + (p.posY - p.lastTickPosY)
                    * evt.partialTicks;
            dy = dy -1;
            double dz = p.lastTickPosZ + (p.posZ - p.lastTickPosZ)
                    * evt.partialTicks;
           
            int tx = mx - px;
            int ty = my - py;
            int tz = mz - pz;
         
           
            Coordinate translate;
            translate= new Coordinate(tx, ty, tz).add(direction);
           
            Block block = world.getBlock(x, y, z);
            Material matt;
            matt = block.getMaterial();
           
            ItemStack stack;
            stack = player.getHeldItem();
            Item held = null;
            if(stack != null)
            held = stack.getItem();        

            if (block == Blocks.air || matt == Material.fire
                    || matt == Material.water || matt == Material.lava
                    || matt == Material.plants || matt == Material.vine
                    || block == Blocks.snow_layer) {
               
                translate= new Coordinate(tx, ty, tz);
            }
            else translate= new Coordinate(tx, ty, tz).add(direction);
           
            tx = translate.getX();
            ty =translate.getY();
            tz =translate.getZ();
            double fx = px - dx;
            double fy = py - dy;
            double fz = pz - dz;

          //Block block3 = Common_Registry.Floater;
         // Block block4 = Common_Registry.Balloon;         
          Block block2 = world.getBlock(20, 20, 20);
                  
           GL11.glPushMatrix();  
           GL11.glEnable(GL11.GL_BLEND);
           GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        Tessellator t = Tessellator.instance;
        RenderBlocks renderBlocks = new RenderBlocks();
        renderBlocks.blockAccess = world;
       
        renderBlocks.setRenderBounds(0D, 0D, 0D, 1D, 1D, 1D);
        t.startDrawingQuads();
        t.setBrightness(15 << 20 | 15 << 4);
       
        try{
            if(block != Blocks.air){
            renderBlocks.renderBlockByRenderType(block2, 0, -11, 0);           
            }          
           
        GL11.glTranslated( 0F, 10f, 0F);       
        GL11.glTranslated( tx, ty, tz);
        GL11.glTranslated( fx, fy, fz);
        }
          catch(NullPointerException exception){
              System.out.println(exception);
          }
        t.draw();              
       
        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_BLEND);
        GL11.glPopMatrix();       
    }

 

 

Here I believe the vanilla method passes to another method and looks for a real block in the world to extract the metadata and thereon lies the problem with that.

public boolean renderBlockLog(Block p_147742_1_, int p_147742_2_, int p_147742_3_, int p_147742_4_)
    {
        int l = this.blockAccess.getBlockMetadata(p_147742_2_, p_147742_3_, p_147742_4_);
        int i1 = l & 12;

        if (i1 == 4)
        {
            this.uvRotateEast = 1;
            this.uvRotateWest = 1;
            this.uvRotateTop = 1;
            this.uvRotateBottom = 1;
        }
        else if (i1 == 
        {
            this.uvRotateSouth = 1;
            this.uvRotateNorth = 1;
        }

        boolean flag = this.renderStandardBlock(p_147742_1_, p_147742_2_, p_147742_3_, p_147742_4_);
        this.uvRotateSouth = 0;
        this.uvRotateEast = 0;
        this.uvRotateWest = 0;
        this.uvRotateNorth = 0;
        this.uvRotateTop = 0;
        this.uvRotateBottom = 0;
        return flag;
    }