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