package net.minecraft.src;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import javax.imageio.ImageIO;
import net.minecraft.client.Minecraft;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.lwjgl.opengl.GLContext;

public class RenderEngine
{
    /** Use mipmaps for all bound textures (unused at present) */
    public static boolean useMipmaps = true;
    private HashMap textureMap = new HashMap();

    /** Texture contents map (key: texture name, value: int[] contents) */
    private HashMap textureContentsMap = new HashMap();

    /** A mapping from GL texture names (integers) to BufferedImage instances */
    private IntHashMap textureNameToImageMap = new IntHashMap();

    /** An IntBuffer storing 1 int used as scratch space in RenderEngine */
    private IntBuffer singleIntBuffer = GLAllocation.createDirectIntBuffer(1);

    /** Stores the image data for the texture. */
    private ByteBuffer imageData;
    private List textureList;

    /** A mapping from image URLs to ThreadDownloadImageData instances */
    private Map urlToImageDataMap;

    /** Reference to the GameSettings object */
    private GameSettings options;

    /** Flag set when a texture should not be repeated */
    public boolean clampTexture;

    /** Flag set when a texture should use blurry resizing */
    public boolean blurTexture;

    /** Texture pack */
    public TexturePackList texturePack;

    /** Missing texture image */
    private BufferedImage missingTextureImage;
    private int field_48512_n;
    private int terrainTextureId = -1;
    private int guiItemsTextureId = -1;
    private int ctmTextureId = -1;
    private boolean hdTexturesInstalled = false;
    private Map textureDimensionsMap = new HashMap();
    private Map textureDataMap = new HashMap();
    private int tickCounter = 0;
    private ByteBuffer[] mipImageDatas;
    private boolean dynamicTexturesUpdated = false;
    private Map textureFxMap = new IdentityHashMap();
    private Map mipDataBufsMap = new HashMap();
    private int checkedEntityId = -1;
    private World checkedEntityWorld = null;
    private Map textureVariantsMap = new HashMap();

    public RenderEngine(TexturePackList par1TexturePackList, GameSettings par2GameSettings)
    {
        this.allocateImageData(256);
        this.textureList = new ArrayList();
        this.urlToImageDataMap = new HashMap();
        this.clampTexture = false;
        this.blurTexture = false;
        this.missingTextureImage = new BufferedImage(64, 64, 2);
        this.field_48512_n = 16;
        this.texturePack = par1TexturePackList;
        this.options = par2GameSettings;
        Graphics var3 = this.missingTextureImage.getGraphics();
        var3.setColor(Color.WHITE);
        var3.fillRect(0, 0, 64, 64);
        var3.setColor(Color.BLACK);
        var3.drawString("missingtex", 1, 10);
        var3.dispose();
    }

