Examples with Icon net.minecraft.util.Icon used on opensource projects

Search in sources :

Example 6 with Icon

use of net.minecraft.util.Icon in project MineFactoryReloaded by powercrystals.

the class RenderBlocksInverted method func_102027_b.

public boolean func_102027_b(RenderBlocks renderer, Block par1Block, int par2, int par3, int par4, float par5, float par6, float par7) {
    renderer.enableAO = true;
    boolean flag = false;
    float f3 = 0.0F;
    float f4 = 0.0F;
    float f5 = 0.0F;
    float f6 = 0.0F;
    boolean flag1 = true;
    int l = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4);
    Tessellator tessellator = Tessellator.instance;
    tessellator.setBrightness(983055);
    if (renderer.getBlockIcon(par1Block).getIconName().equals("grass_top")) {
        flag1 = false;
    } else if (renderer.hasOverrideBlockTexture()) {
        flag1 = false;
    }
    boolean flag2;
    boolean flag3;
    boolean flag4;
    boolean flag5;
    float f7;
    int i1;
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2, par3 - 1, par4, 0)) {
        if (renderer.renderMinY <= 0.0D) {
            --par3;
        }
        renderer.aoBrightnessXYNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoBrightnessYZNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoBrightnessYZNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoBrightnessXYPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoLightValueScratchXYNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoLightValueScratchYZNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoLightValueScratchYZNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoLightValueScratchXYPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3 - 1, par4)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3 - 1, par4)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 - 1, par4 + 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 - 1, par4 - 1)];
        if (!flag4 && !flag2) {
            renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXYNN;
            renderer.aoBrightnessXYZNNN = renderer.aoBrightnessXYNN;
        } else {
            renderer.aoLightValueScratchXYZNNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4 - 1);
            renderer.aoBrightnessXYZNNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4 - 1);
        }
        if (!flag5 && !flag2) {
            renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXYNN;
            renderer.aoBrightnessXYZNNP = renderer.aoBrightnessXYNN;
        } else {
            renderer.aoLightValueScratchXYZNNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4 + 1);
            renderer.aoBrightnessXYZNNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4 + 1);
        }
        if (!flag4 && !flag3) {
            renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXYPN;
            renderer.aoBrightnessXYZPNN = renderer.aoBrightnessXYPN;
        } else {
            renderer.aoLightValueScratchXYZPNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4 - 1);
            renderer.aoBrightnessXYZPNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4 - 1);
        }
        if (!flag5 && !flag3) {
            renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXYPN;
            renderer.aoBrightnessXYZPNP = renderer.aoBrightnessXYPN;
        } else {
            renderer.aoLightValueScratchXYZPNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4 + 1);
            renderer.aoBrightnessXYZPNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4 + 1);
        }
        if (renderer.renderMinY <= 0.0D) {
            ++par3;
        }
        i1 = l;
        if (renderer.renderMinY <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(par2, par3 - 1, par4)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4);
        f3 = (renderer.aoLightValueScratchXYZNNP + renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchYZNP + f7) / 4.0F;
        f6 = (renderer.aoLightValueScratchYZNP + f7 + renderer.aoLightValueScratchXYZPNP + renderer.aoLightValueScratchXYPN) / 4.0F;
        f5 = (f7 + renderer.aoLightValueScratchYZNN + renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXYZPNN) / 4.0F;
        f4 = (renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXYZNNN + f7 + renderer.aoLightValueScratchYZNN) / 4.0F;
        renderer.brightnessTopLeft = renderer.getAoBrightness(renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXYNN, renderer.aoBrightnessYZNP, i1);
        renderer.brightnessTopRight = renderer.getAoBrightness(renderer.aoBrightnessYZNP, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXYPN, i1);
        renderer.brightnessBottomRight = renderer.getAoBrightness(renderer.aoBrightnessYZNN, renderer.aoBrightnessXYPN, renderer.aoBrightnessXYZPNN, i1);
        renderer.brightnessBottomLeft = renderer.getAoBrightness(renderer.aoBrightnessXYNN, renderer.aoBrightnessXYZNNN, renderer.aoBrightnessYZNN, i1);
        if (flag1) {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5 * 0.5F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6 * 0.5F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7 * 0.5F;
        } else {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.5F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.5F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.5F;
        }
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        this.renderBottomFace(renderer, par1Block, par2, par3, par4, renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 0));
        flag = true;
    }
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2, par3 + 1, par4, 1)) {
        if (renderer.renderMaxY >= 1.0D) {
            ++par3;
        }
        renderer.aoBrightnessXYNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoBrightnessXYPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoBrightnessYZPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoBrightnessYZPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoLightValueScratchXYNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoLightValueScratchXYPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoLightValueScratchYZPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoLightValueScratchYZPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 + 1);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3 + 1, par4)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3 + 1, par4)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 + 1, par4 + 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 + 1, par4 - 1)];
        if (!flag4 && !flag2) {
            renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXYNP;
            renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXYNP;
        } else {
            renderer.aoLightValueScratchXYZNPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4 - 1);
            renderer.aoBrightnessXYZNPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4 - 1);
        }
        if (!flag4 && !flag3) {
            renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXYPP;
            renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXYPP;
        } else {
            renderer.aoLightValueScratchXYZPPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4 - 1);
            renderer.aoBrightnessXYZPPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4 - 1);
        }
        if (!flag5 && !flag2) {
            renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXYNP;
            renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXYNP;
        } else {
            renderer.aoLightValueScratchXYZNPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4 + 1);
            renderer.aoBrightnessXYZNPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4 + 1);
        }
        if (!flag5 && !flag3) {
            renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXYPP;
            renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXYPP;
        } else {
            renderer.aoLightValueScratchXYZPPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4 + 1);
            renderer.aoBrightnessXYZPPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4 + 1);
        }
        if (renderer.renderMaxY >= 1.0D) {
            --par3;
        }
        i1 = l;
        if (renderer.renderMaxY >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(par2, par3 + 1, par4)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4);
        f6 = (renderer.aoLightValueScratchXYZNPP + renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchYZPP + f7) / 4.0F;
        f3 = (renderer.aoLightValueScratchYZPP + f7 + renderer.aoLightValueScratchXYZPPP + renderer.aoLightValueScratchXYPP) / 4.0F;
        f4 = (f7 + renderer.aoLightValueScratchYZPN + renderer.aoLightValueScratchXYPP + renderer.aoLightValueScratchXYZPPN) / 4.0F;
        f5 = (renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchXYZNPN + f7 + renderer.aoLightValueScratchYZPN) / 4.0F;
        renderer.brightnessTopRight = renderer.getAoBrightness(renderer.aoBrightnessXYZNPP, renderer.aoBrightnessXYNP, renderer.aoBrightnessYZPP, i1);
        renderer.brightnessTopLeft = renderer.getAoBrightness(renderer.aoBrightnessYZPP, renderer.aoBrightnessXYZPPP, renderer.aoBrightnessXYPP, i1);
        renderer.brightnessBottomLeft = renderer.getAoBrightness(renderer.aoBrightnessYZPN, renderer.aoBrightnessXYPP, renderer.aoBrightnessXYZPPN, i1);
        renderer.brightnessBottomRight = renderer.getAoBrightness(renderer.aoBrightnessXYNP, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessYZPN, i1);
        renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5;
        renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6;
        renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7;
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        this.renderTopFace(renderer, par1Block, par2, par3, par4, renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 1));
        flag = true;
    }
    float f8;
    float f9;
    float f10;
    float f11;
    int j1;
    int k1;
    int l1;
    int i2;
    Icon icon;
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2, par3, par4 - 1, 2)) {
        if (renderer.renderMinZ <= 0.0D) {
            --par4;
        }
        renderer.aoLightValueScratchXZNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoLightValueScratchYZNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoLightValueScratchYZPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4);
        renderer.aoLightValueScratchXZPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoBrightnessXZNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoBrightnessYZNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoBrightnessYZPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4);
        renderer.aoBrightnessXZPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3, par4 - 1)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3, par4 - 1)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 + 1, par4 - 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 - 1, par4 - 1)];
        if (!flag2 && !flag4) {
            renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXZNN;
            renderer.aoBrightnessXYZNNN = renderer.aoBrightnessXZNN;
        } else {
            renderer.aoLightValueScratchXYZNNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3 - 1, par4);
            renderer.aoBrightnessXYZNNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3 - 1, par4);
        }
        if (!flag2 && !flag5) {
            renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXZNN;
            renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXZNN;
        } else {
            renderer.aoLightValueScratchXYZNPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3 + 1, par4);
            renderer.aoBrightnessXYZNPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3 + 1, par4);
        }
        if (!flag3 && !flag4) {
            renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXZPN;
            renderer.aoBrightnessXYZPNN = renderer.aoBrightnessXZPN;
        } else {
            renderer.aoLightValueScratchXYZPNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3 - 1, par4);
            renderer.aoBrightnessXYZPNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3 - 1, par4);
        }
        if (!flag3 && !flag5) {
            renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXZPN;
            renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXZPN;
        } else {
            renderer.aoLightValueScratchXYZPPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3 + 1, par4);
            renderer.aoBrightnessXYZPPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3 + 1, par4);
        }
        if (renderer.renderMinZ <= 0.0D) {
            ++par4;
        }
        i1 = l;
        if (renderer.renderMinZ <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(par2, par3, par4 - 1)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 - 1);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 - 1);
        f9 = (renderer.aoLightValueScratchXZNN + renderer.aoLightValueScratchXYZNPN + f7 + renderer.aoLightValueScratchYZPN) / 4.0F;
        f8 = (f7 + renderer.aoLightValueScratchYZPN + renderer.aoLightValueScratchXZPN + renderer.aoLightValueScratchXYZPPN) / 4.0F;
        f11 = (renderer.aoLightValueScratchYZNN + f7 + renderer.aoLightValueScratchXYZPNN + renderer.aoLightValueScratchXZPN) / 4.0F;
        f10 = (renderer.aoLightValueScratchXYZNNN + renderer.aoLightValueScratchXZNN + renderer.aoLightValueScratchYZNN + f7) / 4.0F;
        f3 = (float) (f9 * renderer.renderMaxY * (1.0D - renderer.renderMinX) + f8 * renderer.renderMinY * renderer.renderMinX + f11 * (1.0D - renderer.renderMaxY) * renderer.renderMinX + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX));
        f4 = (float) (f9 * renderer.renderMaxY * (1.0D - renderer.renderMaxX) + f8 * renderer.renderMaxY * renderer.renderMaxX + f11 * (1.0D - renderer.renderMaxY) * renderer.renderMaxX + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX));
        f5 = (float) (f9 * renderer.renderMinY * (1.0D - renderer.renderMaxX) + f8 * renderer.renderMinY * renderer.renderMaxX + f11 * (1.0D - renderer.renderMinY) * renderer.renderMaxX + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX));
        f6 = (float) (f9 * renderer.renderMinY * (1.0D - renderer.renderMinX) + f8 * renderer.renderMinY * renderer.renderMinX + f11 * (1.0D - renderer.renderMinY) * renderer.renderMinX + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX));
        k1 = renderer.getAoBrightness(renderer.aoBrightnessXZNN, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessYZPN, i1);
        j1 = renderer.getAoBrightness(renderer.aoBrightnessYZPN, renderer.aoBrightnessXZPN, renderer.aoBrightnessXYZPPN, i1);
        i2 = renderer.getAoBrightness(renderer.aoBrightnessYZNN, renderer.aoBrightnessXYZPNN, renderer.aoBrightnessXZPN, i1);
        l1 = renderer.getAoBrightness(renderer.aoBrightnessXYZNNN, renderer.aoBrightnessXZNN, renderer.aoBrightnessYZNN, i1);
        renderer.brightnessTopLeft = renderer.mixAoBrightness(k1, j1, i2, l1, renderer.renderMaxY * (1.0D - renderer.renderMinX), renderer.renderMaxY * renderer.renderMinX, (1.0D - renderer.renderMaxY) * renderer.renderMinX, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX));
        renderer.brightnessBottomLeft = renderer.mixAoBrightness(k1, j1, i2, l1, renderer.renderMaxY * (1.0D - renderer.renderMaxX), renderer.renderMaxY * renderer.renderMaxX, (1.0D - renderer.renderMaxY) * renderer.renderMaxX, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX));
        renderer.brightnessBottomRight = renderer.mixAoBrightness(k1, j1, i2, l1, renderer.renderMinY * (1.0D - renderer.renderMaxX), renderer.renderMinY * renderer.renderMaxX, (1.0D - renderer.renderMinY) * renderer.renderMaxX, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX));
        renderer.brightnessTopRight = renderer.mixAoBrightness(k1, j1, i2, l1, renderer.renderMinY * (1.0D - renderer.renderMinX), renderer.renderMinY * renderer.renderMinX, (1.0D - renderer.renderMinY) * renderer.renderMinX, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX));
        if (flag1) {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5 * 0.8F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6 * 0.8F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7 * 0.8F;
        } else {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.8F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.8F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.8F;
        }
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        icon = renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 2);
        this.renderEastFace(renderer, par1Block, par2, par3, par4, icon);
        if (RenderBlocks.fancyGrass && icon.getIconName().equals("grass_side") && !renderer.hasOverrideBlockTexture()) {
            renderer.colorRedTopLeft *= par5;
            renderer.colorRedBottomLeft *= par5;
            renderer.colorRedBottomRight *= par5;
            renderer.colorRedTopRight *= par5;
            renderer.colorGreenTopLeft *= par6;
            renderer.colorGreenBottomLeft *= par6;
            renderer.colorGreenBottomRight *= par6;
            renderer.colorGreenTopRight *= par6;
            renderer.colorBlueTopLeft *= par7;
            renderer.colorBlueBottomLeft *= par7;
            renderer.colorBlueBottomRight *= par7;
            renderer.colorBlueTopRight *= par7;
            this.renderEastFace(renderer, par1Block, par2, par3, par4, BlockGrass.getIconSideOverlay());
        }
        flag = true;
    }
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2, par3, par4 + 1, 3)) {
        if (renderer.renderMaxZ >= 1.0D) {
            ++par4;
        }
        renderer.aoLightValueScratchXZNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoLightValueScratchXZPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoLightValueScratchYZNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoLightValueScratchYZPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4);
        renderer.aoBrightnessXZNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4);
        renderer.aoBrightnessXZPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4);
        renderer.aoBrightnessYZNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoBrightnessYZPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3, par4 + 1)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3, par4 + 1)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 + 1, par4 + 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2, par3 - 1, par4 + 1)];
        if (!flag2 && !flag4) {
            renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXZNP;
            renderer.aoBrightnessXYZNNP = renderer.aoBrightnessXZNP;
        } else {
            renderer.aoLightValueScratchXYZNNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3 - 1, par4);
            renderer.aoBrightnessXYZNNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3 - 1, par4);
        }
        if (!flag2 && !flag5) {
            renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXZNP;
            renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXZNP;
        } else {
            renderer.aoLightValueScratchXYZNPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3 + 1, par4);
            renderer.aoBrightnessXYZNPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3 + 1, par4);
        }
        if (!flag3 && !flag4) {
            renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXZPP;
            renderer.aoBrightnessXYZPNP = renderer.aoBrightnessXZPP;
        } else {
            renderer.aoLightValueScratchXYZPNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3 - 1, par4);
            renderer.aoBrightnessXYZPNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3 - 1, par4);
        }
        if (!flag3 && !flag5) {
            renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXZPP;
            renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXZPP;
        } else {
            renderer.aoLightValueScratchXYZPPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3 + 1, par4);
            renderer.aoBrightnessXYZPPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3 + 1, par4);
        }
        if (renderer.renderMaxZ >= 1.0D) {
            --par4;
        }
        i1 = l;
        if (renderer.renderMaxZ >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(par2, par3, par4 + 1)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 + 1);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 + 1);
        f9 = (renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchXYZNPP + f7 + renderer.aoLightValueScratchYZPP) / 4.0F;
        f8 = (f7 + renderer.aoLightValueScratchYZPP + renderer.aoLightValueScratchXZPP + renderer.aoLightValueScratchXYZPPP) / 4.0F;
        f11 = (renderer.aoLightValueScratchYZNP + f7 + renderer.aoLightValueScratchXYZPNP + renderer.aoLightValueScratchXZPP) / 4.0F;
        f10 = (renderer.aoLightValueScratchXYZNNP + renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchYZNP + f7) / 4.0F;
        f3 = (float) (f9 * renderer.renderMaxY * (1.0D - renderer.renderMinX) + f8 * renderer.renderMaxY * renderer.renderMinX + f11 * (1.0D - renderer.renderMaxY) * renderer.renderMinX + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX));
        f4 = (float) (f9 * renderer.renderMinY * (1.0D - renderer.renderMinX) + f8 * renderer.renderMinY * renderer.renderMinX + f11 * (1.0D - renderer.renderMinY) * renderer.renderMinX + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX));
        f5 = (float) (f9 * renderer.renderMinY * (1.0D - renderer.renderMaxX) + f8 * renderer.renderMinY * renderer.renderMaxX + f11 * (1.0D - renderer.renderMinY) * renderer.renderMaxX + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX));
        f6 = (float) (f9 * renderer.renderMaxY * (1.0D - renderer.renderMaxX) + f8 * renderer.renderMaxY * renderer.renderMaxX + f11 * (1.0D - renderer.renderMaxY) * renderer.renderMaxX + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX));
        k1 = renderer.getAoBrightness(renderer.aoBrightnessXZNP, renderer.aoBrightnessXYZNPP, renderer.aoBrightnessYZPP, i1);
        j1 = renderer.getAoBrightness(renderer.aoBrightnessYZPP, renderer.aoBrightnessXZPP, renderer.aoBrightnessXYZPPP, i1);
        i2 = renderer.getAoBrightness(renderer.aoBrightnessYZNP, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXZPP, i1);
        l1 = renderer.getAoBrightness(renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXZNP, renderer.aoBrightnessYZNP, i1);
        renderer.brightnessTopLeft = renderer.mixAoBrightness(k1, l1, i2, j1, renderer.renderMaxY * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMaxY) * renderer.renderMinX, renderer.renderMaxY * renderer.renderMinX);
        renderer.brightnessBottomLeft = renderer.mixAoBrightness(k1, l1, i2, j1, renderer.renderMinY * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMinY) * renderer.renderMinX, renderer.renderMinY * renderer.renderMinX);
        renderer.brightnessBottomRight = renderer.mixAoBrightness(k1, l1, i2, j1, renderer.renderMinY * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMinY) * renderer.renderMaxX, renderer.renderMinY * renderer.renderMaxX);
        renderer.brightnessTopRight = renderer.mixAoBrightness(k1, l1, i2, j1, renderer.renderMaxY * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMaxY) * renderer.renderMaxX, renderer.renderMaxY * renderer.renderMaxX);
        if (flag1) {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5 * 0.8F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6 * 0.8F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7 * 0.8F;
        } else {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.8F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.8F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.8F;
        }
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        icon = renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 3);
        this.renderWestFace(renderer, par1Block, par2, par3, par4, renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 3));
        if (RenderBlocks.fancyGrass && icon.getIconName().equals("grass_side") && !renderer.hasOverrideBlockTexture()) {
            renderer.colorRedTopLeft *= par5;
            renderer.colorRedBottomLeft *= par5;
            renderer.colorRedBottomRight *= par5;
            renderer.colorRedTopRight *= par5;
            renderer.colorGreenTopLeft *= par6;
            renderer.colorGreenBottomLeft *= par6;
            renderer.colorGreenBottomRight *= par6;
            renderer.colorGreenTopRight *= par6;
            renderer.colorBlueTopLeft *= par7;
            renderer.colorBlueBottomLeft *= par7;
            renderer.colorBlueBottomRight *= par7;
            renderer.colorBlueTopRight *= par7;
            this.renderWestFace(renderer, par1Block, par2, par3, par4, BlockGrass.getIconSideOverlay());
        }
        flag = true;
    }
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2 - 1, par3, par4, 4)) {
        if (renderer.renderMinX <= 0.0D) {
            --par2;
        }
        renderer.aoLightValueScratchXYNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoLightValueScratchXZNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoLightValueScratchXZNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoLightValueScratchXYNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4);
        renderer.aoBrightnessXYNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoBrightnessXZNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoBrightnessXZNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoBrightnessXYNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3 + 1, par4)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3 - 1, par4)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3, par4 - 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 - 1, par3, par4 + 1)];
        if (!flag5 && !flag2) {
            renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXZNN;
            renderer.aoBrightnessXYZNNN = renderer.aoBrightnessXZNN;
        } else {
            renderer.aoLightValueScratchXYZNNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4 - 1);
            renderer.aoBrightnessXYZNNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4 - 1);
        }
        if (!flag4 && !flag2) {
            renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXZNP;
            renderer.aoBrightnessXYZNNP = renderer.aoBrightnessXZNP;
        } else {
            renderer.aoLightValueScratchXYZNNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4 + 1);
            renderer.aoBrightnessXYZNNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4 + 1);
        }
        if (!flag5 && !flag3) {
            renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXZNN;
            renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXZNN;
        } else {
            renderer.aoLightValueScratchXYZNPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4 - 1);
            renderer.aoBrightnessXYZNPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4 - 1);
        }
        if (!flag4 && !flag3) {
            renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXZNP;
            renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXZNP;
        } else {
            renderer.aoLightValueScratchXYZNPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4 + 1);
            renderer.aoBrightnessXYZNPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4 + 1);
        }
        if (renderer.renderMinX <= 0.0D) {
            ++par2;
        }
        i1 = l;
        if (renderer.renderMinX <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(par2 - 1, par3, par4)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 - 1, par3, par4);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 - 1, par3, par4);
        f9 = (renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXYZNNP + f7 + renderer.aoLightValueScratchXZNP) / 4.0F;
        f8 = (f7 + renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchXYZNPP) / 4.0F;
        f11 = (renderer.aoLightValueScratchXZNN + f7 + renderer.aoLightValueScratchXYZNPN + renderer.aoLightValueScratchXYNP) / 4.0F;
        f10 = (renderer.aoLightValueScratchXYZNNN + renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXZNN + f7) / 4.0F;
        f3 = (float) (f8 * renderer.renderMaxY * renderer.renderMaxZ + f11 * renderer.renderMaxY * (1.0D - renderer.renderMaxZ) + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ) + f9 * (1.0D - renderer.renderMaxY) * renderer.renderMaxZ);
        f4 = (float) (f8 * renderer.renderMaxY * renderer.renderMinZ + f11 * renderer.renderMaxY * (1.0D - renderer.renderMinZ) + f10 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ) + f9 * (1.0D - renderer.renderMaxY) * renderer.renderMinZ);
        f5 = (float) (f8 * renderer.renderMinY * renderer.renderMinZ + f11 * renderer.renderMinY * (1.0D - renderer.renderMinZ) + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ) + f9 * (1.0D - renderer.renderMinY) * renderer.renderMinZ);
        f6 = (float) (f8 * renderer.renderMinY * renderer.renderMaxZ + f11 * renderer.renderMinY * (1.0D - renderer.renderMaxZ) + f10 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ) + f9 * (1.0D - renderer.renderMinY) * renderer.renderMaxZ);
        k1 = renderer.getAoBrightness(renderer.aoBrightnessXYNN, renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXZNP, i1);
        j1 = renderer.getAoBrightness(renderer.aoBrightnessXZNP, renderer.aoBrightnessXYNP, renderer.aoBrightnessXYZNPP, i1);
        i2 = renderer.getAoBrightness(renderer.aoBrightnessXZNN, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessXYNP, i1);
        l1 = renderer.getAoBrightness(renderer.aoBrightnessXYZNNN, renderer.aoBrightnessXYNN, renderer.aoBrightnessXZNN, i1);
        renderer.brightnessTopLeft = renderer.mixAoBrightness(j1, i2, l1, k1, renderer.renderMaxY * renderer.renderMaxZ, renderer.renderMaxY * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxY) * renderer.renderMaxZ);
        renderer.brightnessBottomLeft = renderer.mixAoBrightness(j1, i2, l1, k1, renderer.renderMaxY * renderer.renderMinZ, renderer.renderMaxY * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxY) * renderer.renderMinZ);
        renderer.brightnessBottomRight = renderer.mixAoBrightness(j1, i2, l1, k1, renderer.renderMinY * renderer.renderMinZ, renderer.renderMinY * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinY) * renderer.renderMinZ);
        renderer.brightnessTopRight = renderer.mixAoBrightness(j1, i2, l1, k1, renderer.renderMinY * renderer.renderMaxZ, renderer.renderMinY * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinY) * renderer.renderMaxZ);
        if (flag1) {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5 * 0.6F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6 * 0.6F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7 * 0.6F;
        } else {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.6F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.6F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.6F;
        }
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        icon = renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 4);
        this.renderNorthFace(renderer, par1Block, par2, par3, par4, icon);
        if (RenderBlocks.fancyGrass && icon.getIconName().equals("grass_side") && !renderer.hasOverrideBlockTexture()) {
            renderer.colorRedTopLeft *= par5;
            renderer.colorRedBottomLeft *= par5;
            renderer.colorRedBottomRight *= par5;
            renderer.colorRedTopRight *= par5;
            renderer.colorGreenTopLeft *= par6;
            renderer.colorGreenBottomLeft *= par6;
            renderer.colorGreenBottomRight *= par6;
            renderer.colorGreenTopRight *= par6;
            renderer.colorBlueTopLeft *= par7;
            renderer.colorBlueBottomLeft *= par7;
            renderer.colorBlueBottomRight *= par7;
            renderer.colorBlueTopRight *= par7;
            this.renderNorthFace(renderer, par1Block, par2, par3, par4, BlockGrass.getIconSideOverlay());
        }
        flag = true;
    }
    if (renderer.renderAllFaces || par1Block.shouldSideBeRendered(renderer.blockAccess, par2 + 1, par3, par4, 5)) {
        if (renderer.renderMaxX >= 1.0D) {
            ++par2;
        }
        renderer.aoLightValueScratchXYPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoLightValueScratchXZPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoLightValueScratchXZPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoLightValueScratchXYPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4);
        renderer.aoBrightnessXYPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4);
        renderer.aoBrightnessXZPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 - 1);
        renderer.aoBrightnessXZPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3, par4 + 1);
        renderer.aoBrightnessXYPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4);
        flag3 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3 + 1, par4)];
        flag2 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3 - 1, par4)];
        flag5 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3, par4 + 1)];
        flag4 = Block.canBlockGrass[renderer.blockAccess.getBlockId(par2 + 1, par3, par4 - 1)];
        if (!flag2 && !flag4) {
            renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXZPN;
            renderer.aoBrightnessXYZPNN = renderer.aoBrightnessXZPN;
        } else {
            renderer.aoLightValueScratchXYZPNN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4 - 1);
            renderer.aoBrightnessXYZPNN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4 - 1);
        }
        if (!flag2 && !flag5) {
            renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXZPP;
            renderer.aoBrightnessXYZPNP = renderer.aoBrightnessXZPP;
        } else {
            renderer.aoLightValueScratchXYZPNP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 - 1, par4 + 1);
            renderer.aoBrightnessXYZPNP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 - 1, par4 + 1);
        }
        if (!flag3 && !flag4) {
            renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXZPN;
            renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXZPN;
        } else {
            renderer.aoLightValueScratchXYZPPN = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4 - 1);
            renderer.aoBrightnessXYZPPN = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4 - 1);
        }
        if (!flag3 && !flag5) {
            renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXZPP;
            renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXZPP;
        } else {
            renderer.aoLightValueScratchXYZPPP = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2, par3 + 1, par4 + 1);
            renderer.aoBrightnessXYZPPP = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2, par3 + 1, par4 + 1);
        }
        if (renderer.renderMaxX >= 1.0D) {
            --par2;
        }
        i1 = l;
        if (renderer.renderMaxX >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(par2 + 1, par3, par4)) {
            i1 = par1Block.getMixedBrightnessForBlock(renderer.blockAccess, par2 + 1, par3, par4);
        }
        f7 = par1Block.getAmbientOcclusionLightValue(renderer.blockAccess, par2 + 1, par3, par4);
        f9 = (renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXYZPNP + f7 + renderer.aoLightValueScratchXZPP) / 4.0F;
        f8 = (renderer.aoLightValueScratchXYZPNN + renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXZPN + f7) / 4.0F;
        f11 = (renderer.aoLightValueScratchXZPN + f7 + renderer.aoLightValueScratchXYZPPN + renderer.aoLightValueScratchXYPP) / 4.0F;
        f10 = (f7 + renderer.aoLightValueScratchXZPP + renderer.aoLightValueScratchXYPP + renderer.aoLightValueScratchXYZPPP) / 4.0F;
        f3 = (float) (f9 * (1.0D - renderer.renderMinY) * renderer.renderMaxZ + f8 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ) + f11 * renderer.renderMinY * (1.0D - renderer.renderMaxZ) + f10 * renderer.renderMinY * renderer.renderMaxZ);
        f4 = (float) (f9 * (1.0D - renderer.renderMinY) * renderer.renderMinZ + f8 * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ) + f11 * renderer.renderMinY * (1.0D - renderer.renderMinZ) + f10 * renderer.renderMinY * renderer.renderMinZ);
        f5 = (float) (f9 * (1.0D - renderer.renderMaxY) * renderer.renderMinZ + f8 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ) + f11 * renderer.renderMaxY * (1.0D - renderer.renderMinZ) + f10 * renderer.renderMaxY * renderer.renderMinZ);
        f6 = (float) (f9 * (1.0D - renderer.renderMaxY) * renderer.renderMaxZ + f8 * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ) + f11 * renderer.renderMaxY * (1.0D - renderer.renderMaxZ) + f10 * renderer.renderMaxY * renderer.renderMaxZ);
        k1 = renderer.getAoBrightness(renderer.aoBrightnessXYPN, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXZPP, i1);
        j1 = renderer.getAoBrightness(renderer.aoBrightnessXZPP, renderer.aoBrightnessXYPP, renderer.aoBrightnessXYZPPP, i1);
        i2 = renderer.getAoBrightness(renderer.aoBrightnessXZPN, renderer.aoBrightnessXYZPPN, renderer.aoBrightnessXYPP, i1);
        l1 = renderer.getAoBrightness(renderer.aoBrightnessXYZPNN, renderer.aoBrightnessXYPN, renderer.aoBrightnessXZPN, i1);
        renderer.brightnessTopLeft = renderer.mixAoBrightness(k1, l1, i2, j1, (1.0D - renderer.renderMinY) * renderer.renderMaxZ, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ), renderer.renderMinY * (1.0D - renderer.renderMaxZ), renderer.renderMinY * renderer.renderMaxZ);
        renderer.brightnessBottomLeft = renderer.mixAoBrightness(k1, l1, i2, j1, (1.0D - renderer.renderMinY) * renderer.renderMinZ, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ), renderer.renderMinY * (1.0D - renderer.renderMinZ), renderer.renderMinY * renderer.renderMinZ);
        renderer.brightnessBottomRight = renderer.mixAoBrightness(k1, l1, i2, j1, (1.0D - renderer.renderMaxY) * renderer.renderMinZ, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ), renderer.renderMaxY * (1.0D - renderer.renderMinZ), renderer.renderMaxY * renderer.renderMinZ);
        renderer.brightnessTopRight = renderer.mixAoBrightness(k1, l1, i2, j1, (1.0D - renderer.renderMaxY) * renderer.renderMaxZ, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ), renderer.renderMaxY * (1.0D - renderer.renderMaxZ), renderer.renderMaxY * renderer.renderMaxZ);
        if (flag1) {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = par5 * 0.6F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = par6 * 0.6F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = par7 * 0.6F;
        } else {
            renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.6F;
            renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.6F;
            renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.6F;
        }
        renderer.colorRedTopLeft *= f3;
        renderer.colorGreenTopLeft *= f3;
        renderer.colorBlueTopLeft *= f3;
        renderer.colorRedBottomLeft *= f4;
        renderer.colorGreenBottomLeft *= f4;
        renderer.colorBlueBottomLeft *= f4;
        renderer.colorRedBottomRight *= f5;
        renderer.colorGreenBottomRight *= f5;
        renderer.colorBlueBottomRight *= f5;
        renderer.colorRedTopRight *= f6;
        renderer.colorGreenTopRight *= f6;
        renderer.colorBlueTopRight *= f6;
        icon = renderer.getBlockIcon(par1Block, renderer.blockAccess, par2, par3, par4, 5);
        this.renderSouthFace(renderer, par1Block, par2, par3, par4, icon);
        if (RenderBlocks.fancyGrass && icon.getIconName().equals("grass_side") && !renderer.hasOverrideBlockTexture()) {
            renderer.colorRedTopLeft *= par5;
            renderer.colorRedBottomLeft *= par5;
            renderer.colorRedBottomRight *= par5;
            renderer.colorRedTopRight *= par5;
            renderer.colorGreenTopLeft *= par6;
            renderer.colorGreenBottomLeft *= par6;
            renderer.colorGreenBottomRight *= par6;
            renderer.colorGreenTopRight *= par6;
            renderer.colorBlueTopLeft *= par7;
            renderer.colorBlueBottomLeft *= par7;
            renderer.colorBlueBottomRight *= par7;
            renderer.colorBlueTopRight *= par7;
            this.renderSouthFace(renderer, par1Block, par2, par3, par4, BlockGrass.getIconSideOverlay());
        }
        flag = true;
    }
    renderer.enableAO = false;
    return flag;
}
Also used : Tessellator(net.minecraft.client.renderer.Tessellator) Icon(net.minecraft.util.Icon)

