    001package net.minecraft.client.renderer;
    002
    003import cpw.mods.fml.relauncher.Side;
    004import cpw.mods.fml.relauncher.SideOnly;
    005import java.awt.image.BufferedImage;
    006import java.nio.FloatBuffer;
    007import java.util.List;
    008import java.util.Random;
    009import net.minecraft.block.Block;
    010import net.minecraft.block.material.Material;
    011import net.minecraft.client.Minecraft;
    012import net.minecraft.client.entity.EntityPlayerSP;
    013import net.minecraft.client.gui.ScaledResolution;
    014import net.minecraft.client.multiplayer.WorldClient;
    015import net.minecraft.client.particle.EffectRenderer;
    016import net.minecraft.client.particle.EntityRainFX;
    017import net.minecraft.client.particle.EntitySmokeFX;
    018import net.minecraft.client.renderer.culling.ClippingHelperImpl;
    019import net.minecraft.client.renderer.culling.Frustrum;
    020import net.minecraft.crash.CrashReport;
    021import net.minecraft.crash.CrashReportCategory;
    022import net.minecraft.entity.Entity;
    023import net.minecraft.entity.EntityLiving;
    024import net.minecraft.entity.boss.BossStatus;
    025import net.minecraft.entity.player.EntityPlayer;
    026import net.minecraft.potion.Potion;
    027import net.minecraft.util.AxisAlignedBB;
    028import net.minecraft.util.MathHelper;
    029import net.minecraft.util.MouseFilter;
    030import net.minecraft.util.MovingObjectPosition;
    031import net.minecraft.util.ReportedException;
    032import net.minecraft.util.Vec3;
    033import net.minecraft.world.biome.BiomeGenBase;
    034import org.lwjgl.input.Mouse;
    035import org.lwjgl.opengl.Display;
    036import org.lwjgl.opengl.GL11;
    037import org.lwjgl.opengl.GLContext;
    038import org.lwjgl.util.glu.GLU;
    039
    040import net.minecraftforge.client.ForgeHooksClient;
    041import net.minecraftforge.client.event.DrawBlockHighlightEvent;
    042import net.minecraftforge.client.event.RenderWorldLastEvent;
    043import net.minecraftforge.common.MinecraftForge;
    044
    045@SideOnly(Side.CLIENT)
    046public class EntityRenderer
    047{
    048    public static boolean anaglyphEnable = false;
    049
    050    /** Anaglyph field (0=R, 1=GB) */
    051    public static int anaglyphField;
    052
    053    /** A reference to the Minecraft object. */
    054    private Minecraft mc;
    055    private float farPlaneDistance = 0.0F;
    056    public ItemRenderer itemRenderer;
    057
    058    /** Entity renderer update count */
    059    private int rendererUpdateCount;
    060
    061    /** Pointed entity */
    062    private Entity pointedEntity = null;
    063    private MouseFilter mouseFilterXAxis = new MouseFilter();
    064    private MouseFilter mouseFilterYAxis = new MouseFilter();
    065
    066    /** Mouse filter dummy 1 */
    067    private MouseFilter mouseFilterDummy1 = new MouseFilter();
    068
    069    /** Mouse filter dummy 2 */
    070    private MouseFilter mouseFilterDummy2 = new MouseFilter();
    071
    072    /** Mouse filter dummy 3 */
    073    private MouseFilter mouseFilterDummy3 = new MouseFilter();
    074
    075    /** Mouse filter dummy 4 */
    076    private MouseFilter mouseFilterDummy4 = new MouseFilter();
    077    private float thirdPersonDistance = 4.0F;
    078
    079    /** Third person distance temp */
    080    private float thirdPersonDistanceTemp = 4.0F;
    081    private float debugCamYaw = 0.0F;
    082    private float prevDebugCamYaw = 0.0F;
    083    private float debugCamPitch = 0.0F;
    084    private float prevDebugCamPitch = 0.0F;
    085
    086    /** Smooth cam yaw */
    087    private float smoothCamYaw;
    088
    089    /** Smooth cam pitch */
    090    private float smoothCamPitch;
    091
    092    /** Smooth cam filter X */
    093    private float smoothCamFilterX;
    094
    095    /** Smooth cam filter Y */
    096    private float smoothCamFilterY;
    097
    098    /** Smooth cam partial ticks */
    099    private float smoothCamPartialTicks;
    100    private float debugCamFOV = 0.0F;
    101    private float prevDebugCamFOV = 0.0F;
    102    private float camRoll = 0.0F;
    103    private float prevCamRoll = 0.0F;
    104
    105    /**
    106     * The texture id of the blocklight/skylight texture used for lighting effects
    107     */
    108    public int lightmapTexture;
    109
    110    /**
    111     * Colors computed in updateLightmap() and loaded into the lightmap emptyTexture
    112     */
    113    private int[] lightmapColors;
    114
    115    /** FOV modifier hand */
    116    private float fovModifierHand;
    117
    118    /** FOV modifier hand prev */
    119    private float fovModifierHandPrev;
    120
    121    /** FOV multiplier temp */
    122    private float fovMultiplierTemp;
    123    private float field_82831_U;
    124    private float field_82832_V;
    125
    126    /** Cloud fog mode */
    127    private boolean cloudFog = false;
    128    private double cameraZoom = 1.0D;
    129    private double cameraYaw = 0.0D;
    130    private double cameraPitch = 0.0D;
    131
    132    /** Previous frame time in milliseconds */
    133    private long prevFrameTime = Minecraft.getSystemTime();
    134
    135    /** End time of last render (ns) */
    136    private long renderEndNanoTime = 0L;
    137
    138    /**
    139     * Is set, updateCameraAndRender() calls updateLightmap(); set by updateTorchFlicker()
    140     */
    141    private boolean lightmapUpdateNeeded = false;
    142
    143    /** Torch flicker X */
    144    float torchFlickerX = 0.0F;
    145
    146    /** Torch flicker DX */
    147    float torchFlickerDX = 0.0F;
    148
    149    /** Torch flicker Y */
    150    float torchFlickerY = 0.0F;
    151
    152    /** Torch flicker DY */
    153    float torchFlickerDY = 0.0F;
    154    private Random random = new Random();
    155
    156    /** Rain sound counter */
    157    private int rainSoundCounter = 0;
    158
    159    /** Rain X coords */
    160    float[] rainXCoords;
    161
    162    /** Rain Y coords */
    163    float[] rainYCoords;
    164    volatile int field_78523_k = 0;
    165    volatile int field_78520_l = 0;
    166
    167    /** Fog color buffer */
    168    FloatBuffer fogColorBuffer = GLAllocation.createDirectFloatBuffer(16);
    169
    170    /** red component of the fog color */
    171    float fogColorRed;
    172
    173    /** green component of the fog color */
    174    float fogColorGreen;
    175
    176    /** blue component of the fog color */
    177    float fogColorBlue;
    178
    179    /** Fog color 2 */
    180    private float fogColor2;
    181
    182    /** Fog color 1 */
    183    private float fogColor1;
    184
    185    /**
    186     * Debug view direction (0=OFF, 1=Front, 2=Right, 3=Back, 4=Left, 5=TiltLeft, 6=TiltRight)
    187     */
    188    public int debugViewDirection;
    189
    190    public EntityRenderer(Minecraft par1Minecraft)
    191    {
    192        this.mc = par1Minecraft;
    193        this.itemRenderer = new ItemRenderer(par1Minecraft);
    194        this.lightmapTexture = par1Minecraft.renderEngine.allocateAndSetupTexture(new BufferedImage(16, 16, 1));
    195        this.lightmapColors = new int[256];
    196    }
    197
    198    /**
    199     * Updates the entity renderer
    200     */
    201    public void updateRenderer()
    202    {
    203        this.updateFovModifierHand();
    204        this.updateTorchFlicker();
    205        this.fogColor2 = this.fogColor1;
    206        this.thirdPersonDistanceTemp = this.thirdPersonDistance;
    207        this.prevDebugCamYaw = this.debugCamYaw;
    208        this.prevDebugCamPitch = this.debugCamPitch;
    209        this.prevDebugCamFOV = this.debugCamFOV;
    210        this.prevCamRoll = this.camRoll;
    211        float var1;
    212        float var2;
    213
    214        if (this.mc.gameSettings.smoothCamera)
    215        {
    216            var1 = this.mc.gameSettings.mouseSensitivity * 0.6F + 0.2F;
    217            var2 = var1 * var1 * var1 * 8.0F;
    218            this.smoothCamFilterX = this.mouseFilterXAxis.smooth(this.smoothCamYaw, 0.05F * var2);
    219            this.smoothCamFilterY = this.mouseFilterYAxis.smooth(this.smoothCamPitch, 0.05F * var2);
    220            this.smoothCamPartialTicks = 0.0F;
    221            this.smoothCamYaw = 0.0F;
    222            this.smoothCamPitch = 0.0F;
    223        }
    224
    225        if (this.mc.renderViewEntity == null)
    226        {
    227            this.mc.renderViewEntity = this.mc.thePlayer;
    228        }
    229
    230        var1 = this.mc.theWorld.getLightBrightness(MathHelper.floor_double(this.mc.renderViewEntity.posX), MathHelper.floor_double(this.mc.renderViewEntity.posY), MathHelper.floor_double(this.mc.renderViewEntity.posZ));
    231        var2 = (float)(3 - this.mc.gameSettings.renderDistance) / 3.0F;
    232        float var3 = var1 * (1.0F - var2) + var2;
    233        this.fogColor1 += (var3 - this.fogColor1) * 0.1F;
    234        ++this.rendererUpdateCount;
    235        this.itemRenderer.updateEquippedItem();
    236        this.addRainParticles();
    237        this.field_82832_V = this.field_82831_U;
    238
    239        if (BossStatus.field_82825_d)
    240        {
    241            this.field_82831_U += 0.05F;
    242
    243            if (this.field_82831_U > 1.0F)
    244            {
    245                this.field_82831_U = 1.0F;
    246            }
    247
    248            BossStatus.field_82825_d = false;
    249        }
    250        else if (this.field_82831_U > 0.0F)
    251        {
    252            this.field_82831_U -= 0.0125F;
    253        }
    254    }
    255
    256    /**
    257     * Finds what block or object the mouse is over at the specified partial tick time. Args: partialTickTime
    258     */
    259    public void getMouseOver(float par1)
    260    {
    261        if (this.mc.renderViewEntity != null)
    262        {
    263            if (this.mc.theWorld != null)
    264            {
    265                double var2 = (double)this.mc.playerController.getBlockReachDistance();
    266                this.mc.objectMouseOver = this.mc.renderViewEntity.rayTrace(var2, par1);
    267                double var4 = var2;
    268                Vec3 var6 = this.mc.renderViewEntity.getPosition(par1);
    269
    270                if (this.mc.playerController.extendedReach())
    271                {
    272                    var2 = 6.0D;
    273                    var4 = 6.0D;
    274                }
    275                else
    276                {
    277                    if (var2 > 3.0D)
    278                    {
    279                        var4 = 3.0D;
    280                    }
    281
    282                    var2 = var4;
    283                }
    284
    285                if (this.mc.objectMouseOver != null)
    286                {
    287                    var4 = this.mc.objectMouseOver.hitVec.distanceTo(var6);
    288                }
    289
    290                Vec3 var7 = this.mc.renderViewEntity.getLook(par1);
    291                Vec3 var8 = var6.addVector(var7.xCoord * var2, var7.yCoord * var2, var7.zCoord * var2);
    292                this.pointedEntity = null;
    293                float var9 = 1.0F;
    294                List var10 = this.mc.theWorld.getEntitiesWithinAABBExcludingEntity(this.mc.renderViewEntity, this.mc.renderViewEntity.boundingBox.addCoord(var7.xCoord * var2, var7.yCoord * var2, var7.zCoord * var2).expand((double)var9, (double)var9, (double)var9));
    295                double var11 = var4;
    296
    297                for (int var13 = 0; var13 < var10.size(); ++var13)
    298                {
    299                    Entity var14 = (Entity)var10.get(var13);
    300
    301                    if (var14.canBeCollidedWith())
    302                    {
    303                        float var15 = var14.getCollisionBorderSize();
    304                        AxisAlignedBB var16 = var14.boundingBox.expand((double)var15, (double)var15, (double)var15);
    305                        MovingObjectPosition var17 = var16.calculateIntercept(var6, var8);
    306
    307                        if (var16.isVecInside(var6))
    308                        {
    309                            if (0.0D < var11 || var11 == 0.0D)
    310                            {
    311                                this.pointedEntity = var14;
    312                                var11 = 0.0D;
    313                            }
    314                        }
    315                        else if (var17 != null)
    316                        {
    317                            double var18 = var6.distanceTo(var17.hitVec);
    318
    319                            if (var18 < var11 || var11 == 0.0D)
    320                            {
    321                                this.pointedEntity = var14;
    322                                var11 = var18;
    323                            }
    324                        }
    325                    }
    326                }
    327
    328                if (this.pointedEntity != null && (var11 < var4 || this.mc.objectMouseOver == null))
    329                {
    330                    this.mc.objectMouseOver = new MovingObjectPosition(this.pointedEntity);
    331                }
    332            }
    333        }
    334    }
    335
    336    /**
    337     * Update FOV modifier hand
    338     */
    339    private void updateFovModifierHand()
    340    {
    341        if (mc.renderViewEntity instanceof EntityPlayerSP)
    342        {
    343            EntityPlayerSP var1 = (EntityPlayerSP)this.mc.renderViewEntity;
    344            this.fovMultiplierTemp = var1.getFOVMultiplier();
    345        }
    346        else
    347        {
    348            this.fovMultiplierTemp = mc.thePlayer.getFOVMultiplier();
    349        }
    350        this.fovModifierHandPrev = this.fovModifierHand;
    351        this.fovModifierHand += (this.fovMultiplierTemp - this.fovModifierHand) * 0.5F;
    352    }
    353
    354    /**
    355     * Changes the field of view of the player depending on if they are underwater or not
    356     */
    357    private float getFOVModifier(float par1, boolean par2)
    358    {
    359        if (this.debugViewDirection > 0)
    360        {
    361            return 90.0F;
    362        }
    363        else
    364        {
    365            EntityLiving var3 = (EntityLiving)this.mc.renderViewEntity;
    366            float var4 = 70.0F;
    367
    368            if (par2)
    369            {
    370                var4 += this.mc.gameSettings.fovSetting * 40.0F;
    371                var4 *= this.fovModifierHandPrev + (this.fovModifierHand - this.fovModifierHandPrev) * par1;
    372            }
    373
    374            if (var3.getHealth() <= 0)
    375            {
    376                float var5 = (float)var3.deathTime + par1;
    377                var4 /= (1.0F - 500.0F / (var5 + 500.0F)) * 2.0F + 1.0F;
    378            }
    379
    380            int var6 = ActiveRenderInfo.getBlockIdAtEntityViewpoint(this.mc.theWorld, var3, par1);
    381
    382            if (var6 != 0 && Block.blocksList[var6].blockMaterial == Material.water)
    383            {
    384                var4 = var4 * 60.0F / 70.0F;
    385            }
    386
    387            return var4 + this.prevDebugCamFOV + (this.debugCamFOV - this.prevDebugCamFOV) * par1;
    388        }
    389    }
    390
    391    private void hurtCameraEffect(float par1)
    392    {
    393        EntityLiving var2 = this.mc.renderViewEntity;
    394        float var3 = (float)var2.hurtTime - par1;
    395        float var4;
    396
    397        if (var2.getHealth() <= 0)
    398        {
    399            var4 = (float)var2.deathTime + par1;
    400            GL11.glRotatef(40.0F - 8000.0F / (var4 + 200.0F), 0.0F, 0.0F, 1.0F);
    401        }
    402
    403        if (var3 >= 0.0F)
    404        {
    405            var3 /= (float)var2.maxHurtTime;
    406            var3 = MathHelper.sin(var3 * var3 * var3 * var3 * (float)Math.PI);
    407            var4 = var2.attackedAtYaw;
    408            GL11.glRotatef(-var4, 0.0F, 1.0F, 0.0F);
    409            GL11.glRotatef(-var3 * 14.0F, 0.0F, 0.0F, 1.0F);
    410            GL11.glRotatef(var4, 0.0F, 1.0F, 0.0F);
    411        }
    412    }
    413
    414    /**
    415     * Setups all the GL settings for view bobbing. Args: partialTickTime
    416     */
    417    private void setupViewBobbing(float par1)
    418    {
    419        if (this.mc.renderViewEntity instanceof EntityPlayer)
    420        {
    421            EntityPlayer var2 = (EntityPlayer)this.mc.renderViewEntity;
    422            float var3 = var2.distanceWalkedModified - var2.prevDistanceWalkedModified;
    423            float var4 = -(var2.distanceWalkedModified + var3 * par1);
    424            float var5 = var2.prevCameraYaw + (var2.cameraYaw - var2.prevCameraYaw) * par1;
    425            float var6 = var2.prevCameraPitch + (var2.cameraPitch - var2.prevCameraPitch) * par1;
    426            GL11.glTranslatef(MathHelper.sin(var4 * (float)Math.PI) * var5 * 0.5F, -Math.abs(MathHelper.cos(var4 * (float)Math.PI) * var5), 0.0F);
    427            GL11.glRotatef(MathHelper.sin(var4 * (float)Math.PI) * var5 * 3.0F, 0.0F, 0.0F, 1.0F);
    428            GL11.glRotatef(Math.abs(MathHelper.cos(var4 * (float)Math.PI - 0.2F) * var5) * 5.0F, 1.0F, 0.0F, 0.0F);
    429            GL11.glRotatef(var6, 1.0F, 0.0F, 0.0F);
    430        }
    431    }
    432
    433    /**
    434     * sets up player's eye (or camera in third person mode)
    435     */
    436    private void orientCamera(float par1)
    437    {
    438        EntityLiving var2 = this.mc.renderViewEntity;
    439        float var3 = var2.yOffset - 1.62F;
    440        double var4 = var2.prevPosX + (var2.posX - var2.prevPosX) * (double)par1;
    441        double var6 = var2.prevPosY + (var2.posY - var2.prevPosY) * (double)par1 - (double)var3;
    442        double var8 = var2.prevPosZ + (var2.posZ - var2.prevPosZ) * (double)par1;
    443        GL11.glRotatef(this.prevCamRoll + (this.camRoll - this.prevCamRoll) * par1, 0.0F, 0.0F, 1.0F);
    444
    445        if (var2.isPlayerSleeping())
    446        {
    447            var3 = (float)((double)var3 + 1.0D);
    448            GL11.glTranslatef(0.0F, 0.3F, 0.0F);
    449
    450            if (!this.mc.gameSettings.debugCamEnable)
    451            {
    452                ForgeHooksClient.orientBedCamera(mc, var2);
    453                GL11.glRotatef(var2.prevRotationYaw + (var2.rotationYaw - var2.prevRotationYaw) * par1 + 180.0F, 0.0F, -1.0F, 0.0F);
    454                GL11.glRotatef(var2.prevRotationPitch + (var2.rotationPitch - var2.prevRotationPitch) * par1, -1.0F, 0.0F, 0.0F);
    455            }
    456        }
    457        else if (this.mc.gameSettings.thirdPersonView > 0)
    458        {
    459            double var27 = (double)(this.thirdPersonDistanceTemp + (this.thirdPersonDistance - this.thirdPersonDistanceTemp) * par1);
    460            float var13;
    461            float var28;
    462
    463            if (this.mc.gameSettings.debugCamEnable)
    464            {
    465                var28 = this.prevDebugCamYaw + (this.debugCamYaw - this.prevDebugCamYaw) * par1;
    466                var13 = this.prevDebugCamPitch + (this.debugCamPitch - this.prevDebugCamPitch) * par1;
    467                GL11.glTranslatef(0.0F, 0.0F, (float)(-var27));
    468                GL11.glRotatef(var13, 1.0F, 0.0F, 0.0F);
    469                GL11.glRotatef(var28, 0.0F, 1.0F, 0.0F);
    470            }
    471            else
    472            {
    473                var28 = var2.rotationYaw;
    474                var13 = var2.rotationPitch;
    475
    476                if (this.mc.gameSettings.thirdPersonView == 2)
    477                {
    478                    var13 += 180.0F;
    479                }
    480
    481                double var14 = (double)(-MathHelper.sin(var28 / 180.0F * (float)Math.PI) * MathHelper.cos(var13 / 180.0F * (float)Math.PI)) * var27;
    482                double var16 = (double)(MathHelper.cos(var28 / 180.0F * (float)Math.PI) * MathHelper.cos(var13 / 180.0F * (float)Math.PI)) * var27;
    483                double var18 = (double)(-MathHelper.sin(var13 / 180.0F * (float)Math.PI)) * var27;
    484
    485                for (int var20 = 0; var20 < 8; ++var20)
    486                {
    487                    float var21 = (float)((var20 & 1) * 2 - 1);
    488                    float var22 = (float)((var20 >> 1 & 1) * 2 - 1);
    489                    float var23 = (float)((var20 >> 2 & 1) * 2 - 1);
    490                    var21 *= 0.1F;
    491                    var22 *= 0.1F;
    492                    var23 *= 0.1F;
    493                    MovingObjectPosition var24 = this.mc.theWorld.rayTraceBlocks(this.mc.theWorld.getWorldVec3Pool().getVecFromPool(var4 + (double)var21, var6 + (double)var22, var8 + (double)var23), this.mc.theWorld.getWorldVec3Pool().getVecFromPool(var4 - var14 + (double)var21 + (double)var23, var6 - var18 + (double)var22, var8 - var16 + (double)var23));
    494
    495                    if (var24 != null)
    496                    {
    497                        double var25 = var24.hitVec.distanceTo(this.mc.theWorld.getWorldVec3Pool().getVecFromPool(var4, var6, var8));
    498
    499                        if (var25 < var27)
    500                        {
    501                            var27 = var25;
    502                        }
    503                    }
    504                }
    505
    506                if (this.mc.gameSettings.thirdPersonView == 2)
    507                {
    508                    GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);
    509                }
    510
    511                GL11.glRotatef(var2.rotationPitch - var13, 1.0F, 0.0F, 0.0F);
    512                GL11.glRotatef(var2.rotationYaw - var28, 0.0F, 1.0F, 0.0F);
    513                GL11.glTranslatef(0.0F, 0.0F, (float)(-var27));
    514                GL11.glRotatef(var28 - var2.rotationYaw, 0.0F, 1.0F, 0.0F);
    515                GL11.glRotatef(var13 - var2.rotationPitch, 1.0F, 0.0F, 0.0F);
    516            }
    517        }
    518        else
    519        {
    520            GL11.glTranslatef(0.0F, 0.0F, -0.1F);
    521        }
    522
    523        if (!this.mc.gameSettings.debugCamEnable)
    524        {
    525            GL11.glRotatef(var2.prevRotationPitch + (var2.rotationPitch - var2.prevRotationPitch) * par1, 1.0F, 0.0F, 0.0F);
    526            GL11.glRotatef(var2.prevRotationYaw + (var2.rotationYaw - var2.prevRotationYaw) * par1 + 180.0F, 0.0F, 1.0F, 0.0F);
    527        }
    528
    529        GL11.glTranslatef(0.0F, var3, 0.0F);
    530        var4 = var2.prevPosX + (var2.posX - var2.prevPosX) * (double)par1;
    531        var6 = var2.prevPosY + (var2.posY - var2.prevPosY) * (double)par1 - (double)var3;
    532        var8 = var2.prevPosZ + (var2.posZ - var2.prevPosZ) * (double)par1;
    533        this.cloudFog = this.mc.renderGlobal.hasCloudFog(var4, var6, var8, par1);
    534    }
    535
    536    /**
    537     * sets up projection, view effects, camera position/rotation
    538     */
    539    private void setupCameraTransform(float par1, int par2)
    540    {
    541        this.farPlaneDistance = (float)(256 >> this.mc.gameSettings.renderDistance);
    542        GL11.glMatrixMode(GL11.GL_PROJECTION);
    543        GL11.glLoadIdentity();
    544        float var3 = 0.07F;
    545
    546        if (this.mc.gameSettings.anaglyph)
    547        {
    548            GL11.glTranslatef((float)(-(par2 * 2 - 1)) * var3, 0.0F, 0.0F);
    549        }
    550
    551        if (this.cameraZoom != 1.0D)
    552        {
    553            GL11.glTranslatef((float)this.cameraYaw, (float)(-this.cameraPitch), 0.0F);
    554            GL11.glScaled(this.cameraZoom, this.cameraZoom, 1.0D);
    555        }
    556
    557        GLU.gluPerspective(this.getFOVModifier(par1, true), (float)this.mc.displayWidth / (float)this.mc.displayHeight, 0.05F, this.farPlaneDistance * 2.0F);
    558        float var4;
    559
    560        if (this.mc.playerController.func_78747_a())
    561        {
    562            var4 = 0.6666667F;
    563            GL11.glScalef(1.0F, var4, 1.0F);
    564        }
    565
    566        GL11.glMatrixMode(GL11.GL_MODELVIEW);
    567        GL11.glLoadIdentity();
    568
    569        if (this.mc.gameSettings.anaglyph)
    570        {
    571            GL11.glTranslatef((float)(par2 * 2 - 1) * 0.1F, 0.0F, 0.0F);
    572        }
    573
    574        this.hurtCameraEffect(par1);
    575
    576        if (this.mc.gameSettings.viewBobbing)
    577        {
    578            this.setupViewBobbing(par1);
    579        }
    580
    581        var4 = this.mc.thePlayer.prevTimeInPortal + (this.mc.thePlayer.timeInPortal - this.mc.thePlayer.prevTimeInPortal) * par1;
    582
    583        if (var4 > 0.0F)
    584        {
    585            byte var5 = 20;
    586
    587            if (this.mc.thePlayer.isPotionActive(Potion.confusion))
    588            {
    589                var5 = 7;
    590            }
    591
    592            float var6 = 5.0F / (var4 * var4 + 5.0F) - var4 * 0.04F;
    593            var6 *= var6;
    594            GL11.glRotatef(((float)this.rendererUpdateCount + par1) * (float)var5, 0.0F, 1.0F, 1.0F);
    595            GL11.glScalef(1.0F / var6, 1.0F, 1.0F);
    596            GL11.glRotatef(-((float)this.rendererUpdateCount + par1) * (float)var5, 0.0F, 1.0F, 1.0F);
    597        }
    598
    599        this.orientCamera(par1);
    600
    601        if (this.debugViewDirection > 0)
    602        {
    603            int var7 = this.debugViewDirection - 1;
    604
    605            if (var7 == 1)
    606            {
    607                GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
    608            }
    609
    610            if (var7 == 2)
    611            {
    612                GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);
    613            }
    614
    615            if (var7 == 3)
    616            {
    617                GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
    618            }
    619
    620            if (var7 == 4)
    621            {
    622                GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
    623            }
    624
    625            if (var7 == 5)
    626            {
    627                GL11.glRotatef(-90.0F, 1.0F, 0.0F, 0.0F);
    628            }
    629        }
    630    }
    631
    632    /**
    633     * Render player hand
    634     */
    635    private void renderHand(float par1, int par2)
    636    {
    637        if (this.debugViewDirection <= 0)
    638        {
    639            GL11.glMatrixMode(GL11.GL_PROJECTION);
    640            GL11.glLoadIdentity();
    641            float var3 = 0.07F;
    642
    643            if (this.mc.gameSettings.anaglyph)
    644            {
    645                GL11.glTranslatef((float)(-(par2 * 2 - 1)) * var3, 0.0F, 0.0F);
    646            }
    647
    648            if (this.cameraZoom != 1.0D)
    649            {
    650                GL11.glTranslatef((float)this.cameraYaw, (float)(-this.cameraPitch), 0.0F);
    651                GL11.glScaled(this.cameraZoom, this.cameraZoom, 1.0D);
    652            }
    653
    654            GLU.gluPerspective(this.getFOVModifier(par1, false), (float)this.mc.displayWidth / (float)this.mc.displayHeight, 0.05F, this.farPlaneDistance * 2.0F);
    655
    656            if (this.mc.playerController.func_78747_a())
    657            {
    658                float var4 = 0.6666667F;
    659                GL11.glScalef(1.0F, var4, 1.0F);
    660            }
    661
    662            GL11.glMatrixMode(GL11.GL_MODELVIEW);
    663            GL11.glLoadIdentity();
    664
    665            if (this.mc.gameSettings.anaglyph)
    666            {
    667                GL11.glTranslatef((float)(par2 * 2 - 1) * 0.1F, 0.0F, 0.0F);
    668            }
    669
    670            GL11.glPushMatrix();
    671            this.hurtCameraEffect(par1);
    672
    673            if (this.mc.gameSettings.viewBobbing)
    674            {
    675                this.setupViewBobbing(par1);
    676            }
    677
    678            if (this.mc.gameSettings.thirdPersonView == 0 && !this.mc.renderViewEntity.isPlayerSleeping() && !this.mc.gameSettings.hideGUI && !this.mc.playerController.func_78747_a())
    679            {
    680                this.enableLightmap((double)par1);
    681                this.itemRenderer.renderItemInFirstPerson(par1);
    682                this.disableLightmap((double)par1);
    683            }
    684
    685            GL11.glPopMatrix();
    686
    687            if (this.mc.gameSettings.thirdPersonView == 0 && !this.mc.renderViewEntity.isPlayerSleeping())
    688            {
    689                this.itemRenderer.renderOverlays(par1);
    690                this.hurtCameraEffect(par1);
    691            }
    692
    693            if (this.mc.gameSettings.viewBobbing)
    694            {
    695                this.setupViewBobbing(par1);
    696            }
    697        }
    698    }
    699
    700    /**
    701     * Disable secondary texture unit used by lightmap
    702     */
    703    public void disableLightmap(double par1)
    704    {
    705        OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit);
    706        GL11.glDisable(GL11.GL_TEXTURE_2D);
    707        OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);
    708    }
    709
    710    /**
    711     * Enable lightmap in secondary texture unit
    712     */
    713    public void enableLightmap(double par1)
    714    {
    715        OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit);
    716        GL11.glMatrixMode(GL11.GL_TEXTURE);
    717        GL11.glLoadIdentity();
    718        float var3 = 0.00390625F;
    719        GL11.glScalef(var3, var3, var3);
    720        GL11.glTranslatef(8.0F, 8.0F, 8.0F);
    721        GL11.glMatrixMode(GL11.GL_MODELVIEW);
    722        this.mc.renderEngine.bindTexture(this.lightmapTexture);
    723        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    724        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    725        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    726        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    727        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP);
    728        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP);
    729        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    730        GL11.glEnable(GL11.GL_TEXTURE_2D);
    731        OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);
    732    }
    733
    734    /**
    735     * Recompute a random value that is applied to block color in updateLightmap()
    736     */
    737    private void updateTorchFlicker()
    738    {
    739        this.torchFlickerDX = (float)((double)this.torchFlickerDX + (Math.random() - Math.random()) * Math.random() * Math.random());
    740        this.torchFlickerDY = (float)((double)this.torchFlickerDY + (Math.random() - Math.random()) * Math.random() * Math.random());
    741        this.torchFlickerDX = (float)((double)this.torchFlickerDX * 0.9D);
    742        this.torchFlickerDY = (float)((double)this.torchFlickerDY * 0.9D);
    743        this.torchFlickerX += (this.torchFlickerDX - this.torchFlickerX) * 1.0F;
    744        this.torchFlickerY += (this.torchFlickerDY - this.torchFlickerY) * 1.0F;
    745        this.lightmapUpdateNeeded = true;
    746    }
    747
    748    private void updateLightmap(float par1)
    749    {
    750        WorldClient var2 = this.mc.theWorld;
    751
    752        if (var2 != null)
    753        {
    754            for (int var3 = 0; var3 < 256; ++var3)
    755            {
    756                float var4 = var2.getSunBrightness(1.0F) * 0.95F + 0.05F;
    757                float var5 = var2.provider.lightBrightnessTable[var3 / 16] * var4;
    758                float var6 = var2.provider.lightBrightnessTable[var3 % 16] * (this.torchFlickerX * 0.1F + 1.5F);
    759
    760                if (var2.lastLightningBolt > 0)
    761                {
    762                    var5 = var2.provider.lightBrightnessTable[var3 / 16];
    763                }
    764
    765                float var7 = var5 * (var2.getSunBrightness(1.0F) * 0.65F + 0.35F);
    766                float var8 = var5 * (var2.getSunBrightness(1.0F) * 0.65F + 0.35F);
    767                float var11 = var6 * ((var6 * 0.6F + 0.4F) * 0.6F + 0.4F);
    768                float var12 = var6 * (var6 * var6 * 0.6F + 0.4F);
    769                float var13 = var7 + var6;
    770                float var14 = var8 + var11;
    771                float var15 = var5 + var12;
    772                var13 = var13 * 0.96F + 0.03F;
    773                var14 = var14 * 0.96F + 0.03F;
    774                var15 = var15 * 0.96F + 0.03F;
    775                float var16;
    776
    777                if (this.field_82831_U > 0.0F)
    778                {
    779                    var16 = this.field_82832_V + (this.field_82831_U - this.field_82832_V) * par1;
    780                    var13 = var13 * (1.0F - var16) + var13 * 0.7F * var16;
    781                    var14 = var14 * (1.0F - var16) + var14 * 0.6F * var16;
    782                    var15 = var15 * (1.0F - var16) + var15 * 0.6F * var16;
    783                }
    784
    785                if (var2.provider.dimensionId == 1)
    786                {
    787                    var13 = 0.22F + var6 * 0.75F;
    788                    var14 = 0.28F + var11 * 0.75F;
    789                    var15 = 0.25F + var12 * 0.75F;
    790                }
    791
    792                float var17;
    793
    794                if (this.mc.thePlayer.isPotionActive(Potion.nightVision))
    795                {
    796                    var16 = this.getNightVisionBrightness(this.mc.thePlayer, par1);
    797                    var17 = 1.0F / var13;
    798
    799                    if (var17 > 1.0F / var14)
    800                    {
    801                        var17 = 1.0F / var14;
    802                    }
    803
    804                    if (var17 > 1.0F / var15)
    805                    {
    806                        var17 = 1.0F / var15;
    807                    }
    808
    809                    var13 = var13 * (1.0F - var16) + var13 * var17 * var16;
    810                    var14 = var14 * (1.0F - var16) + var14 * var17 * var16;
    811                    var15 = var15 * (1.0F - var16) + var15 * var17 * var16;
    812                }
    813
    814                if (var13 > 1.0F)
    815                {
    816                    var13 = 1.0F;
    817                }
    818
    819                if (var14 > 1.0F)
    820                {
    821                    var14 = 1.0F;
    822                }
    823
    824                if (var15 > 1.0F)
    825                {
    826                    var15 = 1.0F;
    827                }
    828
    829                var16 = this.mc.gameSettings.gammaSetting;
    830                var17 = 1.0F - var13;
    831                float var18 = 1.0F - var14;
    832                float var19 = 1.0F - var15;
    833                var17 = 1.0F - var17 * var17 * var17 * var17;
    834                var18 = 1.0F - var18 * var18 * var18 * var18;
    835                var19 = 1.0F - var19 * var19 * var19 * var19;
    836                var13 = var13 * (1.0F - var16) + var17 * var16;
    837                var14 = var14 * (1.0F - var16) + var18 * var16;
    838                var15 = var15 * (1.0F - var16) + var19 * var16;
    839                var13 = var13 * 0.96F + 0.03F;
    840                var14 = var14 * 0.96F + 0.03F;
    841                var15 = var15 * 0.96F + 0.03F;
    842
    843                if (var13 > 1.0F)
    844                {
    845                    var13 = 1.0F;
    846                }
    847
    848                if (var14 > 1.0F)
    849                {
    850                    var14 = 1.0F;
    851                }
    852
    853                if (var15 > 1.0F)
    854                {
    855                    var15 = 1.0F;
    856                }
    857
    858                if (var13 < 0.0F)
    859                {
    860                    var13 = 0.0F;
    861                }
    862
    863                if (var14 < 0.0F)
    864                {
    865                    var14 = 0.0F;
    866                }
    867
    868                if (var15 < 0.0F)
    869                {
    870                    var15 = 0.0F;
    871                }
    872
    873                short var20 = 255;
    874                int var21 = (int)(var13 * 255.0F);
    875                int var22 = (int)(var14 * 255.0F);
    876                int var23 = (int)(var15 * 255.0F);
    877                this.lightmapColors[var3] = var20 << 24 | var21 << 16 | var22 << 8 | var23;
    878            }
    879
    880            this.mc.renderEngine.createTextureFromBytes(this.lightmapColors, 16, 16, this.lightmapTexture);
    881        }
    882    }
    883
    884    /**
    885     * Gets the night vision brightness
    886     */
    887    private float getNightVisionBrightness(EntityPlayer par1EntityPlayer, float par2)
    888    {
    889        int var3 = par1EntityPlayer.getActivePotionEffect(Potion.nightVision).getDuration();
    890        return var3 > 200 ? 1.0F : 0.7F + MathHelper.sin(((float)var3 - par2) * (float)Math.PI * 0.2F) * 0.3F;
    891    }
    892
    893    /**
    894     * Will update any inputs that effect the camera angle (mouse) and then render the world and GUI
    895     */
    896    public void updateCameraAndRender(float par1)
    897    {
    898        this.mc.mcProfiler.startSection("lightTex");
    899
    900        if (this.lightmapUpdateNeeded)
    901        {
    902            this.updateLightmap(par1);
    903        }
    904
    905        this.mc.mcProfiler.endSection();
    906        boolean var2 = Display.isActive();
    907
    908        if (!var2 && this.mc.gameSettings.pauseOnLostFocus && (!this.mc.gameSettings.touchscreen || !Mouse.isButtonDown(1)))
    909        {
    910            if (Minecraft.getSystemTime() - this.prevFrameTime > 500L)
    911            {
    912                this.mc.displayInGameMenu();
    913            }
    914        }
    915        else
    916        {
    917            this.prevFrameTime = Minecraft.getSystemTime();
    918        }
    919
    920        this.mc.mcProfiler.startSection("mouse");
    921
    922        if (this.mc.inGameHasFocus && var2)
    923        {
    924            this.mc.mouseHelper.mouseXYChange();
    925            float var3 = this.mc.gameSettings.mouseSensitivity * 0.6F + 0.2F;
    926            float var4 = var3 * var3 * var3 * 8.0F;
    927            float var5 = (float)this.mc.mouseHelper.deltaX * var4;
    928            float var6 = (float)this.mc.mouseHelper.deltaY * var4;
    929            byte var7 = 1;
    930
    931            if (this.mc.gameSettings.invertMouse)
    932            {
    933                var7 = -1;
    934            }
    935
    936            if (this.mc.gameSettings.smoothCamera)
    937            {
    938                this.smoothCamYaw += var5;
    939                this.smoothCamPitch += var6;
    940                float var8 = par1 - this.smoothCamPartialTicks;
    941                this.smoothCamPartialTicks = par1;
    942                var5 = this.smoothCamFilterX * var8;
    943                var6 = this.smoothCamFilterY * var8;
    944                this.mc.thePlayer.setAngles(var5, var6 * (float)var7);
    945            }
    946            else
    947            {
    948                this.mc.thePlayer.setAngles(var5, var6 * (float)var7);
    949            }
    950        }
    951
    952        this.mc.mcProfiler.endSection();
    953
    954        if (!this.mc.skipRenderWorld)
    955        {
    956            anaglyphEnable = this.mc.gameSettings.anaglyph;
    957            ScaledResolution var13 = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
    958            int var14 = var13.getScaledWidth();
    959            int var15 = var13.getScaledHeight();
    960            int var16 = Mouse.getX() * var14 / this.mc.displayWidth;
    961            int var17 = var15 - Mouse.getY() * var15 / this.mc.displayHeight - 1;
    962            int var18 = performanceToFps(this.mc.gameSettings.limitFramerate);
    963
    964            if (this.mc.theWorld != null)
    965            {
    966                this.mc.mcProfiler.startSection("level");
    967
    968                if (this.mc.gameSettings.limitFramerate == 0)
    969                {
    970                    this.renderWorld(par1, 0L);
    971                }
    972                else
    973                {
    974                    this.renderWorld(par1, this.renderEndNanoTime + (long)(1000000000 / var18));
    975                }
    976
    977                this.renderEndNanoTime = System.nanoTime();
    978                this.mc.mcProfiler.endStartSection("gui");
    979
    980                if (!this.mc.gameSettings.hideGUI || this.mc.currentScreen != null)
    981                {
    982                    this.mc.ingameGUI.renderGameOverlay(par1, this.mc.currentScreen != null, var16, var17);
    983                }
    984
    985                this.mc.mcProfiler.endSection();
    986            }
    987            else
    988            {
    989                GL11.glViewport(0, 0, this.mc.displayWidth, this.mc.displayHeight);
    990                GL11.glMatrixMode(GL11.GL_PROJECTION);
    991                GL11.glLoadIdentity();
    992                GL11.glMatrixMode(GL11.GL_MODELVIEW);
    993                GL11.glLoadIdentity();
    994                this.setupOverlayRendering();
    995                this.renderEndNanoTime = System.nanoTime();
    996            }
    997
    998            if (this.mc.currentScreen != null)
    999            {
    1000                GL11.glClear(256);
    1001
    1002                try
    1003                {
    1004                    this.mc.currentScreen.drawScreen(var16, var17, par1);
    1005                }
    1006                catch (Throwable var12)
    1007                {
    1008                    CrashReport var10 = CrashReport.makeCrashReport(var12, "Rendering screen");
    1009                    CrashReportCategory var11 = var10.makeCategory("Screen render details");
    1010                    var11.addCrashSectionCallable("Screen name", new CallableScreenName(this));
    1011                    var11.addCrashSectionCallable("Mouse location", new CallableMouseLocation(this, var16, var17));
    1012                    var11.addCrashSectionCallable("Screen size", new CallableScreenSize(this, var13));
    1013                    throw new ReportedException(var10);
    1014                }
    1015
    1016                if (this.mc.currentScreen != null && this.mc.currentScreen.guiParticles != null)
    1017                {
    1018                    this.mc.currentScreen.guiParticles.draw(par1);
    1019                }
    1020            }
    1021        }
    1022    }
    1023
    1024    public void renderWorld(float par1, long par2)
    1025    {
    1026        this.mc.mcProfiler.startSection("lightTex");
    1027
    1028        if (this.lightmapUpdateNeeded)
    1029        {
    1030            this.updateLightmap(par1);
    1031        }
    1032
    1033        GL11.glEnable(GL11.GL_CULL_FACE);
    1034        GL11.glEnable(GL11.GL_DEPTH_TEST);
    1035
    1036        if (this.mc.renderViewEntity == null)
    1037        {
    1038            this.mc.renderViewEntity = this.mc.thePlayer;
    1039        }
    1040
    1041        this.mc.mcProfiler.endStartSection("pick");
    1042        this.getMouseOver(par1);
    1043        EntityLiving var4 = this.mc.renderViewEntity;
    1044        RenderGlobal var5 = this.mc.renderGlobal;
    1045        EffectRenderer var6 = this.mc.effectRenderer;
    1046        double var7 = var4.lastTickPosX + (var4.posX - var4.lastTickPosX) * (double)par1;
    1047        double var9 = var4.lastTickPosY + (var4.posY - var4.lastTickPosY) * (double)par1;
    1048        double var11 = var4.lastTickPosZ + (var4.posZ - var4.lastTickPosZ) * (double)par1;
    1049        this.mc.mcProfiler.endStartSection("center");
    1050
    1051        for (int var13 = 0; var13 < 2; ++var13)
    1052        {
    1053            if (this.mc.gameSettings.anaglyph)
    1054            {
    1055                anaglyphField = var13;
    1056
    1057                if (anaglyphField == 0)
    1058                {
    1059                    GL11.glColorMask(false, true, true, false);
    1060                }
    1061                else
    1062                {
    1063                    GL11.glColorMask(true, false, false, false);
    1064                }
    1065            }
    1066
    1067            this.mc.mcProfiler.endStartSection("clear");
    1068            GL11.glViewport(0, 0, this.mc.displayWidth, this.mc.displayHeight);
    1069            this.updateFogColor(par1);
    1070            GL11.glClear(16640);
    1071            GL11.glEnable(GL11.GL_CULL_FACE);
    1072            this.mc.mcProfiler.endStartSection("camera");
    1073            this.setupCameraTransform(par1, var13);
    1074            ActiveRenderInfo.updateRenderInfo(this.mc.thePlayer, this.mc.gameSettings.thirdPersonView == 2);
    1075            this.mc.mcProfiler.endStartSection("frustrum");
    1076            ClippingHelperImpl.getInstance();
    1077
    1078            if (this.mc.gameSettings.renderDistance < 2)
    1079            {
    1080                this.setupFog(-1, par1);
    1081                this.mc.mcProfiler.endStartSection("sky");
    1082                var5.renderSky(par1);
    1083            }
    1084
    1085            GL11.glEnable(GL11.GL_FOG);
    1086            this.setupFog(1, par1);
    1087
    1088            if (this.mc.gameSettings.ambientOcclusion)
    1089            {
    1090                GL11.glShadeModel(GL11.GL_SMOOTH);
    1091            }
    1092
    1093            this.mc.mcProfiler.endStartSection("culling");
    1094            Frustrum var14 = new Frustrum();
    1095            var14.setPosition(var7, var9, var11);
    1096            this.mc.renderGlobal.clipRenderersByFrustum(var14, par1);
    1097
    1098            if (var13 == 0)
    1099            {
    1100                this.mc.mcProfiler.endStartSection("updatechunks");
    1101
    1102                while (!this.mc.renderGlobal.updateRenderers(var4, false) && par2 != 0L)
    1103                {
    1104                    long var15 = par2 - System.nanoTime();
    1105
    1106                    if (var15 < 0L || var15 > 1000000000L)
    1107                    {
    1108                        break;
    1109                    }
    1110                }
    1111            }
    1112
    1113            if (var4.posY < 128.0D)
    1114            {
    1115                this.renderCloudsCheck(var5, par1);
    1116            }
    1117
    1118            this.setupFog(0, par1);
    1119            GL11.glEnable(GL11.GL_FOG);
    1120            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture("/terrain.png"));
    1121            RenderHelper.disableStandardItemLighting();
    1122            this.mc.mcProfiler.endStartSection("terrain");
    1123            var5.sortAndRender(var4, 0, (double)par1);
    1124            GL11.glShadeModel(GL11.GL_FLAT);
    1125            EntityPlayer var17;
    1126
    1127            if (this.debugViewDirection == 0)
    1128            {
    1129                RenderHelper.enableStandardItemLighting();
    1130                this.mc.mcProfiler.endStartSection("entities");
    1131                ForgeHooksClient.setRenderPass(0);
    1132                var5.renderEntities(var4.getPosition(par1), var14, par1);
    1133                ForgeHooksClient.setRenderPass(-1);
    1134                this.enableLightmap((double)par1);
    1135                this.mc.mcProfiler.endStartSection("litParticles");
    1136                var6.renderLitParticles(var4, par1);
    1137                RenderHelper.disableStandardItemLighting();
    1138                this.setupFog(0, par1);
    1139                this.mc.mcProfiler.endStartSection("particles");
    1140                var6.renderParticles(var4, par1);
    1141                this.disableLightmap((double)par1);
    1142
    1143                if (this.mc.objectMouseOver != null && var4.isInsideOfMaterial(Material.water) && var4 instanceof EntityPlayer && !this.mc.gameSettings.hideGUI)
    1144                {
    1145                    var17 = (EntityPlayer)var4;
    1146                    GL11.glDisable(GL11.GL_ALPHA_TEST);
    1147                    this.mc.mcProfiler.endStartSection("outline");
    1148                    if (!ForgeHooksClient.onDrawBlockHighlight(var5, var17, mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1))
    1149                    {
    1150                        var5.drawBlockBreaking(var17, this.mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1);
    1151                        var5.drawSelectionBox(var17, this.mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1);
    1152                    }
    1153                    GL11.glEnable(GL11.GL_ALPHA_TEST);
    1154                }
    1155            }
    1156
    1157            GL11.glDisable(GL11.GL_BLEND);
    1158            GL11.glEnable(GL11.GL_CULL_FACE);
    1159            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    1160            GL11.glDepthMask(true);
    1161            this.setupFog(0, par1);
    1162            GL11.glEnable(GL11.GL_BLEND);
    1163            GL11.glDisable(GL11.GL_CULL_FACE);
    1164            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture("/terrain.png"));
    1165
    1166            if (this.mc.gameSettings.fancyGraphics)
    1167            {
    1168                this.mc.mcProfiler.endStartSection("water");
    1169
    1170                if (this.mc.gameSettings.ambientOcclusion)
    1171                {
    1172                    GL11.glShadeModel(GL11.GL_SMOOTH);
    1173                }
    1174
    1175                GL11.glColorMask(false, false, false, false);
    1176                int var18 = var5.sortAndRender(var4, 1, (double)par1);
    1177
    1178                if (this.mc.gameSettings.anaglyph)
    1179                {
    1180                    if (anaglyphField == 0)
    1181                    {
    1182                        GL11.glColorMask(false, true, true, true);
    1183                    }
    1184                    else
    1185                    {
    1186                        GL11.glColorMask(true, false, false, true);
    1187                    }
    1188                }
    1189                else
    1190                {
    1191                    GL11.glColorMask(true, true, true, true);
    1192                }
    1193
    1194                if (var18 > 0)
    1195                {
    1196                    var5.renderAllRenderLists(1, (double)par1);
    1197                }
    1198
    1199                GL11.glShadeModel(GL11.GL_FLAT);
    1200            }
    1201            else
    1202            {
    1203                this.mc.mcProfiler.endStartSection("water");
    1204                var5.sortAndRender(var4, 1, (double)par1);
    1205            }
    1206
    1207            RenderHelper.enableStandardItemLighting();
    1208            this.mc.mcProfiler.endStartSection("entities");
    1209            ForgeHooksClient.setRenderPass(1);
    1210            var5.renderEntities(var4.getPosition(par1), var14, par1);
    1211            ForgeHooksClient.setRenderPass(-1);
    1212            RenderHelper.disableStandardItemLighting();
    1213
    1214            GL11.glDepthMask(true);
    1215            GL11.glEnable(GL11.GL_CULL_FACE);
    1216            GL11.glDisable(GL11.GL_BLEND);
    1217
    1218            if (this.cameraZoom == 1.0D && var4 instanceof EntityPlayer && !this.mc.gameSettings.hideGUI && this.mc.objectMouseOver != null && !var4.isInsideOfMaterial(Material.water))
    1219            {
    1220                var17 = (EntityPlayer)var4;
    1221                GL11.glDisable(GL11.GL_ALPHA_TEST);
    1222                this.mc.mcProfiler.endStartSection("outline");
    1223                if (!ForgeHooksClient.onDrawBlockHighlight(var5, var17, mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1))
    1224                {
    1225                    var5.drawBlockBreaking(var17, this.mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1);
    1226                    var5.drawSelectionBox(var17, this.mc.objectMouseOver, 0, var17.inventory.getCurrentItem(), par1);
    1227                }
    1228                GL11.glEnable(GL11.GL_ALPHA_TEST);
    1229            }
    1230
    1231            this.mc.mcProfiler.endStartSection("destroyProgress");
    1232            GL11.glEnable(GL11.GL_BLEND);
    1233            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
    1234            var5.drawBlockDamageTexture(Tessellator.instance, var4, par1);
    1235            GL11.glDisable(GL11.GL_BLEND);
    1236            this.mc.mcProfiler.endStartSection("weather");
    1237            this.renderRainSnow(par1);
    1238            GL11.glDisable(GL11.GL_FOG);
    1239
    1240            if (var4.posY >= 128.0D)
    1241            {
    1242                this.renderCloudsCheck(var5, par1);
    1243            }
    1244
    1245            this.mc.mcProfiler.endStartSection("FRenderLast");
    1246            ForgeHooksClient.dispatchRenderLast(var5, par1);
    1247
    1248            this.mc.mcProfiler.endStartSection("hand");
    1249
    1250            if (this.cameraZoom == 1.0D)
    1251            {
    1252                GL11.glClear(256);
    1253                this.renderHand(par1, var13);
    1254            }
    1255
    1256            if (!this.mc.gameSettings.anaglyph)
    1257            {
    1258                this.mc.mcProfiler.endSection();
    1259                return;
    1260            }
    1261        }
    1262
    1263        GL11.glColorMask(true, true, true, false);
    1264        this.mc.mcProfiler.endSection();
    1265    }
    1266
    1267    /**
    1268     * Render clouds if enabled
    1269     */
    1270    private void renderCloudsCheck(RenderGlobal par1RenderGlobal, float par2)
    1271    {
    1272        if (this.mc.gameSettings.shouldRenderClouds())
    1273        {
    1274            this.mc.mcProfiler.endStartSection("clouds");
    1275            GL11.glPushMatrix();
    1276            this.setupFog(0, par2);
    1277            GL11.glEnable(GL11.GL_FOG);
    1278            par1RenderGlobal.renderClouds(par2);
    1279            GL11.glDisable(GL11.GL_FOG);
    1280            this.setupFog(1, par2);
    1281            GL11.glPopMatrix();
    1282        }
    1283    }
    1284
    1285    private void addRainParticles()
    1286    {
    1287        float var1 = this.mc.theWorld.getRainStrength(1.0F);
    1288
    1289        if (!this.mc.gameSettings.fancyGraphics)
    1290        {
    1291            var1 /= 2.0F;
    1292        }
    1293
    1294        if (var1 != 0.0F)
    1295        {
    1296            this.random.setSeed((long)this.rendererUpdateCount * 312987231L);
    1297            EntityLiving var2 = this.mc.renderViewEntity;
    1298            WorldClient var3 = this.mc.theWorld;
    1299            int var4 = MathHelper.floor_double(var2.posX);
    1300            int var5 = MathHelper.floor_double(var2.posY);
    1301            int var6 = MathHelper.floor_double(var2.posZ);
    1302            byte var7 = 10;
    1303            double var8 = 0.0D;
    1304            double var10 = 0.0D;
    1305            double var12 = 0.0D;
    1306            int var14 = 0;
    1307            int var15 = (int)(100.0F * var1 * var1);
    1308
    1309            if (this.mc.gameSettings.particleSetting == 1)
    1310            {
    1311                var15 >>= 1;
    1312            }
    1313            else if (this.mc.gameSettings.particleSetting == 2)
    1314            {
    1315                var15 = 0;
    1316            }
    1317
    1318            for (int var16 = 0; var16 < var15; ++var16)
    1319            {
    1320                int var17 = var4 + this.random.nextInt(var7) - this.random.nextInt(var7);
    1321                int var18 = var6 + this.random.nextInt(var7) - this.random.nextInt(var7);
    1322                int var19 = var3.getPrecipitationHeight(var17, var18);
    1323                int var20 = var3.getBlockId(var17, var19 - 1, var18);
    1324                BiomeGenBase var21 = var3.getBiomeGenForCoords(var17, var18);
    1325
    1326                if (var19 <= var5 + var7 && var19 >= var5 - var7 && var21.canSpawnLightningBolt() && var21.getFloatTemperature() >= 0.2F)
    1327                {
    1328                    float var22 = this.random.nextFloat();
    1329                    float var23 = this.random.nextFloat();
    1330
    1331                    if (var20 > 0)
    1332                    {
    1333                        if (Block.blocksList[var20].blockMaterial == Material.lava)
    1334                        {
    1335                            this.mc.effectRenderer.addEffect(new EntitySmokeFX(var3, (double)((float)var17 + var22), (double)((float)var19 + 0.1F) - Block.blocksList[var20].getBlockBoundsMinY(), (double)((float)var18 + var23), 0.0D, 0.0D, 0.0D));
    1336                        }
    1337                        else
    1338                        {
    1339                            ++var14;
    1340
    1341                            if (this.random.nextInt(var14) == 0)
    1342                            {
    1343                                var8 = (double)((float)var17 + var22);
    1344                                var10 = (double)((float)var19 + 0.1F) - Block.blocksList[var20].getBlockBoundsMinY();
    1345                                var12 = (double)((float)var18 + var23);
    1346                            }
    1347
    1348                            this.mc.effectRenderer.addEffect(new EntityRainFX(var3, (double)((float)var17 + var22), (double)((float)var19 + 0.1F) - Block.blocksList[var20].getBlockBoundsMinY(), (double)((float)var18 + var23)));
    1349                        }
    1350                    }
    1351                }
    1352            }
    1353
    1354            if (var14 > 0 && this.random.nextInt(3) < this.rainSoundCounter++)
    1355            {
    1356                this.rainSoundCounter = 0;
    1357
    1358                if (var10 > var2.posY + 1.0D && var3.getPrecipitationHeight(MathHelper.floor_double(var2.posX), MathHelper.floor_double(var2.posZ)) > MathHelper.floor_double(var2.posY))
    1359                {
    1360                    this.mc.theWorld.playSound(var8, var10, var12, "ambient.weather.rain", 0.1F, 0.5F, false);
    1361                }
    1362                else
    1363                {
    1364                    this.mc.theWorld.playSound(var8, var10, var12, "ambient.weather.rain", 0.2F, 1.0F, false);
    1365                }
    1366            }
    1367        }
    1368    }
    1369
    1370    /**
    1371     * Render rain and snow
    1372     */
    1373    protected void renderRainSnow(float par1)
    1374    {
    1375        float var2 = this.mc.theWorld.getRainStrength(par1);
    1376
    1377        if (var2 > 0.0F)
    1378        {
    1379            this.enableLightmap((double)par1);
    1380
    1381            if (this.rainXCoords == null)
    1382            {
    1383                this.rainXCoords = new float[1024];
    1384                this.rainYCoords = new float[1024];
    1385
    1386                for (int var3 = 0; var3 < 32; ++var3)
    1387                {
    1388                    for (int var4 = 0; var4 < 32; ++var4)
    1389                    {
    1390                        float var5 = (float)(var4 - 16);
    1391                        float var6 = (float)(var3 - 16);
    1392                        float var7 = MathHelper.sqrt_float(var5 * var5 + var6 * var6);
    1393                        this.rainXCoords[var3 << 5 | var4] = -var6 / var7;
    1394                        this.rainYCoords[var3 << 5 | var4] = var5 / var7;
    1395                    }
    1396                }
    1397            }
    1398
    1399            EntityLiving var41 = this.mc.renderViewEntity;
    1400            WorldClient var42 = this.mc.theWorld;
    1401            int var43 = MathHelper.floor_double(var41.posX);
    1402            int var44 = MathHelper.floor_double(var41.posY);
    1403            int var45 = MathHelper.floor_double(var41.posZ);
    1404            Tessellator var8 = Tessellator.instance;
    1405            GL11.glDisable(GL11.GL_CULL_FACE);
    1406            GL11.glNormal3f(0.0F, 1.0F, 0.0F);
    1407            GL11.glEnable(GL11.GL_BLEND);
    1408            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    1409            GL11.glAlphaFunc(GL11.GL_GREATER, 0.01F);
    1410            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture("/environment/snow.png"));
    1411            double var9 = var41.lastTickPosX + (var41.posX - var41.lastTickPosX) * (double)par1;
    1412            double var11 = var41.lastTickPosY + (var41.posY - var41.lastTickPosY) * (double)par1;
    1413            double var13 = var41.lastTickPosZ + (var41.posZ - var41.lastTickPosZ) * (double)par1;
    1414            int var15 = MathHelper.floor_double(var11);
    1415            byte var16 = 5;
    1416
    1417            if (this.mc.gameSettings.fancyGraphics)
    1418            {
    1419                var16 = 10;
    1420            }
    1421
    1422            boolean var17 = false;
    1423            byte var18 = -1;
    1424            float var19 = (float)this.rendererUpdateCount + par1;
    1425
    1426            if (this.mc.gameSettings.fancyGraphics)
    1427            {
    1428                var16 = 10;
    1429            }
    1430
    1431            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    1432            var17 = false;
    1433
    1434            for (int var20 = var45 - var16; var20 <= var45 + var16; ++var20)
    1435            {
    1436                for (int var21 = var43 - var16; var21 <= var43 + var16; ++var21)
    1437                {
    1438                    int var22 = (var20 - var45 + 16) * 32 + var21 - var43 + 16;
    1439                    float var23 = this.rainXCoords[var22] * 0.5F;
    1440                    float var24 = this.rainYCoords[var22] * 0.5F;
    1441                    BiomeGenBase var25 = var42.getBiomeGenForCoords(var21, var20);
    1442
    1443                    if (var25.canSpawnLightningBolt() || var25.getEnableSnow())
    1444                    {
    1445                        int var26 = var42.getPrecipitationHeight(var21, var20);
    1446                        int var27 = var44 - var16;
    1447                        int var28 = var44 + var16;
    1448
    1449                        if (var27 < var26)
    1450                        {
    1451                            var27 = var26;
    1452                        }
    1453
    1454                        if (var28 < var26)
    1455                        {
    1456                            var28 = var26;
    1457                        }
    1458
    1459                        float var29 = 1.0F;
    1460                        int var30 = var26;
    1461
    1462                        if (var26 < var15)
    1463                        {
    1464                            var30 = var15;
    1465                        }
    1466
    1467                        if (var27 != var28)
    1468                        {
    1469                            this.random.setSeed((long)(var21 * var21 * 3121 + var21 * 45238971 ^ var20 * var20 * 418711 + var20 * 13761));
    1470                            float var31 = var25.getFloatTemperature();
    1471                            double var35;
    1472                            float var32;
    1473
    1474                            if (var42.getWorldChunkManager().getTemperatureAtHeight(var31, var26) >= 0.15F)
    1475                            {
    1476                                if (var18 != 0)
    1477                                {
    1478                                    if (var18 >= 0)
    1479                                    {
    1480                                        var8.draw();
    1481                                    }
    1482
    1483                                    var18 = 0;
    1484                                    GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture("/environment/rain.png"));
    1485                                    var8.startDrawingQuads();
    1486                                }
    1487
    1488                                var32 = ((float)(this.rendererUpdateCount + var21 * var21 * 3121 + var21 * 45238971 + var20 * var20 * 418711 + var20 * 13761 & 31) + par1) / 32.0F * (3.0F + this.random.nextFloat());
    1489                                double var33 = (double)((float)var21 + 0.5F) - var41.posX;
    1490                                var35 = (double)((float)var20 + 0.5F) - var41.posZ;
    1491                                float var37 = MathHelper.sqrt_double(var33 * var33 + var35 * var35) / (float)var16;
    1492                                float var38 = 1.0F;
    1493                                var8.setBrightness(var42.getLightBrightnessForSkyBlocks(var21, var30, var20, 0));
    1494                                var8.setColorRGBA_F(var38, var38, var38, ((1.0F - var37 * var37) * 0.5F + 0.5F) * var2);
    1495                                var8.setTranslation(-var9 * 1.0D, -var11 * 1.0D, -var13 * 1.0D);
    1496                                var8.addVertexWithUV((double)((float)var21 - var23) + 0.5D, (double)var27, (double)((float)var20 - var24) + 0.5D, (double)(0.0F * var29), (double)((float)var27 * var29 / 4.0F + var32 * var29));
    1497                                var8.addVertexWithUV((double)((float)var21 + var23) + 0.5D, (double)var27, (double)((float)var20 + var24) + 0.5D, (double)(1.0F * var29), (double)((float)var27 * var29 / 4.0F + var32 * var29));
    1498                                var8.addVertexWithUV((double)((float)var21 + var23) + 0.5D, (double)var28, (double)((float)var20 + var24) + 0.5D, (double)(1.0F * var29), (double)((float)var28 * var29 / 4.0F + var32 * var29));
    1499                                var8.addVertexWithUV((double)((float)var21 - var23) + 0.5D, (double)var28, (double)((float)var20 - var24) + 0.5D, (double)(0.0F * var29), (double)((float)var28 * var29 / 4.0F + var32 * var29));
    1500                                var8.setTranslation(0.0D, 0.0D, 0.0D);
    1501                            }
    1502                            else
    1503                            {
    1504                                if (var18 != 1)
    1505                                {
    1506                                    if (var18 >= 0)
    1507                                    {
    1508                                        var8.draw();
    1509                                    }
    1510
    1511                                    var18 = 1;
    1512                                    GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.mc.renderEngine.getTexture("/environment/snow.png"));
    1513                                    var8.startDrawingQuads();
    1514                                }
    1515
    1516                                var32 = ((float)(this.rendererUpdateCount & 511) + par1) / 512.0F;
    1517                                float var46 = this.random.nextFloat() + var19 * 0.01F * (float)this.random.nextGaussian();
    1518                                float var34 = this.random.nextFloat() + var19 * (float)this.random.nextGaussian() * 0.001F;
    1519                                var35 = (double)((float)var21 + 0.5F) - var41.posX;
    1520                                double var47 = (double)((float)var20 + 0.5F) - var41.posZ;
    1521                                float var39 = MathHelper.sqrt_double(var35 * var35 + var47 * var47) / (float)var16;
    1522                                float var40 = 1.0F;
    1523                                var8.setBrightness((var42.getLightBrightnessForSkyBlocks(var21, var30, var20, 0) * 3 + 15728880) / 4);
    1524                                var8.setColorRGBA_F(var40, var40, var40, ((1.0F - var39 * var39) * 0.3F + 0.5F) * var2);
    1525                                var8.setTranslation(-var9 * 1.0D, -var11 * 1.0D, -var13 * 1.0D);
    1526                                var8.addVertexWithUV((double)((float)var21 - var23) + 0.5D, (double)var27, (double)((float)var20 - var24) + 0.5D, (double)(0.0F * var29 + var46), (double)((float)var27 * var29 / 4.0F + var32 * var29 + var34));
    1527                                var8.addVertexWithUV((double)((float)var21 + var23) + 0.5D, (double)var27, (double)((float)var20 + var24) + 0.5D, (double)(1.0F * var29 + var46), (double)((float)var27 * var29 / 4.0F + var32 * var29 + var34));
    1528                                var8.addVertexWithUV((double)((float)var21 + var23) + 0.5D, (double)var28, (double)((float)var20 + var24) + 0.5D, (double)(1.0F * var29 + var46), (double)((float)var28 * var29 / 4.0F + var32 * var29 + var34));
    1529                                var8.addVertexWithUV((double)((float)var21 - var23) + 0.5D, (double)var28, (double)((float)var20 - var24) + 0.5D, (double)(0.0F * var29 + var46), (double)((float)var28 * var29 / 4.0F + var32 * var29 + var34));
    1530                                var8.setTranslation(0.0D, 0.0D, 0.0D);
    1531                            }
    1532                        }
    1533                    }
    1534                }
    1535            }
    1536
    1537            if (var18 >= 0)
    1538            {
    1539                var8.draw();
    1540            }
    1541
    1542            GL11.glEnable(GL11.GL_CULL_FACE);
    1543            GL11.glDisable(GL11.GL_BLEND);
    1544            GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
    1545            this.disableLightmap((double)par1);
    1546        }
    1547    }
    1548
    1549    /**
    1550     * Setup orthogonal projection for rendering GUI screen overlays
    1551     */
    1552    public void setupOverlayRendering()
    1553    {
    1554        ScaledResolution var1 = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
    1555        GL11.glClear(256);
    1556        GL11.glMatrixMode(GL11.GL_PROJECTION);
    1557        GL11.glLoadIdentity();
    1558        GL11.glOrtho(0.0D, var1.getScaledWidth_double(), var1.getScaledHeight_double(), 0.0D, 1000.0D, 3000.0D);
    1559        GL11.glMatrixMode(GL11.GL_MODELVIEW);
    1560        GL11.glLoadIdentity();
    1561        GL11.glTranslatef(0.0F, 0.0F, -2000.0F);
    1562    }
    1563
    1564    /**
    1565     * calculates fog and calls glClearColor
    1566     */
    1567    private void updateFogColor(float par1)
    1568    {
    1569        WorldClient var2 = this.mc.theWorld;
    1570        EntityLiving var3 = this.mc.renderViewEntity;
    1571        float var4 = 1.0F / (float)(4 - this.mc.gameSettings.renderDistance);
    1572        var4 = 1.0F - (float)Math.pow((double)var4, 0.25D);
    1573        Vec3 var5 = var2.getSkyColor(this.mc.renderViewEntity, par1);
    1574        float var6 = (float)var5.xCoord;
    1575        float var7 = (float)var5.yCoord;
    1576        float var8 = (float)var5.zCoord;
    1577        Vec3 var9 = var2.getFogColor(par1);
    1578        this.fogColorRed = (float)var9.xCoord;
    1579        this.fogColorGreen = (float)var9.yCoord;
    1580        this.fogColorBlue = (float)var9.zCoord;
    1581        float var11;
    1582
    1583        if (this.mc.gameSettings.renderDistance < 2)
    1584        {
    1585            Vec3 var10 = MathHelper.sin(var2.getCelestialAngleRadians(par1)) > 0.0F ? var2.getWorldVec3Pool().getVecFromPool(-1.0D, 0.0D, 0.0D) : var2.getWorldVec3Pool().getVecFromPool(1.0D, 0.0D, 0.0D);
    1586            var11 = (float)var3.getLook(par1).dotProduct(var10);
    1587
    1588            if (var11 < 0.0F)
    1589            {
    1590                var11 = 0.0F;
    1591            }
    1592
    1593            if (var11 > 0.0F)
    1594            {
    1595                float[] var12 = var2.provider.calcSunriseSunsetColors(var2.getCelestialAngle(par1), par1);
    1596
    1597                if (var12 != null)
    1598                {
    1599                    var11 *= var12[3];
    1600                    this.fogColorRed = this.fogColorRed * (1.0F - var11) + var12[0] * var11;
    1601                    this.fogColorGreen = this.fogColorGreen * (1.0F - var11) + var12[1] * var11;
    1602                    this.fogColorBlue = this.fogColorBlue * (1.0F - var11) + var12[2] * var11;
    1603                }
    1604            }
    1605        }
    1606
    1607        this.fogColorRed += (var6 - this.fogColorRed) * var4;
    1608        this.fogColorGreen += (var7 - this.fogColorGreen) * var4;
    1609        this.fogColorBlue += (var8 - this.fogColorBlue) * var4;
    1610        float var19 = var2.getRainStrength(par1);
    1611        float var20;
    1612
    1613        if (var19 > 0.0F)
    1614        {
    1615            var11 = 1.0F - var19 * 0.5F;
    1616            var20 = 1.0F - var19 * 0.4F;
    1617            this.fogColorRed *= var11;
    1618            this.fogColorGreen *= var11;
    1619            this.fogColorBlue *= var20;
    1620        }
    1621
    1622        var11 = var2.getWeightedThunderStrength(par1);
    1623
    1624        if (var11 > 0.0F)
    1625        {
    1626            var20 = 1.0F - var11 * 0.5F;
    1627            this.fogColorRed *= var20;
    1628            this.fogColorGreen *= var20;
    1629            this.fogColorBlue *= var20;
    1630        }
    1631
    1632        int var21 = ActiveRenderInfo.getBlockIdAtEntityViewpoint(this.mc.theWorld, var3, par1);
    1633
    1634        if (this.cloudFog)
    1635        {
    1636            Vec3 var13 = var2.drawClouds(par1);
    1637            this.fogColorRed = (float)var13.xCoord;
    1638            this.fogColorGreen = (float)var13.yCoord;
    1639            this.fogColorBlue = (float)var13.zCoord;
    1640        }
    1641        else if (var21 != 0 && Block.blocksList[var21].blockMaterial == Material.water)
    1642        {
    1643            this.fogColorRed = 0.02F;
    1644            this.fogColorGreen = 0.02F;
    1645            this.fogColorBlue = 0.2F;
    1646        }
    1647        else if (var21 != 0 && Block.blocksList[var21].blockMaterial == Material.lava)
    1648        {
    1649            this.fogColorRed = 0.6F;
    1650            this.fogColorGreen = 0.1F;
    1651            this.fogColorBlue = 0.0F;
    1652        }
    1653
    1654        float var22 = this.fogColor2 + (this.fogColor1 - this.fogColor2) * par1;
    1655        this.fogColorRed *= var22;
    1656        this.fogColorGreen *= var22;
    1657        this.fogColorBlue *= var22;
    1658        double var14 = (var3.lastTickPosY + (var3.posY - var3.lastTickPosY) * (double)par1) * var2.provider.getVoidFogYFactor();
    1659
    1660        if (var3.isPotionActive(Potion.blindness))
    1661        {
    1662            int var16 = var3.getActivePotionEffect(Potion.blindness).getDuration();
    1663
    1664            if (var16 < 20)
    1665            {
    1666                var14 *= (double)(1.0F - (float)var16 / 20.0F);
    1667            }
    1668            else
    1669            {
    1670                var14 = 0.0D;
    1671            }
    1672        }
    1673
    1674        if (var14 < 1.0D)
    1675        {
    1676            if (var14 < 0.0D)
    1677            {
    1678                var14 = 0.0D;
    1679            }
    1680
    1681            var14 *= var14;
    1682            this.fogColorRed = (float)((double)this.fogColorRed * var14);
    1683            this.fogColorGreen = (float)((double)this.fogColorGreen * var14);
    1684            this.fogColorBlue = (float)((double)this.fogColorBlue * var14);
    1685        }
    1686
    1687        float var23;
    1688
    1689        if (this.field_82831_U > 0.0F)
    1690        {
    1691            var23 = this.field_82832_V + (this.field_82831_U - this.field_82832_V) * par1;
    1692            this.fogColorRed = this.fogColorRed * (1.0F - var23) + this.fogColorRed * 0.7F * var23;
    1693            this.fogColorGreen = this.fogColorGreen * (1.0F - var23) + this.fogColorGreen * 0.6F * var23;
    1694            this.fogColorBlue = this.fogColorBlue * (1.0F - var23) + this.fogColorBlue * 0.6F * var23;
    1695        }
    1696
    1697        float var17;
    1698
    1699        if (var3.isPotionActive(Potion.nightVision))
    1700        {
    1701            var23 = this.getNightVisionBrightness(this.mc.thePlayer, par1);
    1702            var17 = 1.0F / this.fogColorRed;
    1703
    1704            if (var17 > 1.0F / this.fogColorGreen)
    1705            {
    1706                var17 = 1.0F / this.fogColorGreen;
    1707            }
    1708
    1709            if (var17 > 1.0F / this.fogColorBlue)
    1710            {
    1711                var17 = 1.0F / this.fogColorBlue;
    1712            }
    1713
    1714            this.fogColorRed = this.fogColorRed * (1.0F - var23) + this.fogColorRed * var17 * var23;
    1715            this.fogColorGreen = this.fogColorGreen * (1.0F - var23) + this.fogColorGreen * var17 * var23;
    1716            this.fogColorBlue = this.fogColorBlue * (1.0F - var23) + this.fogColorBlue * var17 * var23;
    1717        }
    1718
    1719        if (this.mc.gameSettings.anaglyph)
    1720        {
    1721            var23 = (this.fogColorRed * 30.0F + this.fogColorGreen * 59.0F + this.fogColorBlue * 11.0F) / 100.0F;
    1722            var17 = (this.fogColorRed * 30.0F + this.fogColorGreen * 70.0F) / 100.0F;
    1723            float var18 = (this.fogColorRed * 30.0F + this.fogColorBlue * 70.0F) / 100.0F;
    1724            this.fogColorRed = var23;
    1725            this.fogColorGreen = var17;
    1726            this.fogColorBlue = var18;
    1727        }
    1728
    1729        GL11.glClearColor(this.fogColorRed, this.fogColorGreen, this.fogColorBlue, 0.0F);
    1730    }
    1731
    1732    /**
    1733     * Sets up the fog to be rendered. If the arg passed in is -1 the fog starts at 0 and goes to 80% of far plane
    1734     * distance and is used for sky rendering.
    1735     */
    1736    private void setupFog(int par1, float par2)
    1737    {
    1738        EntityLiving var3 = this.mc.renderViewEntity;
    1739        boolean var4 = false;
    1740
    1741        if (var3 instanceof EntityPlayer)
    1742        {
    1743            var4 = ((EntityPlayer)var3).capabilities.isCreativeMode;
    1744        }
    1745
    1746        if (par1 == 999)
    1747        {
    1748            GL11.glFog(GL11.GL_FOG_COLOR, this.setFogColorBuffer(0.0F, 0.0F, 0.0F, 1.0F));
    1749            GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_LINEAR);
    1750            GL11.glFogf(GL11.GL_FOG_START, 0.0F);
    1751            GL11.glFogf(GL11.GL_FOG_END, 8.0F);
    1752
    1753            if (GLContext.getCapabilities().GL_NV_fog_distance)
    1754            {
    1755                GL11.glFogi(34138, 34139);
    1756            }
    1757
    1758            GL11.glFogf(GL11.GL_FOG_START, 0.0F);
    1759        }
    1760        else
    1761        {
    1762            GL11.glFog(GL11.GL_FOG_COLOR, this.setFogColorBuffer(this.fogColorRed, this.fogColorGreen, this.fogColorBlue, 1.0F));
    1763            GL11.glNormal3f(0.0F, -1.0F, 0.0F);
    1764            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    1765            int var5 = ActiveRenderInfo.getBlockIdAtEntityViewpoint(this.mc.theWorld, var3, par2);
    1766            float var6;
    1767
    1768            if (var3.isPotionActive(Potion.blindness))
    1769            {
    1770                var6 = 5.0F;
    1771                int var7 = var3.getActivePotionEffect(Potion.blindness).getDuration();
    1772
    1773                if (var7 < 20)
    1774                {
    1775                    var6 = 5.0F + (this.farPlaneDistance - 5.0F) * (1.0F - (float)var7 / 20.0F);
    1776                }
    1777
    1778                GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_LINEAR);
    1779
    1780                if (par1 < 0)
    1781                {
    1782                    GL11.glFogf(GL11.GL_FOG_START, 0.0F);
    1783                    GL11.glFogf(GL11.GL_FOG_END, var6 * 0.8F);
    1784                }
    1785                else
    1786                {
    1787                    GL11.glFogf(GL11.GL_FOG_START, var6 * 0.25F);
    1788                    GL11.glFogf(GL11.GL_FOG_END, var6);
    1789                }
    1790
    1791                if (GLContext.getCapabilities().GL_NV_fog_distance)
    1792                {
    1793                    GL11.glFogi(34138, 34139);
    1794                }
    1795            }
    1796            else
    1797            {
    1798                float var8;
    1799                float var9;
    1800                float var10;
    1801                float var11;
    1802                float var12;
    1803
    1804                if (this.cloudFog)
    1805                {
    1806                    GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_EXP);
    1807                    GL11.glFogf(GL11.GL_FOG_DENSITY, 0.1F);
    1808                    var6 = 1.0F;
    1809                    var12 = 1.0F;
    1810                    var8 = 1.0F;
    1811
    1812                    if (this.mc.gameSettings.anaglyph)
    1813                    {
    1814                        var9 = (var6 * 30.0F + var12 * 59.0F + var8 * 11.0F) / 100.0F;
    1815                        var10 = (var6 * 30.0F + var12 * 70.0F) / 100.0F;
    1816                        var11 = (var6 * 30.0F + var8 * 70.0F) / 100.0F;
    1817                    }
    1818                }
    1819                else if (var5 > 0 && Block.blocksList[var5].blockMaterial == Material.water)
    1820                {
    1821                    GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_EXP);
    1822
    1823                    if (var3.isPotionActive(Potion.waterBreathing))
    1824                    {
    1825                        GL11.glFogf(GL11.GL_FOG_DENSITY, 0.05F);
    1826                    }
    1827                    else
    1828                    {
    1829                        GL11.glFogf(GL11.GL_FOG_DENSITY, 0.1F);
    1830                    }
    1831
    1832                    var6 = 0.4F;
    1833                    var12 = 0.4F;
    1834                    var8 = 0.9F;
    1835
    1836                    if (this.mc.gameSettings.anaglyph)
    1837                    {
    1838                        var9 = (var6 * 30.0F + var12 * 59.0F + var8 * 11.0F) / 100.0F;
    1839                        var10 = (var6 * 30.0F + var12 * 70.0F) / 100.0F;
    1840                        var11 = (var6 * 30.0F + var8 * 70.0F) / 100.0F;
    1841                    }
    1842                }
    1843                else if (var5 > 0 && Block.blocksList[var5].blockMaterial == Material.lava)
    1844                {
    1845                    GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_EXP);
    1846                    GL11.glFogf(GL11.GL_FOG_DENSITY, 2.0F);
    1847                    var6 = 0.4F;
    1848                    var12 = 0.3F;
    1849                    var8 = 0.3F;
    1850
    1851                    if (this.mc.gameSettings.anaglyph)
    1852                    {
    1853                        var9 = (var6 * 30.0F + var12 * 59.0F + var8 * 11.0F) / 100.0F;
    1854                        var10 = (var6 * 30.0F + var12 * 70.0F) / 100.0F;
    1855                        var11 = (var6 * 30.0F + var8 * 70.0F) / 100.0F;
    1856                    }
    1857                }
    1858                else
    1859                {
    1860                    var6 = this.farPlaneDistance;
    1861
    1862                    if (this.mc.theWorld.provider.getWorldHasVoidParticles() && !var4)
    1863                    {
    1864                        double var13 = (double)((var3.getBrightnessForRender(par2) & 15728640) >> 20) / 16.0D + (var3.lastTickPosY + (var3.posY - var3.lastTickPosY) * (double)par2 + 4.0D) / 32.0D;
    1865
    1866                        if (var13 < 1.0D)
    1867                        {
    1868                            if (var13 < 0.0D)
    1869                            {
    1870                                var13 = 0.0D;
    1871                            }
    1872
    1873                            var13 *= var13;
    1874                            var9 = 100.0F * (float)var13;
    1875
    1876                            if (var9 < 5.0F)
    1877                            {
    1878                                var9 = 5.0F;
    1879                            }
    1880
    1881                            if (var6 > var9)
    1882                            {
    1883                                var6 = var9;
    1884                            }
    1885                        }
    1886                    }
    1887
    1888                    GL11.glFogi(GL11.GL_FOG_MODE, GL11.GL_LINEAR);
    1889
    1890                    if (par1 < 0)
    1891                    {
    1892                        GL11.glFogf(GL11.GL_FOG_START, 0.0F);
    1893                        GL11.glFogf(GL11.GL_FOG_END, var6 * 0.8F);
    1894                    }
    1895                    else
    1896                    {
    1897                        GL11.glFogf(GL11.GL_FOG_START, var6 * 0.25F);
    1898                        GL11.glFogf(GL11.GL_FOG_END, var6);
    1899                    }
    1900
    1901                    if (GLContext.getCapabilities().GL_NV_fog_distance)
    1902                    {
    1903                        GL11.glFogi(34138, 34139);
    1904                    }
    1905
    1906                    if (this.mc.theWorld.provider.doesXZShowFog((int)var3.posX, (int)var3.posZ))
    1907                    {
    1908                        GL11.glFogf(GL11.GL_FOG_START, var6 * 0.05F);
    1909                        GL11.glFogf(GL11.GL_FOG_END, Math.min(var6, 192.0F) * 0.5F);
    1910                    }
    1911                }
    1912            }
    1913
    1914            GL11.glEnable(GL11.GL_COLOR_MATERIAL);
    1915            GL11.glColorMaterial(GL11.GL_FRONT, GL11.GL_AMBIENT);
    1916        }
    1917    }
    1918
    1919    /**
    1920     * Update and return fogColorBuffer with the RGBA values passed as arguments
    1921     */
    1922    private FloatBuffer setFogColorBuffer(float par1, float par2, float par3, float par4)
    1923    {
    1924        this.fogColorBuffer.clear();
    1925        this.fogColorBuffer.put(par1).put(par2).put(par3).put(par4);
    1926        this.fogColorBuffer.flip();
    1927        return this.fogColorBuffer;
    1928    }
    1929
    1930    /**
    1931     * Converts performance value (0-2) to FPS (35-200)
    1932     */
    1933    public static int performanceToFps(int par0)
    1934    {
    1935        short var1 = 200;
    1936
    1937        if (par0 == 1)
    1938        {
    1939            var1 = 120;
    1940        }
    1941
    1942        if (par0 == 2)
    1943        {
    1944            var1 = 35;
    1945        }
    1946
    1947        return var1;
    1948    }
    1949
    1950    /**
    1951     * Get minecraft reference from the EntityRenderer
    1952     */
    1953    static Minecraft getRendererMinecraft(EntityRenderer par0EntityRenderer)
    1954    {
    1955        return par0EntityRenderer.mc;
    1956    }
    1957}