Jump to content

Translating WorldRenderer startDRawingQuads to 1.12


fuzzybat23

Recommended Posts

I have an old mod that use to apply a mask to blocks the cursor is aimed at, instead of just drawing the outlined bounding box.  See attached picture for to get the idea of what I'm trying to explain.  Anyhoo, this is how the bounding box is actually drawn in 1.12;

 

    public static void drawSelectionBoundingBox(AxisAlignedBB box, float red, float green, float blue, float alpha)
    {
        drawBoundingBox(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, red, green, blue, alpha);
    }

    public static void drawBoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder bufferbuilder = tessellator.getBuffer();
        bufferbuilder.begin(3, DefaultVertexFormats.POSITION_COLOR);
        drawBoundingBox(bufferbuilder, minX, minY, minZ, maxX, maxY, maxZ, red, green, blue, alpha);
        tessellator.draw();
    }

    public static void drawBoundingBox(BufferBuilder buffer, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        buffer.pos(minX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, minZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
    }

 

And this is the old way this was drawn back in 1.8, I believe:

 

	private static void drawBlinkingBlock(AxisAlignedBB par1AxisAlignedBB, float alpha) {
		Tessellator tessellator = Tessellator.getInstance();

		if (alpha > 0.0F) {
			if (getBlinkSpeed() > 0 && CSB.breakAnimation != ALPHA)
				alpha *= (float) Math.abs(Math.sin(Minecraft.getSystemTime() / 100.0D * getBlinkSpeed()));

			GL11.glColor4f(getRed(), getGreen(), getBlue(), alpha);
			renderDown(par1AxisAlignedBB);
			renderUp(par1AxisAlignedBB);
			renderNorth(par1AxisAlignedBB);
			renderSouth(par1AxisAlignedBB);
			renderWest(par1AxisAlignedBB);
			renderEast(par1AxisAlignedBB);
		}
	}

	public static void renderUp(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		tessellator.draw();
	}

	public static void renderDown(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);

		tessellator.draw();
	}

	public static void renderNorth(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		tessellator.draw();
	}

	public static void renderSouth(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		tessellator.draw();
	}

	public static void renderWest(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		tessellator.draw();
	}

	public static void renderEast(AxisAlignedBB par1AxisAlignedBB) {
		Tessellator tessellator = Tessellator.getInstance();
		WorldRenderer worldrenderer = tessellator.getWorldRenderer();

		worldrenderer.startDrawingQuads();
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
		worldrenderer.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
		tessellator.draw();
	}

 

getBlinkSpeed(), getRed(), getGreen(), and getBlue() are calls to retrieve the float values from a config file.  For this post, assume Blink Speed is 0, Red is 1.0F, Green is 0.0F and Blue is 0.0F, basically meaning I'm trying to achieve what is in the picture, only with a solid red bounding box and the inside mask has an alpha value of  0.5F 

Capture.JPG

Link to comment
Share on other sites

8 minutes ago, fuzzybat23 said:

WorldRenderer

-> BufferBuilder

 

8 minutes ago, fuzzybat23 said:

startDrawingQuads

-> begin(7, %FORMAT%). The format can be obtained at DefaultVertexFormats and the names are pretty descriptive.

 

8 minutes ago, fuzzybat23 said:

addVertex

-> pos/color/lightmap/tex/whatever based on the format + endVertex() at the end. The order of the elements(pos/color/etc) matters and the name of the format chosen shows the order. Your vanilla example shows that pretty well.

 

draw is still draw.

All other logic should be pretty much the same. You might need to play around with vertex ordering though.

Link to comment
Share on other sites

BLOCK is a format designed for drawing blocks, hence the name. Do you need to render a block? No, you need to render a colored cube. POSITION_COLOR will suffice. You would need to disable texture2d using GlStateManager before drawing with that one though as you are not using any texture.

Edited by V0idWa1k3r
Link to comment
Share on other sites

Ok, I already have texture2d disabled in the function that ultimately calls my drawboundingbox function. 

 

        	if(disableDepthBuffer) {
        		GL11.glDisable(GL11.GL_DEPTH_TEST);
        	}
        	
            GlStateManager.enableBlend();
            GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);
            GlStateManager.glLineWidth(2.0F);
    		GlStateManager.disableTexture2D();
            GlStateManager.depthMask(false);

 

How do I use this POSITION_COLOR now?  I'm still learning this stuff as I go.  I know I've seen position_Color somewhere recently, but for the life of me I can't remember where.