Example 7 with Icon

use of net.minecraft.util.Icon in project MineFactoryReloaded by powercrystals.

the class ConveyorRenderer method renderConveyorWorld.

private void renderConveyorWorld(RenderBlocks renderblocks, IBlockAccess iblockaccess, int blockX, int blockY, int blockZ, Block block, int renderId) {
    Tessellator tessellator = Tessellator.instance;
    int conveyorMetadata = iblockaccess.getBlockMetadata(blockX, blockY, blockZ);
    Icon conveyorTexture = renderblocks.overrideBlockTexture != null ? renderblocks.overrideBlockTexture : block.getBlockTexture(iblockaccess, blockX, blockY, blockZ, 0);
    tessellator.setBrightness(block.getMixedBrightnessForBlock(iblockaccess, blockX, blockY, blockZ));
    tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
    double uStart = conveyorTexture.getInterpolatedU(0);
    double uEnd = conveyorTexture.getInterpolatedU(16);
    double vStart = conveyorTexture.getInterpolatedV(0);
    double vEnd = conveyorTexture.getInterpolatedV(16);
    float renderHeight = 0.00625F;
    float vert1x = blockX + 1;
    float vert2x = blockX + 1;
    float vert3x = blockX + 0;
    float vert4x = blockX + 0;
    float vert1z = blockZ + 0;
    float vert2z = blockZ + 1;
    float vert3z = blockZ + 1;
    float vert4z = blockZ + 0;
    float vert1y = blockY + renderHeight;
    float vert2y = blockY + renderHeight;
    float vert3y = blockY + renderHeight;
    float vert4y = blockY + renderHeight;
    if (conveyorMetadata == 0 || conveyorMetadata == 4 || conveyorMetadata == 8) {
        vert1x = vert4x = blockX + 0;
        vert2x = vert3x = blockX + 1;
        vert1z = vert2z = blockZ + 0;
        vert3z = vert4z = blockZ + 1;
        if (conveyorMetadata == 4) {
            // 1,0
            vert2y++;
            // 1,1
            vert3y++;
        }
        if (conveyorMetadata == 8) {
            vert1y++;
            vert4y++;
        }
    } else if (conveyorMetadata == 1 || conveyorMetadata == 5 || conveyorMetadata == 9) {
        vert1x = vert2x = blockX + 1;
        vert3x = vert4x = blockX + 0;
        vert1z = vert4z = blockZ + 0;
        vert2z = vert3z = blockZ + 1;
        if (conveyorMetadata == 5) {
            // 0,1
            vert3y++;
            // 1,1
            vert2y++;
        }
        if (conveyorMetadata == 9) {
            vert1y++;
            vert4y++;
        }
    } else if (conveyorMetadata == 2 || conveyorMetadata == 6 || conveyorMetadata == 10) {
        vert1x = vert4x = blockX + 1;
        vert2x = vert3x = blockX + 0;
        vert1z = vert2z = blockZ + 1;
        vert3z = vert4z = blockZ + 0;
        if (conveyorMetadata == 6) {
            vert2y++;
            vert3y++;
        }
        if (conveyorMetadata == 10) {
            // 1,0
            vert4y++;
            // 1,1
            vert1y++;
        }
    } else if (conveyorMetadata == 3 || conveyorMetadata == 7 || conveyorMetadata == 11) {
        vert1x = vert2x = blockX + 0;
        vert3x = vert4x = blockX + 1;
        vert1z = vert4z = blockZ + 1;
        vert2z = vert3z = blockZ + 0;
        if (conveyorMetadata == 7) {
            vert2y++;
            vert3y++;
        }
        if (conveyorMetadata == 11) {
            // 0,1
            vert1y++;
            // 1,1
            vert4y++;
        }
    }
    tessellator.addVertexWithUV(vert1x, vert1y, vert1z, uEnd, vStart);
    tessellator.addVertexWithUV(vert2x, vert2y, vert2z, uEnd, vEnd);
    tessellator.addVertexWithUV(vert3x, vert3y, vert3z, uStart, vEnd);
    tessellator.addVertexWithUV(vert4x, vert4y, vert4z, uStart, vStart);
    tessellator.addVertexWithUV(vert4x, vert4y, vert4z, uStart, vStart);
    tessellator.addVertexWithUV(vert3x, vert3y, vert3z, uStart, vEnd);
    tessellator.addVertexWithUV(vert2x, vert2y, vert2z, uEnd, vEnd);
    tessellator.addVertexWithUV(vert1x, vert1y, vert1z, uEnd, vStart);
}
Also used : Tessellator(net.minecraft.client.renderer.Tessellator) Icon(net.minecraft.util.Icon)

