net.minecraft.client.renderer.ActiveRenderInfo Java Examples

@Override
@SideOnly(Side.CLIENT)
public Vec3d getFogColor(World world, BlockPos pos, IBlockState state, Entity entity, Vec3d originalColor,
        float partialTicks) {
    if (!isWithinFluid(world, pos, ActiveRenderInfo.projectViewFromEntity(entity, partialTicks))) {
        BlockPos otherPos = pos.down(densityDir);
        IBlockState otherState = world.getBlockState(otherPos);
        return otherState.getBlock().getFogColor(world, otherPos, otherState, entity, originalColor, partialTicks);
    }

    if (getFluid() != null) {
        return new Vec3d(5.0F, 5.0F, 5.0F);
    }

    return super.getFogColor(world, pos, state, entity, originalColor, partialTicks);
}
 

public static void render(double x, double y, double z, Colour colour, double s, double u1, double v1, double u2, double v2)
{
    x-=EntityFX.interpPosX;
    y-=EntityFX.interpPosY;
    z-=EntityFX.interpPosZ;
    //TODO: check
    
    float par3 = ActiveRenderInfo.rotationX;
    float par4 = ActiveRenderInfo.rotationXZ;
    float par5 = ActiveRenderInfo.rotationZ;
    float par6 = ActiveRenderInfo.rotationYZ;
    float par7 = ActiveRenderInfo.rotationXY;
    
    Tessellator t = Tessellator.instance;
    t.setColorRGBA(colour.r&0xFF, colour.g&0xFF, colour.b&0xFF, colour.a&0xFF);
    t.addVertexWithUV((x - par3 * s - par6 * s), (y - par4 * s), (z - par5 * s - par7 * s), u2, v2);
    t.addVertexWithUV((x - par3 * s + par6 * s), (y + par4 * s), (z - par5 * s + par7 * s), u2, v1);
    t.addVertexWithUV((x + par3 * s + par6 * s), (y + par4 * s), (z + par5 * s + par7 * s), u1, v1);
    t.addVertexWithUV((x + par3 * s - par6 * s), (y - par4 * s), (z + par5 * s - par7 * s), u1, v2);
}
 

private void cleanActiveRenderInfo(ItemRenderType renderType) {
    renderInfo[0] = ActiveRenderInfo.rotationX;
    renderInfo[1] = ActiveRenderInfo.rotationXZ;
    renderInfo[2] = ActiveRenderInfo.rotationZ;
    renderInfo[3] = ActiveRenderInfo.rotationYZ;
    renderInfo[4] = ActiveRenderInfo.rotationXY;
    switch (renderType) {
        case ENTITY:
            break;
        case EQUIPPED:
            ActiveRenderInfo.rotationX = 0.85535365F;
            ActiveRenderInfo.rotationXZ = 0.9868404F;
            ActiveRenderInfo.rotationZ = -0.51804453F;
            ActiveRenderInfo.rotationYZ = 0.083717324F;
            ActiveRenderInfo.rotationXY = 0.13822734F;
            break;
        case EQUIPPED_FIRST_PERSON:
            ActiveRenderInfo.rotationX = -0.4186075F;
            ActiveRenderInfo.rotationXZ = 0.99932945F;
            ActiveRenderInfo.rotationZ = -0.90816724F;
            ActiveRenderInfo.rotationYZ = 0.033253096F;
            ActiveRenderInfo.rotationXY = -0.015327567F;
            break;
        case INVENTORY:
            ActiveRenderInfo.rotationX = -0.71445745F;
            ActiveRenderInfo.rotationXZ = 0.9573291F;
            ActiveRenderInfo.rotationZ = 0.69967884F;
            ActiveRenderInfo.rotationYZ = -0.20220716F;
            ActiveRenderInfo.rotationXY = -0.20647818F;
            break;
        case FIRST_PERSON_MAP:
            break;
    }
}
 