Link to comment
Share on other sites

It's funny, just as your thing blipped up a reply, I glanced up and saw this already in my code for drawing the bounding box.

 

        bufferbuilder.begin(3, DefaultVertexFormats.POSITION_COLOR);

 

So to start, I'd want something similar.

 

public static void whatever(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
{
	Tessellator t = Tessellator.getInstance();
	BufferBuilder b = t.getBuffer();
	b.begin(7, DefaultVertexFormats.POSITION_COLOR);

	drawMask(bufferbuilder, minX, minY, minZ, maxX, maxY, maxZ, red, green, blue, alpha);
	t.draw();
}

    public static void drawMask(BufferBuilder buffer, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        buffer.pos(minX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(minX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, maxY, minZ).color(red, green, blue, 0.0F).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        buffer.pos(maxX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
    }

 

Is that about right?

Link to comment
Share on other sites

Considering that the ordering of the vertices was taken from vanilla's rendering that uses an entirely different GL mode(3 - LINE_STRIP) as opposed to the one you are using(7 - QUADS) - that will most likely not work. Or it will produce a very weird result. Even the number of vertices is incorrect as each quad requires 4 vertices and the vertices you've posted are only enough for 4.5 quads which isn't right.

If you mean the general usage and syntax - sure.

Edited by V0idWa1k3r
Link to comment
Share on other sites

Ok, making progress ;D  It's working, to a degree.  But with a weird result, probably due to my poor grasp of vertices xD

 

This:

 

    public static void drawSelectionBoxMask(AxisAlignedBB box, float red, float green, float blue, float alpha)
    {
        drawMask(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, red, green, blue, alpha);
    }

    public static void drawMask(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder bufferbuilder = tessellator.getBuffer();
        bufferbuilder.begin(7, DefaultVertexFormats.POSITION_COLOR);
        drawMask(bufferbuilder, minX, minY, minZ, maxX, maxY, maxZ, red, green, blue, alpha);
        tessellator.draw();
    }

	public static void drawMask(BufferBuilder b, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
    	//up
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
	
		//down
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		
		//north
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		
		//south
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		
		//east
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		
		//west
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
    }
    

 

ends up spitting out something that looks like this:

2017-07-03_19.05.14.png

Link to comment
Share on other sites

Just out of idle curiosity, now, you don't happen to know how to make it draw that box when you're underwater, do you? xD  Looking at a block that's in the water, but while your head is above water, draws the bounding box, but when you're completely submerged you get nothing at all.  Makes underwater construction so much a bother x.x

Link to comment
Share on other sites

If you are using DrawBlockHighlightEvent then your problem lies in the fact that the event is not called at all if the entity is in water, I think that is a vanilla thing. You could switch to using a different event but that means more work for you as you will have to raytrace the block on your own and apply the correct translations.

Edited by V0idWa1k3r
Link to comment
Share on other sites

Ugh, that sounds like a pain in the ass.  Shame too, cause the original code, as it was written for 1.8, did draw the box underwater.  It called the DrawBlockHighlightEvent as well, I think.   Guess they changed that somewhere between 1.8 and now.

Link to comment
Share on other sites

I had an idea on that actually.  The debug screen.  Part of the debug screen is that line that tells you the coordinates of the block you're looking at.  Those coordinates are all this mod really needs to function, right?  So how does the game get the coordinates that are put up on the debug screen?

Link to comment
Share on other sites

Somewhere in it's loop it raytraces the block you are looking at. I'm not quite near my pc atm so I can't tell you exactly where. You can do the same using World::rayTraceBlocks. You would still need to offset everything properly before rendering though.

Link to comment
Share on other sites

What about this?

 

BlockPos blockpos1 = this.mc.objectMouseOver.getBlockPos();

Found it in the gui that governs the debug screen here:

            if (this.mc.objectMouseOver != null && this.mc.objectMouseOver.typeOfHit == RayTraceResult.Type.BLOCK && this.mc.objectMouseOver.getBlockPos() != null)
            {
                BlockPos blockpos1 = this.mc.objectMouseOver.getBlockPos();
                list.add(String.format("Looking at: %d %d %d", blockpos1.getX(), blockpos1.getY(), blockpos1.getZ()));
            }

 

Link to comment
Share on other sites

Meh, I just looked through the  entire list of events the eventhandler uses.  I don't see anything that could remotely be useful to this other than DrawBlockHighlightEvent, since that is very specific to what I'm doing xD  I'll have to settle with no underwater fanciness until Mojang adds the selection box to underwater viewing.  They could at least make it something that can be turned on and off from the settings xD

 

Link to comment
Share on other sites

This ended up being the new code that seems to work, though not underwater.  Did I declare mc correctly as Private Final Minecraft mc = Minecraft.getMinecraft();?

 

package com.fuzzybat23.test1;

import com.fuzzybat23.test1.proxy.CommonProxy;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Queues;
import com.google.common.collect.Sets;
import com.google.gson.JsonSyntaxException;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import javax.annotation.Nullable;
import net.minecraft.block.Block;
import net.minecraft.block.BlockChest;
import net.minecraft.block.BlockEnderChest;
import net.minecraft.block.BlockSign;
import net.minecraft.block.BlockSkull;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.audio.ISound;
import net.minecraft.client.audio.PositionedSoundRecord;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.client.particle.Particle;
import net.minecraft.client.renderer.ActiveRenderInfo;
import net.minecraft.client.renderer.BlockRendererDispatcher;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.DestroyBlockProgress;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.chunk.ChunkRenderDispatcher;
import net.minecraft.client.renderer.chunk.CompiledChunk;
import net.minecraft.client.renderer.chunk.IRenderChunkFactory;
import net.minecraft.client.renderer.chunk.ListChunkFactory;
import net.minecraft.client.renderer.chunk.RenderChunk;
import net.minecraft.client.renderer.chunk.VboChunkFactory;
import net.minecraft.client.renderer.chunk.VisGraph;
import net.minecraft.client.renderer.culling.ClippingHelper;
import net.minecraft.client.renderer.culling.ClippingHelperImpl;
import net.minecraft.client.renderer.culling.Frustum;
import net.minecraft.client.renderer.culling.ICamera;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.renderer.vertex.VertexBuffer;
import net.minecraft.client.renderer.vertex.VertexFormat;
import net.minecraft.client.renderer.vertex.VertexFormatElement;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.client.resources.IResourceManagerReloadListener;
import net.minecraft.client.shader.Framebuffer;
import net.minecraft.client.shader.ShaderGroup;
import net.minecraft.client.shader.ShaderLinkHelper;
import net.minecraft.crash.CrashReport;
import net.minecraft.crash.CrashReportCategory;
import net.minecraft.crash.ICrashReportDetail;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.init.SoundEvents;
import net.minecraft.item.Item;
import net.minecraft.item.ItemDye;
import net.minecraft.item.ItemRecord;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraft.util.BlockRenderLayer;
import net.minecraft.util.ClassInheritanceMultiMap;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.ReportedException;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.IWorldEventListener;
import net.minecraft.world.World;
import net.minecraft.world.border.WorldBorder;
import net.minecraft.world.chunk.Chunk;
import net.minecraftforge.client.event.DrawBlockHighlightEvent;
import net.minecraftforge.client.event.MouseEvent;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.Mod.Instance;
import net.minecraftforge.fml.common.SidedProxy;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;
import org.lwjgl.util.vector.Vector4f;

@Mod(modid=Reference.Mod_ID, name=Reference.NAME, version=Reference.VERSION, acceptedMinecraftVersions=Reference.ACCEPTED_VERSIONS)
public class CSBR {
	
	//public class RenderGlobal implements IWorldEventListener, IResourceManagerReloadListener {
	
    private static final Logger LOGGER = LogManager.getLogger();
    private final Minecraft mc = Minecraft.getMinecraft();
    
    float r = 0.0F;		//red
    float g = 0.0F;		//green
    float b = 0.0F;		//blue
    float a = 0.0F;		//alpha
    float ba = 0.10F;	//blink alpha
    float w = 2.0F;		//Line Width
    public static boolean disableDepthBuffer;
    public static VertexFormat BLOCK = new VertexFormat();
    
	@Instance
	public static CSBR instance;

	@SidedProxy(clientSide = Reference.CLIENT_PROXY_CLASS, serverSide = Reference.CLIENT_SERVER_CLASS)
	public static CommonProxy proxy;
	
	@EventHandler
	public void preInit(FMLPreInitializationEvent event)
	{
		proxy.registerTickHandler();
		MinecraftForge.EVENT_BUS.register(this);
		
		r = 1.0F;
		a = 0.30F;
		ba = 0.05F;
		w = 4.0F;
		disableDepthBuffer=false;
	}
	
	@EventHandler
	public void Init(FMLInitializationEvent event)
	{
	
	}

	@EventHandler
	public void PostInit(FMLPostInitializationEvent event)
	{
	
	}
	
	@SubscribeEvent
	public void onDrawBlockSelectionBox(DrawBlockHighlightEvent e) {
		drawSelectionBox(e.getPlayer(), e.getTarget(), e.getSubID(), e.getPartialTicks());
		e.setCanceled(true);
	}
	
    /**
     * Draws the selection box for the player.
     */
    public void drawSelectionBox(EntityPlayer player, RayTraceResult movingObjectPositionIn, int execute, float partialTicks)
    {

        if (execute == 0 && movingObjectPositionIn.typeOfHit == RayTraceResult.Type.BLOCK)
        {

        	if(disableDepthBuffer) {
        		GL11.glDisable(GL11.GL_DEPTH_TEST);
        	}
        	
            GlStateManager.enableBlend();
            GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO);
            GlStateManager.glLineWidth(w);
    		GlStateManager.disableTexture2D();
            GlStateManager.depthMask(false);

            if (this.mc.objectMouseOver != null && this.mc.objectMouseOver.typeOfHit == RayTraceResult.Type.BLOCK && this.mc.objectMouseOver.getBlockPos() != null )

            {
            	BlockPos blockpos1 = this.mc.objectMouseOver.getBlockPos();
            	
             // BlockPos blockpos = movingObjectPositionIn.getBlockPos();
                IBlockState iblockstate = player.getEntityWorld().getBlockState(blockpos1); 
            
            		
          //  if (iblockstate.getMaterial() != Material.AIR && player.getEntityWorld().getWorldBorder().contains(blockpos))
          //  {
                double d0 = player.lastTickPosX + (player.posX - player.lastTickPosX) * (double)partialTicks;
                double d1 = player.lastTickPosY + (player.posY - player.lastTickPosY) * (double)partialTicks;
                double d2 = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * (double)partialTicks;
                AxisAlignedBB bb = iblockstate.getSelectedBoundingBox(player.getEntityWorld(), blockpos1).grow(0.0020000000949949026D).offset(-d0, -d1, -d2);
              
                
                //Draw Boxes
                drawSelectionBoxMask(bb, r, g, b, ba);
                
                drawSelectionBoundingBox(bb, r, g, b, a);
            }


            GL11.glEnable(GL11.GL_DEPTH_TEST);
            GlStateManager.depthMask(true);
            GlStateManager.enableTexture2D();
            GlStateManager.disableBlend();
        }
    }

    public static void drawSelectionBoundingBox(AxisAlignedBB box, float red, float green, float blue, float alpha)
    {
        drawBoundingBox(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, red, green, blue, alpha);
    }
    
    public static void drawSelectionBoxMask(AxisAlignedBB box, float red, float green, float blue, float alpha)
    {
        drawMask(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, red, green, blue, alpha);
    }
    
    public static void drawBoundingBox(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        Tessellator t = Tessellator.getInstance();
        BufferBuilder b = t.getBuffer();
        b.begin(3, DefaultVertexFormats.POSITION_COLOR);
        drawBoundingBox(b, minX, minY, minZ, maxX, maxY, maxZ, red, green, blue, alpha);
        t.draw();
    }
    
    public static void drawMask(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        Tessellator t = Tessellator.getInstance();
        BufferBuilder b = t.getBuffer();
        b.begin(7, DefaultVertexFormats.POSITION_COLOR);
        drawMask(b, minX, minY, minZ, maxX, maxY, maxZ, red, green, blue, alpha);
        t.draw();
    }

    public static void drawBoundingBox(BufferBuilder b, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
        b.pos(minX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
        b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(minX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, maxY, maxZ).color(red, green, blue, 0.0F).endVertex();
        b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, maxY, minZ).color(red, green, blue, 0.0F).endVertex();
        b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
        b.pos(maxX, minY, minZ).color(red, green, blue, 0.0F).endVertex();
    }
        
    public static void drawMask(BufferBuilder b, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, float red, float green, float blue, float alpha)
    {
    	//up
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		//b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
	
		//down
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		//b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		
		//north
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		//b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		
		//south
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		//b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		
		//east
		b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(maxX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		//b.pos(maxX, minY, minZ).color(red, green, blue, alpha).endVertex();
		
		//west
		b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, minY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, maxZ).color(red, green, blue, alpha).endVertex();
		b.pos(minX, maxY, minZ).color(red, green, blue, alpha).endVertex();
		//b.pos(minX, minY, minZ).color(red, green, blue, alpha).endVertex();
    }
    
}

 

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.