Example 8 with Icon

use of net.minecraft.util.Icon in project MineFactoryReloaded by powercrystals.

the class FactoryGlassRenderer method renderInventoryBlock.

@Override
public void renderInventoryBlock(Block tile, int metadata, int modelID, RenderBlocks renderer) {
    BlockFactoryGlass block = (BlockFactoryGlass) tile;
    Tessellator tessellator = Tessellator.instance;
    int color = block.getRenderColor(metadata);
    float red = (color >> 16 & 255) / 255.0F;
    float green = (color >> 8 & 255) / 255.0F;
    float blue = (color & 255) / 255.0F;
    if (EntityRenderer.anaglyphEnable) {
        float anaglyphRed = (red * 30.0F + green * 59.0F + blue * 11.0F) / 100.0F;
        float anaglyphGreen = (red * 30.0F + green * 70.0F) / 100.0F;
        float anaglyphBlue = (red * 30.0F + blue * 70.0F) / 100.0F;
        red = anaglyphRed;
        green = anaglyphGreen;
        blue = anaglyphBlue;
    }
    Icon iconGlass, iconStreaks, iconOverlay;
    iconGlass = block.getIcon(0, metadata);
    iconStreaks = block.getIcon(0, 16 | metadata);
    iconOverlay = block.getBlockOverlayTexture();
    double minXGlass = iconGlass.getMinU();
    double maxXGlass = iconGlass.getMaxU();
    double minYGlass = iconGlass.getMinV();
    double maxYGlass = iconGlass.getMaxV();
    double minXStreaks = iconStreaks.getMinU();
    double maxXStreaks = iconStreaks.getMaxU();
    double minYStreaks = iconStreaks.getMinV();
    double maxYStreaks = iconStreaks.getMaxV();
    double minXOverlay = iconOverlay.getMinU();
    double maxXOverlay = iconOverlay.getMaxU();
    double minYOverlay = iconOverlay.getMinV();
    double maxYOverlay = iconOverlay.getMaxV();
    double xMin = 0, xMax = 1;
    double yMin = 0, yMax = 1;
    double zMin = 0, zMax = 1;
    GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
    GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, -1.0F, 0.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMin, yMin, zMin, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMin, zMin, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMin, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMin, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMin, yMin, zMin, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMin, zMin, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXOverlay, minYOverlay);
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 1.0F, 0.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMin, yMax, zMin, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMax, zMin, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMin, yMax, zMin, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMin, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMin, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMax, zMin, maxXOverlay, minYOverlay);
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, -1.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXOverlay, minYOverlay);
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, 1.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXOverlay, minYOverlay);
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(-1.0F, 0.0F, 0.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMin, yMin, zMax, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMin, yMax, zMax, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMin, yMax, zMin, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMin, yMin, zMin, maxXOverlay, minYOverlay);
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(1.0F, 0.0F, 0.0F);
    tessellator.setColorOpaque_F(red, green, blue);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXGlass, minYGlass);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXGlass, maxYGlass);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXGlass, minYGlass);
    tessellator.setColorOpaque_F(1, 1, 1);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXStreaks, maxYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXStreaks, minYStreaks);
    tessellator.addVertexWithUV(xMax, yMin, zMin, minXOverlay, minYOverlay);
    tessellator.addVertexWithUV(xMax, yMax, zMin, minXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMax, zMax, maxXOverlay, maxYOverlay);
    tessellator.addVertexWithUV(xMax, yMin, zMax, maxXOverlay, minYOverlay);
    tessellator.draw();
    GL11.glTranslatef(0.5F, 0.5F, 0.5F);
}
Also used : Tessellator(net.minecraft.client.renderer.Tessellator) Icon(net.minecraft.util.Icon) BlockFactoryGlass(powercrystals.minefactoryreloaded.block.BlockFactoryGlass)