private void restoreActiveRenderInfo() {
    if(renderInfo[0] != -1) ActiveRenderInfo.rotationX = renderInfo[0];
    if(renderInfo[1] != -1) ActiveRenderInfo.rotationXZ = renderInfo[1];
    if(renderInfo[2] != -1) ActiveRenderInfo.rotationZ = renderInfo[2];
    if(renderInfo[3] != -1) ActiveRenderInfo.rotationYZ = renderInfo[3];
    if(renderInfo[4] != -1) ActiveRenderInfo.rotationXY = renderInfo[4];
    for (int i = 0; i < renderInfo.length; i++) {
        renderInfo[i] = -1;
    }
}
 

@SubscribeEvent
@SideOnly(Side.CLIENT)
public void fogColor(FogColors event) {


	IBlockState state = ActiveRenderInfo.getBlockStateAtEntityViewpoint(event.getEntity().world, event.getEntity(), (float)event.getRenderPartialTicks());

	Block block = state.getBlock();
	if(block.getMaterial(state) == Material.WATER)
		return;

	DimensionProperties properties = DimensionManager.getInstance().getDimensionProperties(event.getEntity().dimension);
	if(properties != null) {
		float fog = properties.getAtmosphereDensityAtHeight(event.getEntity().posY);

		if(event.getEntity().world.provider instanceof IPlanetaryProvider) {
			Vec3d color = event.getEntity().world.provider.getSkyColor(event.getEntity(), 0f);
			event.setRed((float) Math.min(color.x*1.4f,1f));
			event.setGreen((float) Math.min(color.y*1.4f, 1f));
			event.setBlue((float) Math.min(color.z*1.4f, 1f));
		}

		if(endTime > 0) {
			double amt = (endTime - Minecraft.getMinecraft().world.getTotalWorldTime()) / (double)duration;
			if(amt < 0) {
				endTime = 0;
			}
			else {
				event.setRed((float) amt);
				event.setGreen((float) amt);
				event.setBlue((float) amt);
			}

		} else {
			event.setRed(event.getRed()* fog);
			event.setGreen(event.getGreen()* fog);
			event.setBlue(event.getBlue()* fog);
		}
	}
}
 

public static Vec3d renderPos() {
	ActiveRenderInfo ren = mc.gameRenderer.getActiveRenderInfo();
	return ren.getProjectedView();
}
 