    public int[] getTextureContents(String par1Str)
    {
        TexturePackBase var2 = this.texturePack.selectedTexturePack;
        int[] var3 = (int[])((int[])this.textureContentsMap.get(par1Str));

        if (var3 != null)
        {
            return var3;
        }
        else
        {
            int[] var4;

            try
            {
                Object var7 = null;

                if (par1Str.startsWith("##"))
                {
                    var4 = this.getImageContentsAndAllocate(this.unwrapImageByColumns(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(2)))));
                }
                else if (par1Str.startsWith("%clamp%"))
                {
                    this.clampTexture = true;
                    var4 = this.getImageContentsAndAllocate(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(7))));
                    this.clampTexture = false;
                }
                else if (par1Str.startsWith("%blur%"))
                {
                    this.blurTexture = true;
                    this.clampTexture = true;
                    var4 = this.getImageContentsAndAllocate(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(6))));
                    this.clampTexture = false;
                    this.blurTexture = false;
                }
                else
                {
                    InputStream var5 = var2.getResourceAsStream(par1Str);

                    if (var5 == null)
                    {
                        var4 = this.getImageContentsAndAllocate(this.missingTextureImage);
                    }
                    else
                    {
                        var4 = this.getImageContentsAndAllocate(this.readTextureImage(var5));
                    }
                }

                this.textureContentsMap.put(par1Str, var4);
                return var4;
            }
            catch (IOException var6)
            {
                var6.printStackTrace();
                var4 = this.getImageContentsAndAllocate(this.missingTextureImage);
                this.textureContentsMap.put(par1Str, var4);
                return var4;
            }
        }
    }

    private int[] getImageContentsAndAllocate(BufferedImage par1BufferedImage)
    {
        int var2 = par1BufferedImage.getWidth();
        int var3 = par1BufferedImage.getHeight();
        int[] var4 = new int[var2 * var3];
        par1BufferedImage.getRGB(0, 0, var2, var3, var4, 0, var2);
        return var4;
    }

    private int[] getImageContents(BufferedImage par1BufferedImage, int[] par2ArrayOfInteger)
    {
        int var3 = par1BufferedImage.getWidth();
        int var4 = par1BufferedImage.getHeight();
        par1BufferedImage.getRGB(0, 0, var3, var4, par2ArrayOfInteger, 0, var3);
        return par2ArrayOfInteger;
    }

    public int getTexture(String par1Str)
    {
        TexturePackBase var2 = this.texturePack.selectedTexturePack;
        Integer var3 = (Integer)this.textureMap.get(par1Str);

        if (var3 != null)
        {
            return var3.intValue();
        }
        else
        {
            int var4;

            try
            {
                this.singleIntBuffer.clear();
                GLAllocation.generateTextureNames(this.singleIntBuffer);

                if (Tessellator.renderingWorldRenderer)
                {
                    System.out.printf("Warning: Texture %s not preloaded, will cause render glitches!\n", new Object[] {par1Str});
                }

                var4 = this.singleIntBuffer.get(0);
                Config.dbg("setupTexture: \"" + par1Str + "\", id: " + var4);

                if (par1Str.startsWith("##"))
                {
                    this.setupTexture(this.unwrapImageByColumns(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(2)))), var4);
                }
                else if (par1Str.startsWith("%clamp%"))
                {
                    this.clampTexture = true;
                    this.setupTexture(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(7))), var4);
                    this.clampTexture = false;
                }
                else if (par1Str.startsWith("%blur%"))
                {
                    this.blurTexture = true;
                    this.setupTexture(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(6))), var4);
                    this.blurTexture = false;
                }
                else if (par1Str.startsWith("%blurclamp%"))
                {
                    this.blurTexture = true;
                    this.clampTexture = true;
                    this.setupTexture(this.readTextureImage(var2.getResourceAsStream(par1Str.substring(11))), var4);
                    this.blurTexture = false;
                    this.clampTexture = false;
                }
                else
                {
                    InputStream var5 = var2.getResourceAsStream(par1Str);

                    if (var5 == null)
                    {
                        this.setupTexture(this.missingTextureImage, var4);
                    }
                    else
                    {
                        if (par1Str.equals("/terrain.png"))
                        {
                            this.terrainTextureId = var4;
                        }

                        if (par1Str.equals("/gui/items.png"))
                        {
                            this.guiItemsTextureId = var4;
                        }

                        if (par1Str.equals("/ctm.png"))
                        {
                            this.ctmTextureId = var4;
                        }

                        this.setupTexture(this.readTextureImage(var5), var4);
                    }
                }

                this.textureMap.put(par1Str, Integer.valueOf(var4));
                return var4;
            }
            catch (Exception var6)
            {
                var6.printStackTrace();
                GLAllocation.generateTextureNames(this.singleIntBuffer);
                var4 = this.singleIntBuffer.get(0);
                this.setupTexture(this.missingTextureImage, var4);
                this.textureMap.put(par1Str, Integer.valueOf(var4));
                return var4;
            }
        }
    }

    /**
     * Takes an image with multiple 16-pixel-wide columns and creates a new 16-pixel-wide image where the columns are
     * stacked vertically
     */
    private BufferedImage unwrapImageByColumns(BufferedImage par1BufferedImage)
    {
        int var2 = par1BufferedImage.getWidth() / 16;
        BufferedImage var3 = new BufferedImage(16, par1BufferedImage.getHeight() * var2, 2);
        Graphics var4 = var3.getGraphics();

        for (int var5 = 0; var5 < var2; ++var5)
        {
            var4.drawImage(par1BufferedImage, -var5 * 16, var5 * par1BufferedImage.getHeight(), (ImageObserver)null);
        }

        var4.dispose();
        return var3;
    }

    /**
     * Copy the supplied image onto a newly-allocated OpenGL texture, returning the allocated texture name
     */
    public int allocateAndSetupTexture(BufferedImage par1BufferedImage)
    {
        this.singleIntBuffer.clear();
        GLAllocation.generateTextureNames(this.singleIntBuffer);
        int var2 = this.singleIntBuffer.get(0);
        this.setupTexture(par1BufferedImage, var2);
        this.textureNameToImageMap.addKey(var2, par1BufferedImage);
        return var2;
    }

    /**
     * Copy the supplied image onto the specified OpenGL texture
     */
    public void setupTexture(BufferedImage par1BufferedImage, int par2)
    {
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, par2);
        boolean var3 = useMipmaps && Config.isUseMipmaps();
        int var4;
        int var5;

        if (var3 && par2 != this.guiItemsTextureId)
        {
            var4 = Config.getMipmapType();
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, var4);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);

            if (GLContext.getCapabilities().OpenGL12)
            {
                GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_BASE_LEVEL, 0);
                var5 = Config.getMipmapLevel();

                if (var5 >= 4)
                {
                    int var6 = Math.min(par1BufferedImage.getWidth(), par1BufferedImage.getHeight());
                    var5 = this.getMaxMipmapLevel(var6) - 4;

                    if (var5 < 0)
                    {
                        var5 = 0;
                    }
                }

                GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL12.GL_TEXTURE_MAX_LEVEL, var5);
            }
        }
        else
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        }

        if (this.blurTexture)
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
        }

        if (this.clampTexture)
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
        }
        else
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
        }

        var4 = par1BufferedImage.getWidth();
        var5 = par1BufferedImage.getHeight();
        this.setTextureDimension(par2, new Dimension(var4, var5));
        int[] var16 = new int[var4 * var5];
        byte[] var7 = new byte[var4 * var5 * 4];
        par1BufferedImage.getRGB(0, 0, var4, var5, var16, 0, var4);

        for (int var8 = 0; var8 < var16.length; ++var8)
        {
            int var9 = var16[var8] >> 24 & 255;
            int var10 = var16[var8] >> 16 & 255;
            int var11 = var16[var8] >> 8 & 255;
            int var12 = var16[var8] & 255;

            if (this.options != null && this.options.anaglyph)
            {
                int var13 = (var10 * 30 + var11 * 59 + var12 * 11) / 100;
                int var14 = (var10 * 30 + var11 * 70) / 100;
                int var15 = (var10 * 30 + var12 * 70) / 100;
                var10 = var13;
                var11 = var14;
                var12 = var15;
            }

            if (var9 == 0)
            {
                if (this.isTerrainTexture(par2))
                {
                    var10 = 255;
                    var11 = 255;
                    var12 = 255;
                }
                else
                {
                    var10 = 0;
                    var11 = 0;
                    var12 = 0;
                }
            }

            var7[var8 * 4 + 0] = (byte)var10;
            var7[var8 * 4 + 1] = (byte)var11;
            var7[var8 * 4 + 2] = (byte)var12;
            var7[var8 * 4 + 3] = (byte)var9;
        }

        this.checkImageDataSize(var4);
        this.imageData.clear();
        this.imageData.put(var7);
        this.imageData.position(0).limit(var7.length);
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, var4, var5, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, this.imageData);

        if (useMipmaps)
        {
            this.generateMipMaps(this.imageData, var4, var5);
        }
    }

    private boolean isTerrainTexture(int var1)
    {
        return var1 == this.terrainTextureId ? true : var1 == this.ctmTextureId;
    }

    private void generateMipMaps(ByteBuffer var1, int var2, int var3)
    {
        ByteBuffer var4 = var1;

        for (int var5 = 1; var5 <= 16; ++var5)
        {
            int var6 = var2 >> var5 - 1;
            int var7 = var2 >> var5;
            int var8 = var3 >> var5;

            if (var7 <= 0 || var8 <= 0)
            {
                break;
            }

            ByteBuffer var9 = this.mipImageDatas[var5 - 1];
            var9.limit(var7 * var8 * 4);

            for (int var10 = 0; var10 < var7; ++var10)
            {
                for (int var11 = 0; var11 < var8; ++var11)
                {
                    int var12 = var4.getInt((var10 * 2 + 0 + (var11 * 2 + 0) * var6) * 4);
                    int var13 = var4.getInt((var10 * 2 + 1 + (var11 * 2 + 0) * var6) * 4);
                    int var14 = var4.getInt((var10 * 2 + 1 + (var11 * 2 + 1) * var6) * 4);
                    int var15 = var4.getInt((var10 * 2 + 0 + (var11 * 2 + 1) * var6) * 4);
                    int var16 = this.alphaBlend(var12, var13, var14, var15);
                    var9.putInt((var10 + var11 * var7) * 4, var16);
                }
            }

            var9.rewind();
            GL11.glTexImage2D(GL11.GL_TEXTURE_2D, var5, GL11.GL_RGBA, var7, var8, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, var9);
            var4 = var9;
        }
    }

    public void createTextureFromBytes(int[] par1ArrayOfInteger, int par2, int par3, int par4)
    {
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, par4);

        if (useMipmaps && Config.isUseMipmaps())
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST_MIPMAP_LINEAR);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        }
        else
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        }

        if (this.blurTexture)
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
        }

        if (this.clampTexture)
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
        }
        else
        {
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT);
            GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT);
        }

        byte[] var5 = new byte[par2 * par3 * 4];

        for (int var6 = 0; var6 < par1ArrayOfInteger.length; ++var6)
        {
            int var7 = par1ArrayOfInteger[var6] >> 24 & 255;
            int var8 = par1ArrayOfInteger[var6] >> 16 & 255;
            int var9 = par1ArrayOfInteger[var6] >> 8 & 255;
            int var10 = par1ArrayOfInteger[var6] & 255;

            if (this.options != null && this.options.anaglyph)
            {
                int var11 = (var8 * 30 + var9 * 59 + var10 * 11) / 100;
                int var12 = (var8 * 30 + var9 * 70) / 100;
                int var13 = (var8 * 30 + var10 * 70) / 100;
                var8 = var11;
                var9 = var12;
                var10 = var13;
            }

            var5[var6 * 4 + 0] = (byte)var8;
            var5[var6 * 4 + 1] = (byte)var9;
            var5[var6 * 4 + 2] = (byte)var10;
            var5[var6 * 4 + 3] = (byte)var7;
        }

        this.imageData.clear();
        this.imageData.put(var5);
        this.imageData.position(0).limit(var5.length);
        GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, par2, par3, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, this.imageData);
    }

    /**
     * Deletes a single GL texture
     */
    public void deleteTexture(int par1)
    {
        this.textureNameToImageMap.removeObject(par1);
        this.singleIntBuffer.clear();
        this.singleIntBuffer.put(par1);
        this.singleIntBuffer.flip();
        GL11.glDeleteTextures(this.singleIntBuffer);
    }

    /**
     * Takes a URL of a downloadable image and the name of the local image to be used as a fallback.  If the image has
     * been downloaded, returns the GL texture of the downloaded image, otherwise returns the GL texture of the fallback
     * image.
     */
    public int getTextureForDownloadableImage(String par1Str, String par2Str)
    {
        ThreadDownloadImageData var3 = (ThreadDownloadImageData)this.urlToImageDataMap.get(par1Str);

        if (var3 != null && var3.image != null && !var3.textureSetupComplete)
        {
            if (var3.textureName < 0)
            {
                var3.textureName = this.allocateAndSetupTexture(var3.image);
            }
            else
            {
                this.setupTexture(var3.image, var3.textureName);
            }

            var3.textureSetupComplete = true;
        }

        return var3 != null && var3.textureName >= 0 ? var3.textureName : (par2Str == null ? -1 : this.getTexture(par2Str));
    }

    /**
     * Return a ThreadDownloadImageData instance for the given URL.  If it does not already exist, it is created and
     * uses the passed ImageBuffer.  If it does, its reference count is incremented.
     */
    public ThreadDownloadImageData obtainImageData(String par1Str, ImageBuffer par2ImageBuffer)
    {
        ThreadDownloadImageData var3 = (ThreadDownloadImageData)this.urlToImageDataMap.get(par1Str);

        if (var3 == null)
        {
            this.urlToImageDataMap.put(par1Str, new ThreadDownloadImageData(par1Str, par2ImageBuffer));
        }
        else
        {
            ++var3.referenceCount;
        }

        return var3;
    }

    /**
     * Decrements the reference count for a given URL, deleting the image data if the reference count hits 0
     */
    public void releaseImageData(String par1Str)
    {
        ThreadDownloadImageData var2 = (ThreadDownloadImageData)this.urlToImageDataMap.get(par1Str);

        if (var2 != null)
        {
            --var2.referenceCount;

            if (var2.referenceCount == 0)
            {
                if (var2.textureName >= 0)
                {
                    this.deleteTexture(var2.textureName);
                }

                this.urlToImageDataMap.remove(par1Str);
            }
        }
    }

    public void registerTextureFX(TextureFX par1TextureFX)
    {
        int var2 = this.getTextureId(par1TextureFX);

        for (int var3 = 0; var3 < this.textureList.size(); ++var3)
        {
            TextureFX var4 = (TextureFX)this.textureList.get(var3);
            int var5 = this.getTextureId(var4);

            if (var5 == var2 && var4.iconIndex == par1TextureFX.iconIndex)
            {
                this.textureList.remove(var3);
                --var3;
                Config.log("TextureFX removed: " + var4 + ", texId: " + var5 + ", index: " + var4.iconIndex);
            }
        }

        if (par1TextureFX instanceof TextureHDFX)
        {
            TextureHDFX var7 = (TextureHDFX)par1TextureFX;
            var7.setTexturePackBase(this.texturePack.selectedTexturePack);
            Dimension var6 = this.getTextureDimensions(var2);

            if (var6 != null)
            {
                var7.setTileWidth(var6.width / 16);
            }
        }

        this.textureList.add(par1TextureFX);
        par1TextureFX.onTick();
        Config.log("TextureFX registered: " + par1TextureFX + ", texId: " + var2 + ", index: " + par1TextureFX.iconIndex);
        this.dynamicTexturesUpdated = false;
    }

    private int getTextureId(TextureFX var1)
    {
        Integer var2 = (Integer)this.textureFxMap.get(var1);

        if (var2 != null)
        {
            return var2.intValue();
        }
        else
        {
            int var3 = this.getBoundTexture();
            var1.bindImage(this);
            int var4 = this.getBoundTexture();
            this.bindTexture(var3);
            this.textureFxMap.put(var1, new Integer(var4));
            return var4;
        }
    }

    private int getBoundTexture()
    {
        int var1 = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
        return var1;
    }

    private void generateMipMapsSub(int var1, int var2, int var3, int var4, ByteBuffer var5, int var6, boolean var7, String var8)
    {
        ByteBuffer var9 = var5;
        byte[][] var10 = (byte[][])null;

        if (var8.length() > 0)
        {
            var10 = (byte[][])((byte[][])this.mipDataBufsMap.get(var8));

            if (var10 == null)
            {
                var10 = new byte[17][];
                this.mipDataBufsMap.put(var8, var10);
            }
        }

        for (int var11 = 1; var11 <= 16; ++var11)
        {
            int var12 = var3 >> var11 - 1;
            int var13 = var3 >> var11;
            int var14 = var4 >> var11;
            int var15 = var1 >> var11;
            int var16 = var2 >> var11;

            if (var13 <= 0 || var14 <= 0)
            {
                break;
            }

            ByteBuffer var17 = this.mipImageDatas[var11 - 1];
            var17.limit(var13 * var14 * 4);
            byte[] var18 = null;

            if (var10 != null)
            {
                var18 = var10[var11];
            }

            if (var18 != null && var18.length != var13 * var14 * 4)
            {
                var18 = null;
            }

            int var19;
            int var21;
            int var20;
            int var22;

            if (var18 == null)
            {
                if (var10 != null)
                {
                    var18 = new byte[var13 * var14 * 4];
                }

                for (var19 = 0; var19 < var13; ++var19)
                {
                    for (var20 = 0; var20 < var14; ++var20)
                    {
                        var21 = var9.getInt((var19 * 2 + 0 + (var20 * 2 + 0) * var12) * 4);
                        var22 = var9.getInt((var19 * 2 + 1 + (var20 * 2 + 0) * var12) * 4);
                        int var23 = var9.getInt((var19 * 2 + 1 + (var20 * 2 + 1) * var12) * 4);
                        int var24 = var9.getInt((var19 * 2 + 0 + (var20 * 2 + 1) * var12) * 4);
                        int var25;

                        if (var7)
                        {
                            var25 = this.averageColor(this.averageColor(var21, var22), this.averageColor(var23, var24));
                        }
                        else
                        {
                            var25 = this.alphaBlend(var21, var22, var23, var24);
                        }

                        var17.putInt((var19 + var20 * var13) * 4, var25);
                    }
                }

                if (var10 != null)
                {
                    var17.rewind();
                    var17.get(var18);
                    var10[var11] = var18;
                }
            }

            if (var18 != null)
            {
                var17.rewind();
                var17.put(var18);
            }

            var17.rewind();

            for (var19 = 0; var19 < var6; ++var19)
            {
                for (var20 = 0; var20 < var6; ++var20)
                {
                    var21 = var19 * var13;
                    var22 = var20 * var14;
                    GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, var11, var15 + var21, var16 + var22, var13, var14, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, var17);
                }
            }

            var9 = var17;
        }
    }

    public void updateDynamicTextures()
    {
        boolean var1 = useMipmaps && Config.isUseMipmaps();
        this.checkHdTextures();
        this.checkEntityTextures();
        ++this.tickCounter;
        this.terrainTextureId = this.getTexture("/terrain.png");
        this.guiItemsTextureId = this.getTexture("/gui/items.png");
        this.ctmTextureId = this.getTexture("/ctm.png");
        StringBuffer var2 = new StringBuffer();
        int var3 = -1;

        for (int var4 = 0; var4 < this.textureList.size(); ++var4)
        {
            TextureFX var5 = (TextureFX)this.textureList.get(var4);
            var5.anaglyphEnabled = this.options.anaglyph;

            if (!var5.getClass().getName().equals("ModTextureStatic") || !this.dynamicTexturesUpdated)
            {
                int var6 = this.getTextureId(var5);
                Dimension var7 = this.getTextureDimensions(var6);

                if (var7 == null)
                {
                    throw new IllegalArgumentException("Unknown dimensions for texture id: " + var6);
                }

                int var8 = var7.width / 16;
                int var9 = var7.height / 16;
                this.checkImageDataSize(var7.width);
                this.imageData.limit(0);
                var2.setLength(0);
                boolean var10 = this.updateCustomTexture(var5, var6, this.imageData, var7.width / 16, var2);

                if (!var10 || this.imageData.limit() > 0)
                {
                    boolean var11;

                    if (this.imageData.limit() <= 0)
                    {
                        var11 = this.updateDefaultTexture(var5, var6, this.imageData, var7.width / 16, var2);

                        if (var11 && this.imageData.limit() <= 0)
                        {
                            continue;
                        }
                    }

                    if (this.imageData.limit() <= 0)
                    {
                        var5.onTick();

                        if (var5.imageData == null)
                        {
                            continue;
                        }

                        int var17 = var8 * var9 * 4;

                        if (var5.imageData.length == var17)
                        {
                            this.imageData.clear();
                            this.imageData.put(var5.imageData);
                            this.imageData.position(0).limit(var5.imageData.length);
                        }
                        else
                        {
                            this.copyScaled(var5.imageData, this.imageData, var8);
                        }
                    }

                    if (var6 != var3)
                    {
                        var5.bindImage(this);
                        var3 = var6;
                    }

                    var11 = this.scalesWithFastColor(var5);

                    for (int var12 = 0; var12 < var5.tileSize; ++var12)
                    {
                        for (int var13 = 0; var13 < var5.tileSize; ++var13)
                        {
                            int var14 = var5.iconIndex % 16 * var8 + var12 * var8;
                            int var15 = var5.iconIndex / 16 * var9 + var13 * var9;
                            GL11.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, var14, var15, var8, var9, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, this.imageData);

                            if (var1 && var6 != this.guiItemsTextureId)
                            {
                                String var16 = var2.toString();

                                if (var12 == 0 && var13 == 0)
                                {
                                    this.generateMipMapsSub(var14, var15, var8, var9, this.imageData, var5.tileSize, var11, var16);
                                }
                            }
                        }
                    }
                }
            }
        }

        this.dynamicTexturesUpdated = true;
    }

    private void checkEntityTextures()
    {
        if (Config.isRandomMobs())
        {
            World var1 = this.options.mc.theWorld;

            if (var1 != null)
            {
                if (this.checkedEntityWorld != var1)
                {
                    this.checkedEntityWorld = var1;
                    this.checkedEntityId = -1;
                }

                List var2 = this.options.mc.theWorld.getLoadedEntityList();
                int var3 = this.checkedEntityId;

                for (int var4 = var2.size() - 1; var4 >= 0; --var4)
                {
                    Entity var5 = (Entity)var2.get(var4);
                    int var6 = var5.entityId;

                    if (var6 <= var3)
                    {
                        break;
                    }

                    if (var6 > this.checkedEntityId)
                    {
                        this.checkedEntityId = var6;
                    }

                    if (var5 instanceof EntityLiving)
                    {
                        EntityLiving var7 = (EntityLiving)var5;
                        var7.texture = this.getRandomTexture(var7.texture, var7.entityId);
                    }
                }
            }
        }
    }

    private void resetEntityTextures()
    {
        this.checkedEntityWorld = null;
        this.checkedEntityId = -1;
        this.textureVariantsMap.clear();

        if (this.options != null)
        {
            if (this.options.mc != null)
            {
                if (this.options.mc.theWorld != null)
                {
                    if (this.options.mc.theWorld.getLoadedEntityList() != null)
                    {
                        List var1 = this.options.mc.theWorld.getLoadedEntityList();

                        for (int var2 = 0; var2 < var1.size(); ++var2)
                        {
                            Entity var3 = (Entity)var1.get(var2);

                            if (var3 instanceof EntityLiving)
                            {
                                EntityLiving var4 = (EntityLiving)var3;
                                this.resetEntityTexture(var4);
                            }
                        }
                    }
                }
            }
        }
    }

    private void resetEntityTexture(EntityLiving var1)
    {
        if (!(var1 instanceof EntityPlayer))
        {
            String var2 = var1.texture;

            if (var2 != null)
            {
                int var3 = var2.lastIndexOf(46);

                if (var3 >= 0)
                {
                    String var4 = var2.substring(0, var3);
                    String var5 = var2.substring(var3);
                    int var6 = var4.length() - 1;

                    for (int var7 = var6; var7 >= 0; --var7)
                    {
                        char var8 = var4.charAt(var7);

                        if (!Character.isDigit(var8))
                        {
                            if (var7 == var6)
                            {
                                return;
                            }

                            var4 = var4.substring(0, var7 + 1);
                            break;
                        }
                    }

                    var2 = var4 + var5;
                    var1.texture = var2;
                }
            }
        }
    }

    private String getRandomTexture(String var1, int var2)
    {
        int var3 = var1.lastIndexOf(46);

        if (var3 < 0)
        {
            return var1;
        }
        else
        {
            String var4 = var1.substring(0, var3);
            String var5 = var1.substring(var3);
            int var6 = this.getCountTextureVariants(var1, var4, var5);

            if (var6 <= 1)
            {
                return var1;
            }
            else
            {
                Random var7 = new Random((long)var2);
                int var8 = var7.nextInt(var6);

                if (var8 <= 0)
                {
                    return var1;
                }
                else
                {
                    String var9 = var4 + (var8 + 1) + var5;
                    return var9;
                }
            }
        }
    }

    private int getCountTextureVariants(String var1, String var2, String var3)
    {
        Integer var4 = (Integer)this.textureVariantsMap.get(var1);

        if (var4 != null)
        {
            return var4.intValue();
        }
        else
        {
            var4 = new Integer(1);

            for (int var5 = 2; var5 < 100; ++var5)
            {
                String var6 = var2 + var5 + var3;
                byte[] var7 = this.getCustomTextureData(var6, -1);

                if (var7 == null)
                {
                    var4 = new Integer(var5 - 1);
                    break;
                }
            }

            this.textureVariantsMap.put(var1, var4);

            if (var4.intValue() > 1)
            {
                Config.log("RandomMob texture: " + var1 + ", variants: " + var4.intValue());
            }

            return var4.intValue();
        }
    }

    private int averageColor(int var1, int var2)
    {
        int var3 = (var1 & -16777216) >> 24 & 255;
        int var4 = (var2 & -16777216) >> 24 & 255;
        return (var3 + var4 >> 1 << 24) + ((var1 & 16711422) + (var2 & 16711422) >> 1);
    }

    private int alphaBlend(int var1, int var2, int var3, int var4)
    {
        int var5 = this.alphaBlend(var1, var2);
        int var6 = this.alphaBlend(var3, var4);
        int var7 = this.alphaBlend(var5, var6);
        return var7;
    }

    /**
     * Uses the alpha of the two colors passed in to determine the contributions of each color.  If either of them has
     * an alpha greater than 0 then the returned alpha is 255 otherwise its zero if they are both zero. Args: color1,
     * color2
     */
    private int alphaBlend(int par1, int par2)
    {
        int var3 = (par1 & -16777216) >> 24 & 255;
        int var4 = (par2 & -16777216) >> 24 & 255;
        int var5 = (var3 + var4) / 2;

        if (var3 == 0 && var4 == 0)
        {
            var3 = 1;
            var4 = 1;
        }
        else
        {
            if (var3 == 0)
            {
                par1 = par2;
                var5 /= 2;
            }

            if (var4 == 0)
            {
                par2 = par1;
                var5 /= 2;
            }
        }

        int var6 = (par1 >> 16 & 255) * var3;
        int var7 = (par1 >> 8 & 255) * var3;
        int var8 = (par1 & 255) * var3;
        int var9 = (par2 >> 16 & 255) * var4;
        int var10 = (par2 >> 8 & 255) * var4;
        int var11 = (par2 & 255) * var4;
        int var12 = (var6 + var9) / (var3 + var4);
        int var13 = (var7 + var10) / (var3 + var4);
        int var14 = (var8 + var11) / (var3 + var4);
        return var5 << 24 | var12 << 16 | var13 << 8 | var14;
    }

    /**
     * Call setupTexture on all currently-loaded textures again to account for changes in rendering options
     */
    public void refreshTextures()
    {
        this.textureDataMap.clear();
        this.textureFxMap.clear();
        this.dynamicTexturesUpdated = false;
        Config.setTextureUpdateTime(System.currentTimeMillis());
        this.resetEntityTextures();
        this.mipDataBufsMap.clear();
        TexturePackBase var1 = this.texturePack.selectedTexturePack;
        Iterator var4 = this.textureNameToImageMap.getKeySet().iterator();

        while (var4.hasNext())
        {
            int var2 = ((Integer)var4.next()).intValue();
            BufferedImage var3 = (BufferedImage)this.textureNameToImageMap.lookup(var2);
            this.setupTexture(var3, var2);
        }

        ThreadDownloadImageData var5;

        for (var4 = this.urlToImageDataMap.values().iterator(); var4.hasNext(); var5.textureSetupComplete = false)
        {
            var5 = (ThreadDownloadImageData)var4.next();
        }

        var4 = this.textureMap.keySet().iterator();
        BufferedImage var6;
        String var10;

        while (var4.hasNext())
        {
            var10 = (String)var4.next();

            try
            {
                if (var10.startsWith("##"))
                {
                    var6 = this.unwrapImageByColumns(this.readTextureImage(var1.getResourceAsStream(var10.substring(2))));
                }
                else if (var10.startsWith("%clamp%"))
                {
                    this.clampTexture = true;
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10.substring(7)));
                }
                else if (var10.startsWith("%blur%"))
                {
                    this.blurTexture = true;
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10.substring(6)));
                }
                else if (var10.startsWith("%blurclamp%"))
                {
                    this.blurTexture = true;
                    this.clampTexture = true;
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10.substring(11)));
                }
                else
                {
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10));
                }

                int var7 = ((Integer)this.textureMap.get(var10)).intValue();
                this.setupTexture(var6, var7);
                this.blurTexture = false;
                this.clampTexture = false;
            }
            catch (Exception var9)
            {
                if (!"input == null!".equals(var9.getMessage()))
                {
                    var9.printStackTrace();
                }
            }
        }

        var4 = this.textureContentsMap.keySet().iterator();

        while (var4.hasNext())
        {
            var10 = (String)var4.next();

            try
            {
                if (var10.startsWith("##"))
                {
                    var6 = this.unwrapImageByColumns(this.readTextureImage(var1.getResourceAsStream(var10.substring(2))));
                }
                else if (var10.startsWith("%clamp%"))
                {
                    this.clampTexture = true;
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10.substring(7)));
                }
                else if (var10.startsWith("%blur%"))
                {
                    this.blurTexture = true;
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10.substring(6)));
                }
                else
                {
                    var6 = this.readTextureImage(var1.getResourceAsStream(var10));
                }

                this.getImageContents(var6, (int[])((int[])this.textureContentsMap.get(var10)));
                this.blurTexture = false;
                this.clampTexture = false;
            }
            catch (Exception var8)
            {
                if (!"input == null!".equals(var8.getMessage()))
                {
                    var8.printStackTrace();
                }
            }
        }

        this.registerCustomTexturesFX();
        CustomColorizer.update(this);
        this.updateDynamicTextures();
    }

    /**
     * Returns a BufferedImage read off the provided input stream.  Args: inputStream
     */
    private BufferedImage readTextureImage(InputStream par1InputStream) throws IOException
    {
        BufferedImage var2 = ImageIO.read(par1InputStream);
        par1InputStream.close();
        return var2;
    }

    public void bindTexture(int par1)
    {
        if (par1 >= 0)
        {
            GL11.glBindTexture(GL11.GL_TEXTURE_2D, par1);
        }
    }

    private void setTextureDimension(int var1, Dimension var2)
    {
        this.textureDimensionsMap.put(new Integer(var1), var2);

        if (var1 == this.terrainTextureId)
        {
            Config.setIconWidthTerrain(var2.width / 16);
        }

        if (var1 == this.guiItemsTextureId)
        {
            Config.setIconWidthItems(var2.width / 16);
        }

        this.updateDinamicTextures(var1, var2);
    }

    private Dimension getTextureDimensions(int var1)
    {
        Dimension var2 = (Dimension)this.textureDimensionsMap.get(new Integer(var1));
        return var2;
    }

    private void updateDinamicTextures(int var1, Dimension var2)
    {
        for (int var3 = 0; var3 < this.textureList.size(); ++var3)
        {
            TextureFX var4 = (TextureFX)this.textureList.get(var3);
            int var5 = this.getTextureId(var4);

            if (var5 == var1 && var4 instanceof TextureHDFX)
            {
                TextureHDFX var6 = (TextureHDFX)var4;
                var6.setTexturePackBase(this.texturePack.selectedTexturePack);
                var6.setTileWidth(var2.width / 16);
                var6.onTick();
            }
        }
    }

    public boolean updateCustomTexture(TextureFX var1, int var2, ByteBuffer var3, int var4, StringBuffer var5)
    {
        if (var2 == this.terrainTextureId)
        {
            if (var1.iconIndex == Block.waterStill.blockIndexInTexture)
            {
                if (Config.isGeneratedWater())
                {
                    return false;
                }

                return this.updateCustomTexture(var1, "/custom_water_still.png", var3, var4, Config.isAnimatedWater(), 1, var5);
            }

            if (var1.iconIndex == Block.waterStill.blockIndexInTexture + 1)
            {
                if (Config.isGeneratedWater())
                {
                    return false;
                }

                return this.updateCustomTexture(var1, "/custom_water_flowing.png", var3, var4, Config.isAnimatedWater(), 1, var5);
            }

            if (var1.iconIndex == Block.lavaStill.blockIndexInTexture)
            {
                if (Config.isGeneratedLava())
                {
                    return false;
                }

                return this.updateCustomTexture(var1, "/custom_lava_still.png", var3, var4, Config.isAnimatedLava(), 1, var5);
            }

            if (var1.iconIndex == Block.lavaStill.blockIndexInTexture + 1)
            {
                if (Config.isGeneratedLava())
                {
                    return false;
                }

                return this.updateCustomTexture(var1, "/custom_lava_flowing.png", var3, var4, Config.isAnimatedLava(), 1, var5);
            }

            if (var1.iconIndex == Block.portal.blockIndexInTexture)
            {
                return this.updateCustomTexture(var1, "/custom_portal.png", var3, var4, Config.isAnimatedPortal(), 1, var5);
            }

            if (var1.iconIndex == Block.fire.blockIndexInTexture)
            {
                return this.updateCustomTexture(var1, "/custom_fire_n_s.png", var3, var4, Config.isAnimatedFire(), 1, var5);
            }

            if (var1.iconIndex == Block.fire.blockIndexInTexture + 16)
            {
                return this.updateCustomTexture(var1, "/custom_fire_e_w.png", var3, var4, Config.isAnimatedFire(), 1, var5);
            }

            if (Config.isAnimatedTerrain())
            {
                return this.updateCustomTexture(var1, "/custom_terrain_" + var1.iconIndex + ".png", var3, var4, Config.isAnimatedTerrain(), 1, var5);
            }
        }

        return var2 == this.guiItemsTextureId && Config.isAnimatedItems() ? this.updateCustomTexture(var1, "/custom_item_" + var1.iconIndex + ".png", var3, var4, Config.isAnimatedTerrain(), 1, var5) : false;
    }

    private boolean updateDefaultTexture(TextureFX var1, int var2, ByteBuffer var3, int var4, StringBuffer var5)
    {
        return var2 != this.terrainTextureId ? false : (this.texturePack.selectedTexturePack instanceof TexturePackDefault ? false : (var1.iconIndex == Block.waterStill.blockIndexInTexture ? (Config.isGeneratedWater() ? false : this.updateDefaultTexture(var1, var3, var4, false, 1, var5)) : (var1.iconIndex == Block.waterStill.blockIndexInTexture + 1 ? (Config.isGeneratedWater() ? false : this.updateDefaultTexture(var1, var3, var4, Config.isAnimatedWater(), 1, var5)) : (var1.iconIndex == Block.lavaStill.blockIndexInTexture ? (Config.isGeneratedLava() ? false : this.updateDefaultTexture(var1, var3, var4, false, 1, var5)) : (var1.iconIndex == Block.lavaStill.blockIndexInTexture + 1 ? (Config.isGeneratedLava() ? false : this.updateDefaultTexture(var1, var3, var4, Config.isAnimatedLava(), 3, var5)) : false)))));
    }

    private boolean updateDefaultTexture(TextureFX var1, ByteBuffer var2, int var3, boolean var4, int var5, StringBuffer var6)
    {
        int var7 = var1.iconIndex;

        if (!var4 && this.dynamicTexturesUpdated)
        {
            return true;
        }
        else
        {
            byte[] var8 = this.getTerrainIconData(var7, var3, var6);

            if (var8 == null)
            {
                return false;
            }
            else
            {
                var2.clear();
                int var9 = var8.length;

                if (var4)
                {
                    int var10 = var3 - this.tickCounter / var5 % var3;
                    int var11 = var10 * var3 * 4;
                    var2.put(var8, var11, var9 - var11);
                    var2.put(var8, 0, var11);
                    var6.append(":");
                    var6.append(var10);
                }
                else
                {
                    var2.put(var8, 0, var9);
                }

                var2.position(0).limit(var9);
                return true;
            }
        }
    }

    private boolean updateCustomTexture(TextureFX var1, String var2, ByteBuffer var3, int var4, boolean var5, int var6, StringBuffer var7)
    {
        byte[] var8 = this.getCustomTextureData(var2, var4);

        if (var8 == null)
        {
            return false;
        }
        else if (!var5 && this.dynamicTexturesUpdated)
        {
            return true;
        }
        else
        {
            int var9 = var4 * var4 * 4;

            if (var8.length < var9)
            {
                return false;
            }
            else
            {
                int var10 = var8.length / var9;
                int var11 = this.tickCounter / var6 % var10;
                int var12 = 0;

                if (var5)
                {
                    var12 = var9 * var11;
                }

                var3.clear();
                var3.put(var8, var12, var9);
                var3.position(0).limit(var9);
                var7.append(var2);
                var7.append(":");
                var7.append(var11);
                return true;
            }
        }
    }

    private byte[] getTerrainIconData(int var1, int var2, StringBuffer var3)
    {
        String var4 = "Tile-" + var1;
        byte[] var5 = this.getCustomTextureData(var4, var2);

        if (var5 != null)
        {
            var3.append(var4);
            return var5;
        }
        else
        {
            byte[] var6 = this.getCustomTextureData("/terrain.png", var2 * 16);

            if (var6 == null)
            {
                return null;
            }
            else
            {
                var5 = new byte[var2 * var2 * 4];
                int var7 = var1 % 16;
                int var8 = var1 / 16;
                int var9 = var7 * var2;
                int var10 = var8 * var2;
                int var10000 = var9 + var2;
                var10000 = var10 + var2;

                for (int var13 = 0; var13 < var2; ++var13)
                {
                    int var14 = var10 + var13;

                    for (int var15 = 0; var15 < var2; ++var15)
                    {
                        int var16 = var9 + var15;
                        int var17 = 4 * (var16 + var14 * var2 * 16);
                        int var18 = 4 * (var15 + var13 * var2);
                        var5[var18 + 0] = var6[var17 + 0];
                        var5[var18 + 1] = var6[var17 + 1];
                        var5[var18 + 2] = var6[var17 + 2];
                        var5[var18 + 3] = var6[var17 + 3];
                    }
                }

                this.setCustomTextureData(var4, var5);
                var3.append(var4);
                return var5;
            }
        }
    }

    public byte[] getCustomTextureData(String var1, int var2)
    {
        byte[] var3 = (byte[])((byte[])this.textureDataMap.get(var1));

        if (var3 == null)
        {
            if (this.textureDataMap.containsKey(var1))
            {
                return null;
            }

            var3 = this.loadImage(var1, var2);

            if (var3 == null)
            {
                var3 = this.loadImage("/anim" + var1, var2);
            }

            this.textureDataMap.put(var1, var3);
        }

        return var3;
    }

    private void setCustomTextureData(String var1, byte[] var2)
    {
        this.textureDataMap.put(var1, var2);
    }

    private byte[] loadImage(String var1, int var2)
    {
        try
        {
            TexturePackBase var3 = this.texturePack.selectedTexturePack;

            if (var3 == null)
            {
                return null;
            }
            else
            {
                InputStream var4 = var3.getResourceAsStream(var1);

                if (var4 == null)
                {
                    return null;
                }
                else
                {
                    BufferedImage var5 = this.readTextureImage(var4);

                    if (var5 == null)
                    {
                        return null;
                    }
                    else
                    {
                        if (var2 > 0 && var5.getWidth() != var2)
                        {
                            double var6 = (double)(var5.getHeight() / var5.getWidth());
                            int var8 = (int)((double)var2 * var6);
                            var5 = scaleBufferedImage(var5, var2, var8);
                        }

                        int var19 = var5.getWidth();
                        int var7 = var5.getHeight();
                        int[] var20 = new int[var19 * var7];
                        byte[] var9 = new byte[var19 * var7 * 4];
                        var5.getRGB(0, 0, var19, var7, var20, 0, var19);

                        for (int var10 = 0; var10 < var20.length; ++var10)
                        {
                            int var11 = var20[var10] >> 24 & 255;
                            int var12 = var20[var10] >> 16 & 255;
                            int var13 = var20[var10] >> 8 & 255;
                            int var14 = var20[var10] & 255;

                            if (this.options != null && this.options.anaglyph)
                            {
                                int var15 = (var12 * 30 + var13 * 59 + var14 * 11) / 100;
                                int var16 = (var12 * 30 + var13 * 70) / 100;
                                int var17 = (var12 * 30 + var14 * 70) / 100;
                                var12 = var15;
                                var13 = var16;
                                var14 = var17;
                            }

                            var9[var10 * 4 + 0] = (byte)var12;
                            var9[var10 * 4 + 1] = (byte)var13;
                            var9[var10 * 4 + 2] = (byte)var14;
                            var9[var10 * 4 + 3] = (byte)var11;
                        }

                        return var9;
                    }
                }
            }
        }
        catch (Exception var18)
        {
            var18.printStackTrace();
            return null;
        }
    }

    public static BufferedImage scaleBufferedImage(BufferedImage var0, int var1, int var2)
    {
        BufferedImage var3 = new BufferedImage(var1, var2, 2);
        Graphics2D var4 = var3.createGraphics();
        var4.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        var4.drawImage(var0, 0, 0, var1, var2, (ImageObserver)null);
        return var3;
    }

    private void checkImageDataSize(int var1)
    {
        if (this.imageData != null)
        {
            int var2 = var1 * var1 * 4;

            if (this.imageData.capacity() >= var2)
            {
                return;
            }
        }

        this.allocateImageData(var1);
    }

    private void allocateImageData(int var1)
    {
        int var2 = var1 * var1 * 4;
        this.imageData = GLAllocation.createDirectByteBuffer(var2);
        ArrayList var3 = new ArrayList();

        for (int var4 = var1 / 2; var4 > 0; var4 /= 2)
        {
            int var5 = var4 * var4 * 4;
            ByteBuffer var6 = GLAllocation.createDirectByteBuffer(var5);
            var3.add(var6);
        }

        this.mipImageDatas = (ByteBuffer[])((ByteBuffer[])var3.toArray(new ByteBuffer[var3.size()]));
    }

    public void checkHdTextures()
    {
        if (!this.hdTexturesInstalled)
        {
            Minecraft var1 = Config.getMinecraft();

            if (var1 != null)
            {
                this.hdTexturesInstalled = true;
                this.registerTextureFX(new TextureHDLavaFX());
                this.registerTextureFX(new TextureHDWaterFX());
                this.registerTextureFX(new TextureHDPortalFX());
                this.registerTextureFX(new TextureHDWaterFlowFX());
                this.registerTextureFX(new TextureHDLavaFlowFX());
                this.registerTextureFX(new TextureHDFlamesFX(0));
                this.registerTextureFX(new TextureHDFlamesFX(1));
                this.registerTextureFX(new TextureHDCompassFX(var1));
                this.registerTextureFX(new TextureHDWatchFX(var1));
                this.registerCustomTexturesFX();
                CustomColorizer.update(this);
            }
        }
    }

    private void registerCustomTexturesFX()
    {
        TextureFX[] var1 = this.getRegisteredTexturesFX(TextureHDCustomFX.class);
        int var2;

        for (var2 = 0; var2 < var1.length; ++var2)
        {
            TextureFX var3 = var1[var2];
            this.unregisterTextureFX(var3);
        }

        if (Config.isAnimatedTerrain())
        {
            for (var2 = 0; var2 < 256; ++var2)
            {
                this.registerCustomTextureFX("/custom_terrain_" + var2 + ".png", var2, 0);
            }
        }

        if (Config.isAnimatedItems())
        {
            for (var2 = 0; var2 < 256; ++var2)
            {
                this.registerCustomTextureFX("/custom_item_" + var2 + ".png", var2, 1);
            }
        }
    }

    private void unregisterTextureFX(TextureFX var1)
    {
        for (int var2 = 0; var2 < this.textureList.size(); ++var2)
        {
            TextureFX var3 = (TextureFX)this.textureList.get(var2);

            if (var3 == var1)
            {
                this.textureList.remove(var2);
                --var2;
            }
        }
    }

    private TextureFX[] getRegisteredTexturesFX(Class var1)
    {
        ArrayList var2 = new ArrayList();

        for (int var3 = 0; var3 < this.textureList.size(); ++var3)
        {
            TextureFX var4 = (TextureFX)this.textureList.get(var3);

            if (var1.isAssignableFrom(var4.getClass()))
            {
                var2.add(var4);
            }
        }

        TextureFX[] var5 = (TextureFX[])((TextureFX[])var2.toArray(new TextureFX[var2.size()]));
        return var5;
    }

    private void registerCustomTextureFX(String var1, int var2, int var3)
    {
        Object var4 = null;
        byte[] var5;

        if (var3 == 0)
        {
            var5 = this.getCustomTextureData(var1, Config.getIconWidthTerrain());
        }
        else
        {
            var5 = this.getCustomTextureData(var1, Config.getIconWidthItems());
        }

        if (var5 != null)
        {
            this.registerTextureFX(new TextureHDCustomFX(var2, var3));
        }
    }

    private int getMaxMipmapLevel(int var1)
    {
        int var2;

        for (var2 = 0; var1 > 0; ++var2)
        {
            var1 /= 2;
        }

        return var2 - 1;
    }

    private void copyScaled(byte[] var1, ByteBuffer var2, int var3)
    {
        int var4 = (int)Math.sqrt((double)(var1.length / 4));
        int var5 = var3 / var4;
        byte[] var6 = new byte[4];
        int var7 = var3 * var3;
        var2.clear();

        if (var5 > 1)
        {
            for (int var8 = 0; var8 < var4; ++var8)
            {
                int var9 = var8 * var4;
                int var10 = var8 * var5;
                int var11 = var10 * var3;

                for (int var12 = 0; var12 < var4; ++var12)
                {
                    int var13 = (var12 + var9) * 4;
                    var6[0] = var1[var13];
                    var6[1] = var1[var13 + 1];
                    var6[2] = var1[var13 + 2];
                    var6[3] = var1[var13 + 3];
                    int var14 = var12 * var5;
                    int var15 = var14 + var11;

                    for (int var16 = 0; var16 < var5; ++var16)
                    {
                        int var17 = var15 + var16 * var3;
                        var2.position(var17 * 4);

                        for (int var18 = 0; var18 < var5; ++var18)
                        {
                            var2.put(var6);
                        }
                    }
                }
            }
        }

        var2.position(0).limit(var3 * var3 * 4);
    }

    private boolean scalesWithFastColor(TextureFX var1)
    {
        return !var1.getClass().getName().equals("ModTextureStatic");
    }

    public TexturePackList getTexturePack()
    {
        return this.texturePack;
    }
}