Example 9 with Icon

use of net.minecraft.util.Icon in project MineFactoryReloaded by powercrystals.

the class GuiFactoryInventory method drawTank.

protected void drawTank(int xOffset, int yOffset, int liquidId, int liquidMeta, int level) {
    LiquidStack stack = LiquidDictionary.getCanonicalLiquid(new LiquidStack(liquidId, 1, liquidMeta));
    if (liquidId <= 0 || stack == null) {
        return;
    }
    ItemStack itemStack = stack.asItemStack();
    Icon icon = stack.getRenderingIcon();
    if (icon == null) {
        try {
            icon = itemStack.getIconIndex();
        } catch (Throwable _) {
        }
        if (icon == null)
            icon = Block.lavaMoving.getIcon(0, 0);
    }
    int vertOffset = 0;
    while (level > 0) {
        int texHeight = 0;
        if (level > 16) {
            texHeight = 16;
            level -= 16;
        } else {
            texHeight = level;
            level = 0;
        }
        mc.renderEngine.bindTexture(stack.getTextureSheet());
        drawTexturedModelRectFromIcon(xOffset, yOffset - texHeight - vertOffset, icon, 16, texHeight);
        vertOffset = vertOffset + 16;
    }
    this.mc.renderEngine.bindTexture(MineFactoryReloadedCore.guiFolder + _tileEntity.getGuiBackground());
    this.drawTexturedModalRect(xOffset, yOffset - 60, 176, 0, 16, 60);
}
Also used : LiquidStack(net.minecraftforge.liquids.LiquidStack) Icon(net.minecraft.util.Icon) ItemStack(net.minecraft.item.ItemStack)