@Inject(method = "orientCamera", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/Vec3;distanceTo(Lnet/minecraft/util/Vec3;)D"), cancellable = true)
private void cameraClip(float partialTicks, CallbackInfo callbackInfo) {
    if (LiquidBounce.moduleManager.getModule(CameraClip.class).getState()) {
        callbackInfo.cancel();

        Entity entity = this.mc.getRenderViewEntity();
        float f = entity.getEyeHeight();

        if(entity instanceof EntityLivingBase && ((EntityLivingBase) entity).isPlayerSleeping()) {
            f = (float) ((double) f + 1D);
            GlStateManager.translate(0F, 0.3F, 0.0F);

            if(!this.mc.gameSettings.debugCamEnable) {
                BlockPos blockpos = new BlockPos(entity);
                IBlockState iblockstate = this.mc.theWorld.getBlockState(blockpos);
                net.minecraftforge.client.ForgeHooksClient.orientBedCamera(this.mc.theWorld, blockpos, iblockstate, entity);

                GlStateManager.rotate(entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * partialTicks + 180.0F, 0.0F, -1.0F, 0.0F);
                GlStateManager.rotate(entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * partialTicks, -1.0F, 0.0F, 0.0F);
            }
        }else if(this.mc.gameSettings.thirdPersonView > 0) {
            double d3 = (double) (this.thirdPersonDistanceTemp + (this.thirdPersonDistance - this.thirdPersonDistanceTemp) * partialTicks);

            if(this.mc.gameSettings.debugCamEnable) {
                GlStateManager.translate(0.0F, 0.0F, (float) (-d3));
            }else{
                float f1 = entity.rotationYaw;
                float f2 = entity.rotationPitch;

                if(this.mc.gameSettings.thirdPersonView == 2)
                    f2 += 180.0F;

                if(this.mc.gameSettings.thirdPersonView == 2)
                    GlStateManager.rotate(180.0F, 0.0F, 1.0F, 0.0F);

                GlStateManager.rotate(entity.rotationPitch - f2, 1.0F, 0.0F, 0.0F);
                GlStateManager.rotate(entity.rotationYaw - f1, 0.0F, 1.0F, 0.0F);
                GlStateManager.translate(0.0F, 0.0F, (float) (-d3));
                GlStateManager.rotate(f1 - entity.rotationYaw, 0.0F, 1.0F, 0.0F);
                GlStateManager.rotate(f2 - entity.rotationPitch, 1.0F, 0.0F, 0.0F);
            }
        }else
            GlStateManager.translate(0.0F, 0.0F, -0.1F);

        if(!this.mc.gameSettings.debugCamEnable) {
            float yaw = entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * partialTicks + 180.0F;
            float pitch = entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * partialTicks;
            float roll = 0.0F;
            if(entity instanceof EntityAnimal) {
                EntityAnimal entityanimal = (EntityAnimal) entity;
                yaw = entityanimal.prevRotationYawHead + (entityanimal.rotationYawHead - entityanimal.prevRotationYawHead) * partialTicks + 180.0F;
            }

            Block block = ActiveRenderInfo.getBlockAtEntityViewpoint(this.mc.theWorld, entity, partialTicks);
            net.minecraftforge.client.event.EntityViewRenderEvent.CameraSetup event = new net.minecraftforge.client.event.EntityViewRenderEvent.CameraSetup((EntityRenderer) (Object) this, entity, block, partialTicks, yaw, pitch, roll);
            net.minecraftforge.common.MinecraftForge.EVENT_BUS.post(event);
            GlStateManager.rotate(event.roll, 0.0F, 0.0F, 1.0F);
            GlStateManager.rotate(event.pitch, 1.0F, 0.0F, 0.0F);
            GlStateManager.rotate(event.yaw, 0.0F, 1.0F, 0.0F);
        }

        GlStateManager.translate(0.0F, -f, 0.0F);
        double d0 = entity.prevPosX + (entity.posX - entity.prevPosX) * (double) partialTicks;
        double d1 = entity.prevPosY + (entity.posY - entity.prevPosY) * (double) partialTicks + (double) f;
        double d2 = entity.prevPosZ + (entity.posZ - entity.prevPosZ) * (double) partialTicks;
        this.cloudFog = this.mc.renderGlobal.hasCloudFog(d0, d1, d2, partialTicks);
    }
}
 

@Override
public void renderParticle(IVertexBuilder builder, ActiveRenderInfo activeRenderInfo, float partialTicks) {
    super.renderParticle(builder, activeRenderInfo, partialTicks);
}
 

@Override
public void renderParticle(IVertexBuilder p_225606_1_, ActiveRenderInfo p_225606_2_, float p_225606_3_) {
    super.renderParticle(p_225606_1_, p_225606_2_, p_225606_3_);
}
 

/**
 * Convert 3D coord into 2D coordinate projected onto the screen
 */
public static Plane toScreen(double x, double y, double z) {
  Entity view = MC.getRenderViewEntity();
  
  if (view == null) {
    return new Plane(0.D, 0.D, false);
  }
  
  Vec3d camPos = FastReflection.Fields.ActiveRenderInfo_position.getStatic();
  Vec3d eyePos = ActiveRenderInfo.projectViewFromEntity(view, MC.getRenderPartialTicks());
  
  float vecX = (float) ((camPos.x + eyePos.x) - (float) x);
  float vecY = (float) ((camPos.y + eyePos.y) - (float) y);
  float vecZ = (float) ((camPos.z + eyePos.z) - (float) z);
  
  Vector4f pos = new Vector4f(vecX, vecY, vecZ, 1.f);
  
  modelMatrix.load(
      FastReflection.Fields.ActiveRenderInfo_MODELVIEW.getStatic().asReadOnlyBuffer());
  projectionMatrix.load(
      FastReflection.Fields.ActiveRenderInfo_PROJECTION.getStatic().asReadOnlyBuffer());
  
  VecTransformCoordinate(pos, modelMatrix);
  VecTransformCoordinate(pos, projectionMatrix);
  
  if (pos.w > 0.f) {
    pos.x *= -100000;
    pos.y *= -100000;
  } else {
    float invert = 1.f / pos.w;
    pos.x *= invert;
    pos.y *= invert;
  }
  
  ScaledResolution res = new ScaledResolution(MC);
  float halfWidth = (float) res.getScaledWidth() / 2.f;
  float halfHeight = (float) res.getScaledHeight() / 2.f;
  
  pos.x = halfWidth + (0.5f * pos.x * res.getScaledWidth() + 0.5f);
  pos.y = halfHeight - (0.5f * pos.y * res.getScaledHeight() + 0.5f);
  
  boolean bVisible = true;
  
  if (pos.x < 0 || pos.y < 0 || pos.x > res.getScaledWidth() || pos.y > res.getScaledHeight()) {
    bVisible = false;
  }
  
  return new Plane(pos.x, pos.y, bVisible);
}
 

public static void bufferHitbox(Matrix4 mat, IRenderTypeBuffer getter, ActiveRenderInfo renderInfo, Cuboid6 cuboid) {
    Vec3d projectedView = renderInfo.getProjectedView();
    bufferHitBox(mat.copy().translate(-projectedView.x, -projectedView.y, -projectedView.z), getter, cuboid);
}
 

public void renderParticles(EntityPlayer aPlayer, float pTicks) {
	float f = ActiveRenderInfo.getRotationX();
       float f1 = ActiveRenderInfo.getRotationZ();
       float f2 = ActiveRenderInfo.getRotationYZ();
       float f3 = ActiveRenderInfo.getRotationXY();
       float f4 = ActiveRenderInfo.getRotationXZ();
       EntityPlayer player = Minecraft.getMinecraft().player;
       if(player!=null) {
       	Particle.interpPosX = player.lastTickPosX + (player.posX - player.lastTickPosX) * pTicks;
        Particle.interpPosY = player.lastTickPosY + (player.posY - player.lastTickPosY) * pTicks;
        Particle.interpPosZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * pTicks;
        Particle.cameraViewDir = player.getLook(pTicks);
        GlStateManager.enableAlpha();
        GlStateManager.enableBlend();
        GlStateManager.alphaFunc(516, 0.003921569F);
           GlStateManager.disableCull();
           
           GlStateManager.depthMask(false);
           
           Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
		Tessellator tess = Tessellator.getInstance();
		VertexBuffer buffer = tess.getBuffer();
		
		GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.PARTICLE_POSITION_TEX_COLOR_LMAP);
			for(int i = 0; i < particles.size(); i ++) {
				if(!((ILP2Particle) particles.get(i)).isAdditive()) {
					particles.get(i).renderParticle(buffer, player, pTicks, f, f4, f1, f2, f3);
				}
			}
			tess.draw();
		
		GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE);
			buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.PARTICLE_POSITION_TEX_COLOR_LMAP);
			for(int i = 0; i < particles.size(); i ++) {
				if(((ILP2Particle) particles.get(i)).isAdditive()) {
					particles.get(i).renderParticle(buffer, player, pTicks, f, f4, f1, f2, f3);
				}
			}
			tess.draw();
		
		GlStateManager.enableCull();
           GlStateManager.depthMask(true);
        GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
        GlStateManager.disableBlend();
        GlStateManager.alphaFunc(516, 0.1F);
       }
}
 

private void render(Tessellator tessellator, float pTicks) {
    float arX = ActiveRenderInfo.rotationX;
    float arXZ = ActiveRenderInfo.rotationXZ;
    float arZ = ActiveRenderInfo.rotationZ;
    float arYZ = ActiveRenderInfo.rotationYZ;
    float arXY = ActiveRenderInfo.rotationXY;

    GL11.glPushMatrix();
    GL11.glAlphaFunc(GL11.GL_GREATER, 0.003921569F);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

    float agescale = (float) (ClientHandler.ticks % 800) / 400F;
    if(agescale >= 1.0F) agescale = 2 - agescale;
    float size = 0.2F + 0.1F * agescale;
    if(parent != null) {
        size += size * (((float) parent.getSizeStage()) * 0.04F);
    }

    float anglePerc = (float) (ClientHandler.ticks % 300) / 300F;
    float angle = RAD - RAD * anglePerc;

    Vector3 iV = MiscUtils.interpolateEntityPosition(Minecraft.getMinecraft().renderViewEntity, pTicks);
    if(parent != null && parent.getSizeStage() > 4) {
        float mult = 0.001F * (parent.getSizeStage() - 4F);
        Vector3 shake = new Vector3(
                RAND.nextFloat() * mult * (RAND.nextBoolean() ? 1 : -1),
                RAND.nextFloat() * mult * (RAND.nextBoolean() ? 1 : -1),
                RAND.nextFloat() * mult * (RAND.nextBoolean() ? 1 : -1));
        iV.add(shake);
    }

    GL11.glTranslated(-iV.getX(), -iV.getY(), -iV.getZ());

    UtilsFX.bindTexture(TC_VORTEX_TEXTURE);

    tessellator.startDrawingQuads();
    tessellator.setBrightness(220);
    tessellator.setColorRGBA_F(1F, 1F, 1F, 1F);

    Vec3 v1 = Vec3.createVectorHelper(-arX * size - arYZ * size, -arXZ * size, -arZ * size - arXY * size);
    Vec3 v2 = Vec3.createVectorHelper(-arX * size + arYZ * size, arXZ * size, -arZ * size + arXY * size);
    Vec3 v3 = Vec3.createVectorHelper(arX * size + arYZ * size, arXZ * size, arZ * size + arXY * size);
    Vec3 v4 = Vec3.createVectorHelper(arX * size - arYZ * size, -arXZ * size, arZ * size - arXY * size);
    if (angle != 0.0F) {
        Vec3 pvec = Vec3.createVectorHelper(iV.getX(), iV.getY(), iV.getZ());
        Vec3 tvec = Vec3.createVectorHelper(x, y, z);
        Vec3 qvec = pvec.subtract(tvec).normalize();
        QuadHelper.setAxis(qvec, angle).rotate(v1);
        QuadHelper.setAxis(qvec, angle).rotate(v2);
        QuadHelper.setAxis(qvec, angle).rotate(v3);
        QuadHelper.setAxis(qvec, angle).rotate(v4);
    }
    tessellator.setNormal(0.0F, 0.0F, -1.0F);
    tessellator.addVertexWithUV(x + v1.xCoord, y + v1.yCoord, z + v1.zCoord, 0, 1);
    tessellator.addVertexWithUV(x + v2.xCoord, y + v2.yCoord, z + v2.zCoord, 1, 1);
    tessellator.addVertexWithUV(x + v3.xCoord, y + v3.yCoord, z + v3.zCoord, 1, 0);
    tessellator.addVertexWithUV(x + v4.xCoord, y + v4.yCoord, z + v4.zCoord, 0, 0);
    tessellator.draw();

    GL11.glDisable(GL11.GL_BLEND);
    GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
    GL11.glPopMatrix();
}
 