Aggregations

Icon (net.minecraft.util.Icon)9 Tessellator (net.minecraft.client.renderer.Tessellator)8 BlockFactoryGlass (powercrystals.minefactoryreloaded.block.BlockFactoryGlass)2 BlockFactoryGlassPane (powercrystals.minefactoryreloaded.block.BlockFactoryGlassPane)2 ItemStack (net.minecraft.item.ItemStack)1 LiquidStack (net.minecraftforge.liquids.LiquidStack)1
About Me
UseOf

Java Tutorials :

Simple Java RabbitMQ Example with Spring
Simple Springboot JPA Eclipeslink Example
Simple SpringBoot JPA Hibernate Example
Jackson JSON @JsonIgnore and @JsonIgnoreProperties Examples
Java Infinite recursion (StackOverflowError) Jackson solutions
Simple Java Jackson Serialize Objects to JSON and convert them back To Object
ElasticSearch 5 - Upload files using Java API in binary field Example
Java JAXB marshall unmarshall Examples from String and Stream
Java 8 forEach List and Map examples
ElasticSearch 5 Java API SearchRequestBuilder examples
Java ElasticSearch 5 examples with node index and mapping - running local
Convert String to int or Integer Java 8
Java 9 in action - JShell - Ubuntu
Java - removing invalid characters from a file name
Hello world!? or Hello Tutorial