public void render(double posX, double posY, double posZ, float frame, double playerX, double playerY, double playerZ, TextureManager r)
{
    if(r == null)return;
    GL11.glDisable(GL11.GL_LIGHTING);
    Random random = new Random(31100L);
    for(int i = 0; i < 16; i++)
    {
        GL11.glPushMatrix();
        float f5 = 16 - i;
        float f6 = 0.0625F;
        float f7 = 1.0F / (f5 + 1.0F);
        if(i == 0)
        {
            r.bindTexture(end_skyTex);
            f7 = 0.1F;
            f5 = 65F;
            f6 = 0.125F;
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(770, 771);
        }
        if(i == 1)
        {
            r.bindTexture(end_portalTex);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(1, 1);
            f6 = 0.5F;
        }
        float f8 = (float)(-(posY + surfaceY));
        float f9 = f8 + ActiveRenderInfo.objectY;
        float f10 = f8 + f5 + ActiveRenderInfo.objectY;
        float f11 = f9 / f10;
        f11 = (float)(posY + surfaceY) + f11;
        GL11.glTranslated(playerX, f11, playerZ);
        GL11.glTexGeni(GL11.GL_S, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
        GL11.glTexGeni(GL11.GL_T, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
        GL11.glTexGeni(GL11.GL_R, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
        GL11.glTexGeni(GL11.GL_Q, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_EYE_LINEAR);
        GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, func_40447_a(1.0F, 0.0F, 0.0F, 0.0F));
        GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, func_40447_a(0.0F, 0.0F, 1.0F, 0.0F));
        GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, func_40447_a(0.0F, 0.0F, 0.0F, 1.0F));
        GL11.glTexGen(GL11.GL_Q, GL11.GL_EYE_PLANE, func_40447_a(0.0F, 1.0F, 0.0F, 0.0F));
        GL11.glEnable(GL11.GL_TEXTURE_GEN_S);
        GL11.glEnable(GL11.GL_TEXTURE_GEN_T);
        GL11.glEnable(GL11.GL_TEXTURE_GEN_R);
        GL11.glEnable(GL11.GL_TEXTURE_GEN_Q);
        GL11.glPopMatrix();
        GL11.glMatrixMode(GL11.GL_TEXTURE);
        GL11.glPushMatrix();
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, System.currentTimeMillis() % 0xaae60L / 700000F, 0.0F);
        GL11.glScalef(f6, f6, f6);
        GL11.glTranslatef(0.5F, 0.5F, 0.0F);
        GL11.glRotatef((i * i * 4321 + i * 9) * 2.0F, 0.0F, 0.0F, 1.0F);
        GL11.glTranslatef(-0.5F, -0.5F, 0.0F);
        GL11.glTranslated(-playerX, -playerZ, -playerY);
        f9 = f8 + ActiveRenderInfo.objectY;
        GL11.glTranslated((ActiveRenderInfo.objectX * f5) / f9, (ActiveRenderInfo.objectZ * f5) / f9, -playerY + 20);
        Tessellator tessellator = Tessellator.instance;
        tessellator.startDrawingQuads();
        f11 = random.nextFloat() * 0.5F + 0.1F;
        float f12 = random.nextFloat() * 0.5F + 0.4F;
        float f13 = random.nextFloat() * 0.5F + 0.5F;
        if(i == 0)
        {
            f11 = f12 = f13 = 1.0F;
        }
        tessellator.setColorRGBA_F(f11 * f7, f12 * f7, f13 * f7, 1.0F);
        
        tessellator.addVertex(posX + surfaceX1, posY + surfaceY, posZ + surfaceZ1);
        tessellator.addVertex(posX + surfaceX1, posY + surfaceY, posZ + surfaceZ2);
        tessellator.addVertex(posX + surfaceX2, posY + surfaceY, posZ + surfaceZ2);
        tessellator.addVertex(posX + surfaceX2, posY + surfaceY, posZ + surfaceZ1);
        
        tessellator.draw();
        GL11.glPopMatrix();
        GL11.glMatrixMode(ARBVertexBlend.GL_MODELVIEW0_ARB);
    }

    GL11.glDisable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_TEXTURE_GEN_S);
    GL11.glDisable(GL11.GL_TEXTURE_GEN_T);
    GL11.glDisable(GL11.GL_TEXTURE_GEN_R);
    GL11.glDisable(GL11.GL_TEXTURE_GEN_Q);
    GL11.glEnable(GL11.GL_LIGHTING);
}