001    package net.minecraft.src;
002    
003    import cpw.mods.fml.common.Side;
004    import cpw.mods.fml.common.asm.SideOnly;
005    import java.nio.IntBuffer;
006    import java.util.ArrayList;
007    import java.util.Arrays;
008    import java.util.Collections;
009    import java.util.HashMap;
010    import java.util.Iterator;
011    import java.util.List;
012    import java.util.Map;
013    import java.util.Random;
014    
015    import net.minecraft.client.Minecraft;
016    import net.minecraftforge.client.SkyProvider;
017    
018    import org.lwjgl.opengl.ARBOcclusionQuery;
019    import org.lwjgl.opengl.GL11;
020    
021    @SideOnly(Side.CLIENT)
022    public class RenderGlobal implements IWorldAccess
023    {
024        public List tileEntities = new ArrayList();
025        public WorldClient theWorld;
026    
027        /** The RenderEngine instance used by RenderGlobal */
028        public final RenderEngine renderEngine;
029        private List worldRenderersToUpdate = new ArrayList();
030        private WorldRenderer[] sortedWorldRenderers;
031        private WorldRenderer[] worldRenderers;
032        private int renderChunksWide;
033        private int renderChunksTall;
034        private int renderChunksDeep;
035    
036        /** OpenGL render lists base */
037        private int glRenderListBase;
038    
039        /** A reference to the Minecraft object. */
040        public Minecraft mc;
041    
042        /** Global render blocks */
043        public RenderBlocks globalRenderBlocks;
044    
045        /** OpenGL occlusion query base */
046        private IntBuffer glOcclusionQueryBase;
047    
048        /** Is occlusion testing enabled */
049        private boolean occlusionEnabled = false;
050        private int cloudOffsetX = 0;
051    
052        /** The star GL Call list */
053        private int starGLCallList;
054    
055        /** OpenGL sky list */
056        private int glSkyList;
057    
058        /** OpenGL sky list 2 */
059        private int glSkyList2;
060    
061        /** Minimum block X */
062        private int minBlockX;
063    
064        /** Minimum block Y */
065        private int minBlockY;
066    
067        /** Minimum block Z */
068        private int minBlockZ;
069    
070        /** Maximum block X */
071        private int maxBlockX;
072    
073        /** Maximum block Y */
074        private int maxBlockY;
075    
076        /** Maximum block Z */
077        private int maxBlockZ;
078        private Map field_72738_E = new HashMap();
079        private int renderDistance = -1;
080    
081        /** Render entities startup counter (init value=2) */
082        private int renderEntitiesStartupCounter = 2;
083    
084        /** Count entities total */
085        private int countEntitiesTotal;
086    
087        /** Count entities rendered */
088        private int countEntitiesRendered;
089    
090        /** Count entities hidden */
091        private int countEntitiesHidden;
092    
093        /** Dummy buffer (50k) not used */
094        int[] dummyBuf50k = new int[50000];
095    
096        /** Occlusion query result */
097        IntBuffer occlusionResult = GLAllocation.createDirectIntBuffer(64);
098    
099        /** How many renderers are loaded this frame that try to be rendered */
100        private int renderersLoaded;
101    
102        /** How many renderers are being clipped by the frustrum this frame */
103        private int renderersBeingClipped;
104    
105        /** How many renderers are being occluded this frame */
106        private int renderersBeingOccluded;
107    
108        /** How many renderers are actually being rendered this frame */
109        private int renderersBeingRendered;
110    
111        /**
112         * How many renderers are skipping rendering due to not having a render pass this frame
113         */
114        private int renderersSkippingRenderPass;
115    
116        /** Dummy render int */
117        private int dummyRenderInt;
118    
119        /** World renderers check index */
120        private int worldRenderersCheckIndex;
121    
122        /** List of OpenGL lists for the current render pass */
123        private List glRenderLists = new ArrayList();
124    
125        /** All render lists (fixed length 4) */
126        private RenderList[] allRenderLists = new RenderList[] {new RenderList(), new RenderList(), new RenderList(), new RenderList()};
127    
128        /**
129         * Previous x position when the renderers were sorted. (Once the distance moves more than 4 units they will be
130         * resorted)
131         */
132        double prevSortX = -9999.0D;
133    
134        /**
135         * Previous y position when the renderers were sorted. (Once the distance moves more than 4 units they will be
136         * resorted)
137         */
138        double prevSortY = -9999.0D;
139    
140        /**
141         * Previous Z position when the renderers were sorted. (Once the distance moves more than 4 units they will be
142         * resorted)
143         */
144        double prevSortZ = -9999.0D;
145    
146        /**
147         * The offset used to determine if a renderer is one of the sixteenth that are being updated this frame
148         */
149        int frustumCheckOffset = 0;
150    
151        public RenderGlobal(Minecraft par1Minecraft, RenderEngine par2RenderEngine)
152        {
153            this.mc = par1Minecraft;
154            this.renderEngine = par2RenderEngine;
155            byte var3 = 34;
156            byte var4 = 32;
157            this.glRenderListBase = GLAllocation.generateDisplayLists(var3 * var3 * var4 * 3);
158            this.occlusionEnabled = OpenGlCapsChecker.checkARBOcclusion();
159    
160            if (this.occlusionEnabled)
161            {
162                this.occlusionResult.clear();
163                this.glOcclusionQueryBase = GLAllocation.createDirectIntBuffer(var3 * var3 * var4);
164                this.glOcclusionQueryBase.clear();
165                this.glOcclusionQueryBase.position(0);
166                this.glOcclusionQueryBase.limit(var3 * var3 * var4);
167                ARBOcclusionQuery.glGenQueriesARB(this.glOcclusionQueryBase);
168            }
169    
170            this.starGLCallList = GLAllocation.generateDisplayLists(3);
171            GL11.glPushMatrix();
172            GL11.glNewList(this.starGLCallList, GL11.GL_COMPILE);
173            this.renderStars();
174            GL11.glEndList();
175            GL11.glPopMatrix();
176            Tessellator var5 = Tessellator.instance;
177            this.glSkyList = this.starGLCallList + 1;
178            GL11.glNewList(this.glSkyList, GL11.GL_COMPILE);
179            byte var7 = 64;
180            int var8 = 256 / var7 + 2;
181            float var6 = 16.0F;
182            int var9;
183            int var10;
184    
185            for (var9 = -var7 * var8; var9 <= var7 * var8; var9 += var7)
186            {
187                for (var10 = -var7 * var8; var10 <= var7 * var8; var10 += var7)
188                {
189                    var5.startDrawingQuads();
190                    var5.addVertex((double)(var9 + 0), (double)var6, (double)(var10 + 0));
191                    var5.addVertex((double)(var9 + var7), (double)var6, (double)(var10 + 0));
192                    var5.addVertex((double)(var9 + var7), (double)var6, (double)(var10 + var7));
193                    var5.addVertex((double)(var9 + 0), (double)var6, (double)(var10 + var7));
194                    var5.draw();
195                }
196            }
197    
198            GL11.glEndList();
199            this.glSkyList2 = this.starGLCallList + 2;
200            GL11.glNewList(this.glSkyList2, GL11.GL_COMPILE);
201            var6 = -16.0F;
202            var5.startDrawingQuads();
203    
204            for (var9 = -var7 * var8; var9 <= var7 * var8; var9 += var7)
205            {
206                for (var10 = -var7 * var8; var10 <= var7 * var8; var10 += var7)
207                {
208                    var5.addVertex((double)(var9 + var7), (double)var6, (double)(var10 + 0));
209                    var5.addVertex((double)(var9 + 0), (double)var6, (double)(var10 + 0));
210                    var5.addVertex((double)(var9 + 0), (double)var6, (double)(var10 + var7));
211                    var5.addVertex((double)(var9 + var7), (double)var6, (double)(var10 + var7));
212                }
213            }
214    
215            var5.draw();
216            GL11.glEndList();
217        }
218    
219        private void renderStars()
220        {
221            Random var1 = new Random(10842L);
222            Tessellator var2 = Tessellator.instance;
223            var2.startDrawingQuads();
224    
225            for (int var3 = 0; var3 < 1500; ++var3)
226            {
227                double var4 = (double)(var1.nextFloat() * 2.0F - 1.0F);
228                double var6 = (double)(var1.nextFloat() * 2.0F - 1.0F);
229                double var8 = (double)(var1.nextFloat() * 2.0F - 1.0F);
230                double var10 = (double)(0.15F + var1.nextFloat() * 0.1F);
231                double var12 = var4 * var4 + var6 * var6 + var8 * var8;
232    
233                if (var12 < 1.0D && var12 > 0.01D)
234                {
235                    var12 = 1.0D / Math.sqrt(var12);
236                    var4 *= var12;
237                    var6 *= var12;
238                    var8 *= var12;
239                    double var14 = var4 * 100.0D;
240                    double var16 = var6 * 100.0D;
241                    double var18 = var8 * 100.0D;
242                    double var20 = Math.atan2(var4, var8);
243                    double var22 = Math.sin(var20);
244                    double var24 = Math.cos(var20);
245                    double var26 = Math.atan2(Math.sqrt(var4 * var4 + var8 * var8), var6);
246                    double var28 = Math.sin(var26);
247                    double var30 = Math.cos(var26);
248                    double var32 = var1.nextDouble() * Math.PI * 2.0D;
249                    double var34 = Math.sin(var32);
250                    double var36 = Math.cos(var32);
251    
252                    for (int var38 = 0; var38 < 4; ++var38)
253                    {
254                        double var39 = 0.0D;
255                        double var41 = (double)((var38 & 2) - 1) * var10;
256                        double var43 = (double)((var38 + 1 & 2) - 1) * var10;
257                        double var47 = var41 * var36 - var43 * var34;
258                        double var49 = var43 * var36 + var41 * var34;
259                        double var53 = var47 * var28 + var39 * var30;
260                        double var55 = var39 * var28 - var47 * var30;
261                        double var57 = var55 * var22 - var49 * var24;
262                        double var61 = var49 * var22 + var55 * var24;
263                        var2.addVertex(var14 + var57, var16 + var53, var18 + var61);
264                    }
265                }
266            }
267    
268            var2.draw();
269        }
270    
271        /**
272         * set null to clear
273         */
274        public void setWorldAndLoadRenderers(WorldClient par1WorldClient)
275        {
276            if (this.theWorld != null)
277            {
278                this.theWorld.removeWorldAccess(this);
279            }
280    
281            this.prevSortX = -9999.0D;
282            this.prevSortY = -9999.0D;
283            this.prevSortZ = -9999.0D;
284            RenderManager.instance.set(par1WorldClient);
285            this.theWorld = par1WorldClient;
286            this.globalRenderBlocks = new RenderBlocks(par1WorldClient);
287    
288            if (par1WorldClient != null)
289            {
290                par1WorldClient.addWorldAccess(this);
291                this.loadRenderers();
292            }
293        }
294    
295        /**
296         * Loads all the renderers and sets up the basic settings usage
297         */
298        public void loadRenderers()
299        {
300            if (this.theWorld != null)
301            {
302                Block.leaves.setGraphicsLevel(this.mc.gameSettings.fancyGraphics);
303                this.renderDistance = this.mc.gameSettings.renderDistance;
304                int var2;
305                int var3;
306    
307                if (this.worldRenderers != null)
308                {
309                    WorldRenderer[] var1 = this.worldRenderers;
310                    var2 = var1.length;
311    
312                    for (var3 = 0; var3 < var2; ++var3)
313                    {
314                        WorldRenderer var4 = var1[var3];
315                        var4.stopRendering();
316                    }
317                }
318    
319                int var7 = 64 << 3 - this.renderDistance;
320    
321                if (var7 > 400)
322                {
323                    var7 = 400;
324                }
325    
326                this.renderChunksWide = var7 / 16 + 1;
327                this.renderChunksTall = 16;
328                this.renderChunksDeep = var7 / 16 + 1;
329                this.worldRenderers = new WorldRenderer[this.renderChunksWide * this.renderChunksTall * this.renderChunksDeep];
330                this.sortedWorldRenderers = new WorldRenderer[this.renderChunksWide * this.renderChunksTall * this.renderChunksDeep];
331                var2 = 0;
332                var3 = 0;
333                this.minBlockX = 0;
334                this.minBlockY = 0;
335                this.minBlockZ = 0;
336                this.maxBlockX = this.renderChunksWide;
337                this.maxBlockY = this.renderChunksTall;
338                this.maxBlockZ = this.renderChunksDeep;
339                WorldRenderer var5;
340    
341                for (Iterator var8 = this.worldRenderersToUpdate.iterator(); var8.hasNext(); var5.needsUpdate = false)
342                {
343                    var5 = (WorldRenderer)var8.next();
344                }
345    
346                this.worldRenderersToUpdate.clear();
347                this.tileEntities.clear();
348    
349                for (int var9 = 0; var9 < this.renderChunksWide; ++var9)
350                {
351                    for (int var11 = 0; var11 < this.renderChunksTall; ++var11)
352                    {
353                        for (int var6 = 0; var6 < this.renderChunksDeep; ++var6)
354                        {
355                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9] = new WorldRenderer(this.theWorld, this.tileEntities, var9 * 16, var11 * 16, var6 * 16, this.glRenderListBase + var2);
356    
357                            if (this.occlusionEnabled)
358                            {
359                                this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].glOcclusionQuery = this.glOcclusionQueryBase.get(var3);
360                            }
361    
362                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].isWaitingOnOcclusionQuery = false;
363                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].isVisible = true;
364                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].isInFrustum = true;
365                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].chunkIndex = var3++;
366                            this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9].markDirty();
367                            this.sortedWorldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9] = this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9];
368                            this.worldRenderersToUpdate.add(this.worldRenderers[(var6 * this.renderChunksTall + var11) * this.renderChunksWide + var9]);
369                            var2 += 3;
370                        }
371                    }
372                }
373    
374                if (this.theWorld != null)
375                {
376                    EntityLiving var10 = this.mc.renderViewEntity;
377    
378                    if (var10 != null)
379                    {
380                        this.markRenderersForNewPosition(MathHelper.floor_double(var10.posX), MathHelper.floor_double(var10.posY), MathHelper.floor_double(var10.posZ));
381                        Arrays.sort(this.sortedWorldRenderers, new EntitySorter(var10));
382                    }
383                }
384    
385                this.renderEntitiesStartupCounter = 2;
386            }
387        }
388    
389        /**
390         * Renders all entities within range and within the frustrum. Args: pos, frustrum, partialTickTime
391         */
392        public void renderEntities(Vec3 par1Vec3, ICamera par2ICamera, float par3)
393        {
394            if (this.renderEntitiesStartupCounter > 0)
395            {
396                --this.renderEntitiesStartupCounter;
397            }
398            else
399            {
400                this.theWorld.theProfiler.startSection("prepare");
401                TileEntityRenderer.instance.cacheActiveRenderInfo(this.theWorld, this.renderEngine, this.mc.fontRenderer, this.mc.renderViewEntity, par3);
402                RenderManager.instance.cacheActiveRenderInfo(this.theWorld, this.renderEngine, this.mc.fontRenderer, this.mc.renderViewEntity, this.mc.gameSettings, par3);
403                this.countEntitiesTotal = 0;
404                this.countEntitiesRendered = 0;
405                this.countEntitiesHidden = 0;
406                EntityLiving var4 = this.mc.renderViewEntity;
407                RenderManager.renderPosX = var4.lastTickPosX + (var4.posX - var4.lastTickPosX) * (double)par3;
408                RenderManager.renderPosY = var4.lastTickPosY + (var4.posY - var4.lastTickPosY) * (double)par3;
409                RenderManager.renderPosZ = var4.lastTickPosZ + (var4.posZ - var4.lastTickPosZ) * (double)par3;
410                TileEntityRenderer.staticPlayerX = var4.lastTickPosX + (var4.posX - var4.lastTickPosX) * (double)par3;
411                TileEntityRenderer.staticPlayerY = var4.lastTickPosY + (var4.posY - var4.lastTickPosY) * (double)par3;
412                TileEntityRenderer.staticPlayerZ = var4.lastTickPosZ + (var4.posZ - var4.lastTickPosZ) * (double)par3;
413                this.mc.entityRenderer.enableLightmap((double)par3);
414                this.theWorld.theProfiler.endStartSection("global");
415                List var5 = this.theWorld.getLoadedEntityList();
416                this.countEntitiesTotal = var5.size();
417                int var6;
418                Entity var7;
419    
420                for (var6 = 0; var6 < this.theWorld.weatherEffects.size(); ++var6)
421                {
422                    var7 = (Entity)this.theWorld.weatherEffects.get(var6);
423                    ++this.countEntitiesRendered;
424    
425                    if (var7.isInRangeToRenderVec3D(par1Vec3))
426                    {
427                        RenderManager.instance.renderEntity(var7, par3);
428                    }
429                }
430    
431                this.theWorld.theProfiler.endStartSection("entities");
432    
433                for (var6 = 0; var6 < var5.size(); ++var6)
434                {
435                    var7 = (Entity)var5.get(var6);
436    
437                    if (var7.isInRangeToRenderVec3D(par1Vec3) && (var7.ignoreFrustumCheck || par2ICamera.isBoundingBoxInFrustum(var7.boundingBox)) && (var7 != this.mc.renderViewEntity || this.mc.gameSettings.thirdPersonView != 0 || this.mc.renderViewEntity.isPlayerSleeping()) && this.theWorld.blockExists(MathHelper.floor_double(var7.posX), 0, MathHelper.floor_double(var7.posZ)))
438                    {
439                        ++this.countEntitiesRendered;
440                        RenderManager.instance.renderEntity(var7, par3);
441                    }
442                }
443    
444                this.theWorld.theProfiler.endStartSection("tileentities");
445                RenderHelper.enableStandardItemLighting();
446                Iterator var8 = this.tileEntities.iterator();
447    
448                while (var8.hasNext())
449                {
450                    TileEntity var9 = (TileEntity)var8.next();
451                    TileEntityRenderer.instance.renderTileEntity(var9, par3);
452                }
453    
454                this.mc.entityRenderer.disableLightmap((double)par3);
455                this.theWorld.theProfiler.endSection();
456            }
457        }
458    
459        /**
460         * Gets the render info for use on the Debug screen
461         */
462        public String getDebugInfoRenders()
463        {
464            return "C: " + this.renderersBeingRendered + "/" + this.renderersLoaded + ". F: " + this.renderersBeingClipped + ", O: " + this.renderersBeingOccluded + ", E: " + this.renderersSkippingRenderPass;
465        }
466    
467        /**
468         * Gets the entities info for use on the Debug screen
469         */
470        public String getDebugInfoEntities()
471        {
472            return "E: " + this.countEntitiesRendered + "/" + this.countEntitiesTotal + ". B: " + this.countEntitiesHidden + ", I: " + (this.countEntitiesTotal - this.countEntitiesHidden - this.countEntitiesRendered);
473        }
474    
475        /**
476         * Goes through all the renderers setting new positions on them and those that have their position changed are
477         * adding to be updated
478         */
479        private void markRenderersForNewPosition(int par1, int par2, int par3)
480        {
481            par1 -= 8;
482            par2 -= 8;
483            par3 -= 8;
484            this.minBlockX = Integer.MAX_VALUE;
485            this.minBlockY = Integer.MAX_VALUE;
486            this.minBlockZ = Integer.MAX_VALUE;
487            this.maxBlockX = Integer.MIN_VALUE;
488            this.maxBlockY = Integer.MIN_VALUE;
489            this.maxBlockZ = Integer.MIN_VALUE;
490            int var4 = this.renderChunksWide * 16;
491            int var5 = var4 / 2;
492    
493            for (int var6 = 0; var6 < this.renderChunksWide; ++var6)
494            {
495                int var7 = var6 * 16;
496                int var8 = var7 + var5 - par1;
497    
498                if (var8 < 0)
499                {
500                    var8 -= var4 - 1;
501                }
502    
503                var8 /= var4;
504                var7 -= var8 * var4;
505    
506                if (var7 < this.minBlockX)
507                {
508                    this.minBlockX = var7;
509                }
510    
511                if (var7 > this.maxBlockX)
512                {
513                    this.maxBlockX = var7;
514                }
515    
516                for (int var9 = 0; var9 < this.renderChunksDeep; ++var9)
517                {
518                    int var10 = var9 * 16;
519                    int var11 = var10 + var5 - par3;
520    
521                    if (var11 < 0)
522                    {
523                        var11 -= var4 - 1;
524                    }
525    
526                    var11 /= var4;
527                    var10 -= var11 * var4;
528    
529                    if (var10 < this.minBlockZ)
530                    {
531                        this.minBlockZ = var10;
532                    }
533    
534                    if (var10 > this.maxBlockZ)
535                    {
536                        this.maxBlockZ = var10;
537                    }
538    
539                    for (int var12 = 0; var12 < this.renderChunksTall; ++var12)
540                    {
541                        int var13 = var12 * 16;
542    
543                        if (var13 < this.minBlockY)
544                        {
545                            this.minBlockY = var13;
546                        }
547    
548                        if (var13 > this.maxBlockY)
549                        {
550                            this.maxBlockY = var13;
551                        }
552    
553                        WorldRenderer var14 = this.worldRenderers[(var9 * this.renderChunksTall + var12) * this.renderChunksWide + var6];
554                        boolean var15 = var14.needsUpdate;
555                        var14.setPosition(var7, var13, var10);
556    
557                        if (!var15 && var14.needsUpdate)
558                        {
559                            this.worldRenderersToUpdate.add(var14);
560                        }
561                    }
562                }
563            }
564        }
565    
566        /**
567         * Sorts all renderers based on the passed in entity. Args: entityLiving, renderPass, partialTickTime
568         */
569        public int sortAndRender(EntityLiving par1EntityLiving, int par2, double par3)
570        {
571            this.theWorld.theProfiler.startSection("sortchunks");
572    
573            for (int var5 = 0; var5 < 10; ++var5)
574            {
575                this.worldRenderersCheckIndex = (this.worldRenderersCheckIndex + 1) % this.worldRenderers.length;
576                WorldRenderer var6 = this.worldRenderers[this.worldRenderersCheckIndex];
577    
578                if (var6.needsUpdate && !this.worldRenderersToUpdate.contains(var6))
579                {
580                    this.worldRenderersToUpdate.add(var6);
581                }
582            }
583    
584            if (this.mc.gameSettings.renderDistance != this.renderDistance)
585            {
586                this.loadRenderers();
587            }
588    
589            if (par2 == 0)
590            {
591                this.renderersLoaded = 0;
592                this.dummyRenderInt = 0;
593                this.renderersBeingClipped = 0;
594                this.renderersBeingOccluded = 0;
595                this.renderersBeingRendered = 0;
596                this.renderersSkippingRenderPass = 0;
597            }
598    
599            double var33 = par1EntityLiving.lastTickPosX + (par1EntityLiving.posX - par1EntityLiving.lastTickPosX) * par3;
600            double var7 = par1EntityLiving.lastTickPosY + (par1EntityLiving.posY - par1EntityLiving.lastTickPosY) * par3;
601            double var9 = par1EntityLiving.lastTickPosZ + (par1EntityLiving.posZ - par1EntityLiving.lastTickPosZ) * par3;
602            double var11 = par1EntityLiving.posX - this.prevSortX;
603            double var13 = par1EntityLiving.posY - this.prevSortY;
604            double var15 = par1EntityLiving.posZ - this.prevSortZ;
605    
606            if (var11 * var11 + var13 * var13 + var15 * var15 > 16.0D)
607            {
608                this.prevSortX = par1EntityLiving.posX;
609                this.prevSortY = par1EntityLiving.posY;
610                this.prevSortZ = par1EntityLiving.posZ;
611                this.markRenderersForNewPosition(MathHelper.floor_double(par1EntityLiving.posX), MathHelper.floor_double(par1EntityLiving.posY), MathHelper.floor_double(par1EntityLiving.posZ));
612                Arrays.sort(this.sortedWorldRenderers, new EntitySorter(par1EntityLiving));
613            }
614    
615            RenderHelper.disableStandardItemLighting();
616            byte var17 = 0;
617            int var34;
618    
619            if (this.occlusionEnabled && this.mc.gameSettings.advancedOpengl && !this.mc.gameSettings.anaglyph && par2 == 0)
620            {
621                byte var18 = 0;
622                int var19 = 16;
623                this.checkOcclusionQueryResult(var18, var19);
624    
625                for (int var20 = var18; var20 < var19; ++var20)
626                {
627                    this.sortedWorldRenderers[var20].isVisible = true;
628                }
629    
630                this.theWorld.theProfiler.endStartSection("render");
631                var34 = var17 + this.renderSortedRenderers(var18, var19, par2, par3);
632    
633                do
634                {
635                    this.theWorld.theProfiler.endStartSection("occ");
636                    int var35 = var19;
637                    var19 *= 2;
638    
639                    if (var19 > this.sortedWorldRenderers.length)
640                    {
641                        var19 = this.sortedWorldRenderers.length;
642                    }
643    
644                    GL11.glDisable(GL11.GL_TEXTURE_2D);
645                    GL11.glDisable(GL11.GL_LIGHTING);
646                    GL11.glDisable(GL11.GL_ALPHA_TEST);
647                    GL11.glDisable(GL11.GL_FOG);
648                    GL11.glColorMask(false, false, false, false);
649                    GL11.glDepthMask(false);
650                    this.theWorld.theProfiler.startSection("check");
651                    this.checkOcclusionQueryResult(var35, var19);
652                    this.theWorld.theProfiler.endSection();
653                    GL11.glPushMatrix();
654                    float var36 = 0.0F;
655                    float var21 = 0.0F;
656                    float var22 = 0.0F;
657    
658                    for (int var23 = var35; var23 < var19; ++var23)
659                    {
660                        if (this.sortedWorldRenderers[var23].skipAllRenderPasses())
661                        {
662                            this.sortedWorldRenderers[var23].isInFrustum = false;
663                        }
664                        else
665                        {
666                            if (!this.sortedWorldRenderers[var23].isInFrustum)
667                            {
668                                this.sortedWorldRenderers[var23].isVisible = true;
669                            }
670    
671                            if (this.sortedWorldRenderers[var23].isInFrustum && !this.sortedWorldRenderers[var23].isWaitingOnOcclusionQuery)
672                            {
673                                float var24 = MathHelper.sqrt_float(this.sortedWorldRenderers[var23].distanceToEntitySquared(par1EntityLiving));
674                                int var25 = (int)(1.0F + var24 / 128.0F);
675    
676                                if (this.cloudOffsetX % var25 == var23 % var25)
677                                {
678                                    WorldRenderer var26 = this.sortedWorldRenderers[var23];
679                                    float var27 = (float)((double)var26.posXMinus - var33);
680                                    float var28 = (float)((double)var26.posYMinus - var7);
681                                    float var29 = (float)((double)var26.posZMinus - var9);
682                                    float var30 = var27 - var36;
683                                    float var31 = var28 - var21;
684                                    float var32 = var29 - var22;
685    
686                                    if (var30 != 0.0F || var31 != 0.0F || var32 != 0.0F)
687                                    {
688                                        GL11.glTranslatef(var30, var31, var32);
689                                        var36 += var30;
690                                        var21 += var31;
691                                        var22 += var32;
692                                    }
693    
694                                    this.theWorld.theProfiler.startSection("bb");
695                                    ARBOcclusionQuery.glBeginQueryARB(ARBOcclusionQuery.GL_SAMPLES_PASSED_ARB, this.sortedWorldRenderers[var23].glOcclusionQuery);
696                                    this.sortedWorldRenderers[var23].callOcclusionQueryList();
697                                    ARBOcclusionQuery.glEndQueryARB(ARBOcclusionQuery.GL_SAMPLES_PASSED_ARB);
698                                    this.theWorld.theProfiler.endSection();
699                                    this.sortedWorldRenderers[var23].isWaitingOnOcclusionQuery = true;
700                                }
701                            }
702                        }
703                    }
704    
705                    GL11.glPopMatrix();
706    
707                    if (this.mc.gameSettings.anaglyph)
708                    {
709                        if (EntityRenderer.anaglyphField == 0)
710                        {
711                            GL11.glColorMask(false, true, true, true);
712                        }
713                        else
714                        {
715                            GL11.glColorMask(true, false, false, true);
716                        }
717                    }
718                    else
719                    {
720                        GL11.glColorMask(true, true, true, true);
721                    }
722    
723                    GL11.glDepthMask(true);
724                    GL11.glEnable(GL11.GL_TEXTURE_2D);
725                    GL11.glEnable(GL11.GL_ALPHA_TEST);
726                    GL11.glEnable(GL11.GL_FOG);
727                    this.theWorld.theProfiler.endStartSection("render");
728                    var34 += this.renderSortedRenderers(var35, var19, par2, par3);
729                }
730                while (var19 < this.sortedWorldRenderers.length);
731            }
732            else
733            {
734                this.theWorld.theProfiler.endStartSection("render");
735                var34 = var17 + this.renderSortedRenderers(0, this.sortedWorldRenderers.length, par2, par3);
736            }
737    
738            this.theWorld.theProfiler.endSection();
739            return var34;
740        }
741    
742        private void checkOcclusionQueryResult(int par1, int par2)
743        {
744            for (int var3 = par1; var3 < par2; ++var3)
745            {
746                if (this.sortedWorldRenderers[var3].isWaitingOnOcclusionQuery)
747                {
748                    this.occlusionResult.clear();
749                    ARBOcclusionQuery.glGetQueryObjectuARB(this.sortedWorldRenderers[var3].glOcclusionQuery, ARBOcclusionQuery.GL_QUERY_RESULT_AVAILABLE_ARB, this.occlusionResult);
750    
751                    if (this.occlusionResult.get(0) != 0)
752                    {
753                        this.sortedWorldRenderers[var3].isWaitingOnOcclusionQuery = false;
754                        this.occlusionResult.clear();
755                        ARBOcclusionQuery.glGetQueryObjectuARB(this.sortedWorldRenderers[var3].glOcclusionQuery, ARBOcclusionQuery.GL_QUERY_RESULT_ARB, this.occlusionResult);
756                        this.sortedWorldRenderers[var3].isVisible = this.occlusionResult.get(0) != 0;
757                    }
758                }
759            }
760        }
761    
762        /**
763         * Renders the sorted renders for the specified render pass. Args: startRenderer, numRenderers, renderPass,
764         * partialTickTime
765         */
766        private int renderSortedRenderers(int par1, int par2, int par3, double par4)
767        {
768            this.glRenderLists.clear();
769            int var6 = 0;
770    
771            for (int var7 = par1; var7 < par2; ++var7)
772            {
773                if (par3 == 0)
774                {
775                    ++this.renderersLoaded;
776    
777                    if (this.sortedWorldRenderers[var7].skipRenderPass[par3])
778                    {
779                        ++this.renderersSkippingRenderPass;
780                    }
781                    else if (!this.sortedWorldRenderers[var7].isInFrustum)
782                    {
783                        ++this.renderersBeingClipped;
784                    }
785                    else if (this.occlusionEnabled && !this.sortedWorldRenderers[var7].isVisible)
786                    {
787                        ++this.renderersBeingOccluded;
788                    }
789                    else
790                    {
791                        ++this.renderersBeingRendered;
792                    }
793                }
794    
795                if (!this.sortedWorldRenderers[var7].skipRenderPass[par3] && this.sortedWorldRenderers[var7].isInFrustum && (!this.occlusionEnabled || this.sortedWorldRenderers[var7].isVisible))
796                {
797                    int var8 = this.sortedWorldRenderers[var7].getGLCallListForPass(par3);
798    
799                    if (var8 >= 0)
800                    {
801                        this.glRenderLists.add(this.sortedWorldRenderers[var7]);
802                        ++var6;
803                    }
804                }
805            }
806    
807            EntityLiving var19 = this.mc.renderViewEntity;
808            double var20 = var19.lastTickPosX + (var19.posX - var19.lastTickPosX) * par4;
809            double var10 = var19.lastTickPosY + (var19.posY - var19.lastTickPosY) * par4;
810            double var12 = var19.lastTickPosZ + (var19.posZ - var19.lastTickPosZ) * par4;
811            int var14 = 0;
812            RenderList[] var15 = this.allRenderLists;
813            int var16 = var15.length;
814            int var17;
815    
816            for (var17 = 0; var17 < var16; ++var17)
817            {
818                RenderList var18 = var15[var17];
819                var18.func_78421_b();
820            }
821    
822            WorldRenderer var22;
823    
824            for (Iterator var21 = this.glRenderLists.iterator(); var21.hasNext(); this.allRenderLists[var17].func_78420_a(var22.getGLCallListForPass(par3)))
825            {
826                var22 = (WorldRenderer)var21.next();
827                var17 = -1;
828    
829                for (int var23 = 0; var23 < var14; ++var23)
830                {
831                    if (this.allRenderLists[var23].func_78418_a(var22.posXMinus, var22.posYMinus, var22.posZMinus))
832                    {
833                        var17 = var23;
834                    }
835                }
836    
837                if (var17 < 0)
838                {
839                    var17 = var14++;
840                    this.allRenderLists[var17].func_78422_a(var22.posXMinus, var22.posYMinus, var22.posZMinus, var20, var10, var12);
841                }
842            }
843    
844            this.renderAllRenderLists(par3, par4);
845            return var6;
846        }
847    
848        /**
849         * Render all render lists
850         */
851        public void renderAllRenderLists(int par1, double par2)
852        {
853            this.mc.entityRenderer.enableLightmap(par2);
854            RenderList[] var4 = this.allRenderLists;
855            int var5 = var4.length;
856    
857            for (int var6 = 0; var6 < var5; ++var6)
858            {
859                RenderList var7 = var4[var6];
860                var7.func_78419_a();
861            }
862    
863            this.mc.entityRenderer.disableLightmap(par2);
864        }
865    
866        public void updateClouds()
867        {
868            ++this.cloudOffsetX;
869        }
870    
871        /**
872         * Renders the sky with the partial tick time. Args: partialTickTime
873         */
874        public void renderSky(float par1)
875        {
876            SkyProvider skyProvider = null;
877            if ((skyProvider = this.mc.theWorld.provider.getSkyProvider()) != null)
878            {
879                skyProvider.render(par1, this.theWorld, mc);
880                return;
881            }
882            if (this.mc.theWorld.provider.worldType == 1)
883            {
884                GL11.glDisable(GL11.GL_FOG);
885                GL11.glDisable(GL11.GL_ALPHA_TEST);
886                GL11.glEnable(GL11.GL_BLEND);
887                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
888                RenderHelper.disableStandardItemLighting();
889                GL11.glDepthMask(false);
890                this.renderEngine.bindTexture(this.renderEngine.getTexture("/misc/tunnel.png"));
891                Tessellator var21 = Tessellator.instance;
892    
893                for (int var22 = 0; var22 < 6; ++var22)
894                {
895                    GL11.glPushMatrix();
896    
897                    if (var22 == 1)
898                    {
899                        GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
900                    }
901    
902                    if (var22 == 2)
903                    {
904                        GL11.glRotatef(-90.0F, 1.0F, 0.0F, 0.0F);
905                    }
906    
907                    if (var22 == 3)
908                    {
909                        GL11.glRotatef(180.0F, 1.0F, 0.0F, 0.0F);
910                    }
911    
912                    if (var22 == 4)
913                    {
914                        GL11.glRotatef(90.0F, 0.0F, 0.0F, 1.0F);
915                    }
916    
917                    if (var22 == 5)
918                    {
919                        GL11.glRotatef(-90.0F, 0.0F, 0.0F, 1.0F);
920                    }
921    
922                    var21.startDrawingQuads();
923                    var21.setColorOpaque_I(2631720);
924                    var21.addVertexWithUV(-100.0D, -100.0D, -100.0D, 0.0D, 0.0D);
925                    var21.addVertexWithUV(-100.0D, -100.0D, 100.0D, 0.0D, 16.0D);
926                    var21.addVertexWithUV(100.0D, -100.0D, 100.0D, 16.0D, 16.0D);
927                    var21.addVertexWithUV(100.0D, -100.0D, -100.0D, 16.0D, 0.0D);
928                    var21.draw();
929                    GL11.glPopMatrix();
930                }
931    
932                GL11.glDepthMask(true);
933                GL11.glEnable(GL11.GL_TEXTURE_2D);
934                GL11.glEnable(GL11.GL_ALPHA_TEST);
935            }
936            else if (this.mc.theWorld.provider.isSurfaceWorld())
937            {
938                GL11.glDisable(GL11.GL_TEXTURE_2D);
939                Vec3 var2 = this.theWorld.getSkyColor(this.mc.renderViewEntity, par1);
940                float var3 = (float)var2.xCoord;
941                float var4 = (float)var2.yCoord;
942                float var5 = (float)var2.zCoord;
943                float var8;
944    
945                if (this.mc.gameSettings.anaglyph)
946                {
947                    float var6 = (var3 * 30.0F + var4 * 59.0F + var5 * 11.0F) / 100.0F;
948                    float var7 = (var3 * 30.0F + var4 * 70.0F) / 100.0F;
949                    var8 = (var3 * 30.0F + var5 * 70.0F) / 100.0F;
950                    var3 = var6;
951                    var4 = var7;
952                    var5 = var8;
953                }
954    
955                GL11.glColor3f(var3, var4, var5);
956                Tessellator var23 = Tessellator.instance;
957                GL11.glDepthMask(false);
958                GL11.glEnable(GL11.GL_FOG);
959                GL11.glColor3f(var3, var4, var5);
960                GL11.glCallList(this.glSkyList);
961                GL11.glDisable(GL11.GL_FOG);
962                GL11.glDisable(GL11.GL_ALPHA_TEST);
963                GL11.glEnable(GL11.GL_BLEND);
964                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
965                RenderHelper.disableStandardItemLighting();
966                float[] var24 = this.theWorld.provider.calcSunriseSunsetColors(this.theWorld.getCelestialAngle(par1), par1);
967                float var9;
968                float var10;
969                float var11;
970                float var12;
971    
972                if (var24 != null)
973                {
974                    GL11.glDisable(GL11.GL_TEXTURE_2D);
975                    GL11.glShadeModel(GL11.GL_SMOOTH);
976                    GL11.glPushMatrix();
977                    GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F);
978                    GL11.glRotatef(MathHelper.sin(this.theWorld.getCelestialAngleRadians(par1)) < 0.0F ? 180.0F : 0.0F, 0.0F, 0.0F, 1.0F);
979                    GL11.glRotatef(90.0F, 0.0F, 0.0F, 1.0F);
980                    var8 = var24[0];
981                    var9 = var24[1];
982                    var10 = var24[2];
983                    float var13;
984    
985                    if (this.mc.gameSettings.anaglyph)
986                    {
987                        var11 = (var8 * 30.0F + var9 * 59.0F + var10 * 11.0F) / 100.0F;
988                        var12 = (var8 * 30.0F + var9 * 70.0F) / 100.0F;
989                        var13 = (var8 * 30.0F + var10 * 70.0F) / 100.0F;
990                        var8 = var11;
991                        var9 = var12;
992                        var10 = var13;
993                    }
994    
995                    var23.startDrawing(6);
996                    var23.setColorRGBA_F(var8, var9, var10, var24[3]);
997                    var23.addVertex(0.0D, 100.0D, 0.0D);
998                    byte var26 = 16;
999                    var23.setColorRGBA_F(var24[0], var24[1], var24[2], 0.0F);
1000    
1001                    for (int var27 = 0; var27 <= var26; ++var27)
1002                    {
1003                        var13 = (float)var27 * (float)Math.PI * 2.0F / (float)var26;
1004                        float var14 = MathHelper.sin(var13);
1005                        float var15 = MathHelper.cos(var13);
1006                        var23.addVertex((double)(var14 * 120.0F), (double)(var15 * 120.0F), (double)(-var15 * 40.0F * var24[3]));
1007                    }
1008    
1009                    var23.draw();
1010                    GL11.glPopMatrix();
1011                    GL11.glShadeModel(GL11.GL_FLAT);
1012                }
1013    
1014                GL11.glEnable(GL11.GL_TEXTURE_2D);
1015                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
1016                GL11.glPushMatrix();
1017                var8 = 1.0F - this.theWorld.getRainStrength(par1);
1018                var9 = 0.0F;
1019                var10 = 0.0F;
1020                var11 = 0.0F;
1021                GL11.glColor4f(1.0F, 1.0F, 1.0F, var8);
1022                GL11.glTranslatef(var9, var10, var11);
1023                GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
1024                GL11.glRotatef(this.theWorld.getCelestialAngle(par1) * 360.0F, 1.0F, 0.0F, 0.0F);
1025                var12 = 30.0F;
1026                GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/terrain/sun.png"));
1027                var23.startDrawingQuads();
1028                var23.addVertexWithUV((double)(-var12), 100.0D, (double)(-var12), 0.0D, 0.0D);
1029                var23.addVertexWithUV((double)var12, 100.0D, (double)(-var12), 1.0D, 0.0D);
1030                var23.addVertexWithUV((double)var12, 100.0D, (double)var12, 1.0D, 1.0D);
1031                var23.addVertexWithUV((double)(-var12), 100.0D, (double)var12, 0.0D, 1.0D);
1032                var23.draw();
1033                var12 = 20.0F;
1034                GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/terrain/moon_phases.png"));
1035                int var28 = this.theWorld.getMoonPhase(par1);
1036                int var30 = var28 % 4;
1037                int var29 = var28 / 4 % 2;
1038                float var16 = (float)(var30 + 0) / 4.0F;
1039                float var17 = (float)(var29 + 0) / 2.0F;
1040                float var18 = (float)(var30 + 1) / 4.0F;
1041                float var19 = (float)(var29 + 1) / 2.0F;
1042                var23.startDrawingQuads();
1043                var23.addVertexWithUV((double)(-var12), -100.0D, (double)var12, (double)var18, (double)var19);
1044                var23.addVertexWithUV((double)var12, -100.0D, (double)var12, (double)var16, (double)var19);
1045                var23.addVertexWithUV((double)var12, -100.0D, (double)(-var12), (double)var16, (double)var17);
1046                var23.addVertexWithUV((double)(-var12), -100.0D, (double)(-var12), (double)var18, (double)var17);
1047                var23.draw();
1048                GL11.glDisable(GL11.GL_TEXTURE_2D);
1049                float var20 = this.theWorld.getStarBrightness(par1) * var8;
1050    
1051                if (var20 > 0.0F)
1052                {
1053                    GL11.glColor4f(var20, var20, var20, var20);
1054                    GL11.glCallList(this.starGLCallList);
1055                }
1056    
1057                GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
1058                GL11.glDisable(GL11.GL_BLEND);
1059                GL11.glEnable(GL11.GL_ALPHA_TEST);
1060                GL11.glEnable(GL11.GL_FOG);
1061                GL11.glPopMatrix();
1062                GL11.glDisable(GL11.GL_TEXTURE_2D);
1063                GL11.glColor3f(0.0F, 0.0F, 0.0F);
1064                double var25 = this.mc.thePlayer.getPosition(par1).yCoord - this.theWorld.getHorizon();
1065    
1066                if (var25 < 0.0D)
1067                {
1068                    GL11.glPushMatrix();
1069                    GL11.glTranslatef(0.0F, 12.0F, 0.0F);
1070                    GL11.glCallList(this.glSkyList2);
1071                    GL11.glPopMatrix();
1072                    var10 = 1.0F;
1073                    var11 = -((float)(var25 + 65.0D));
1074                    var12 = -var10;
1075                    var23.startDrawingQuads();
1076                    var23.setColorRGBA_I(0, 255);
1077                    var23.addVertex((double)(-var10), (double)var11, (double)var10);
1078                    var23.addVertex((double)var10, (double)var11, (double)var10);
1079                    var23.addVertex((double)var10, (double)var12, (double)var10);
1080                    var23.addVertex((double)(-var10), (double)var12, (double)var10);
1081                    var23.addVertex((double)(-var10), (double)var12, (double)(-var10));
1082                    var23.addVertex((double)var10, (double)var12, (double)(-var10));
1083                    var23.addVertex((double)var10, (double)var11, (double)(-var10));
1084                    var23.addVertex((double)(-var10), (double)var11, (double)(-var10));
1085                    var23.addVertex((double)var10, (double)var12, (double)(-var10));
1086                    var23.addVertex((double)var10, (double)var12, (double)var10);
1087                    var23.addVertex((double)var10, (double)var11, (double)var10);
1088                    var23.addVertex((double)var10, (double)var11, (double)(-var10));
1089                    var23.addVertex((double)(-var10), (double)var11, (double)(-var10));
1090                    var23.addVertex((double)(-var10), (double)var11, (double)var10);
1091                    var23.addVertex((double)(-var10), (double)var12, (double)var10);
1092                    var23.addVertex((double)(-var10), (double)var12, (double)(-var10));
1093                    var23.addVertex((double)(-var10), (double)var12, (double)(-var10));
1094                    var23.addVertex((double)(-var10), (double)var12, (double)var10);
1095                    var23.addVertex((double)var10, (double)var12, (double)var10);
1096                    var23.addVertex((double)var10, (double)var12, (double)(-var10));
1097                    var23.draw();
1098                }
1099    
1100                if (this.theWorld.provider.isSkyColored())
1101                {
1102                    GL11.glColor3f(var3 * 0.2F + 0.04F, var4 * 0.2F + 0.04F, var5 * 0.6F + 0.1F);
1103                }
1104                else
1105                {
1106                    GL11.glColor3f(var3, var4, var5);
1107                }
1108    
1109                GL11.glPushMatrix();
1110                GL11.glTranslatef(0.0F, -((float)(var25 - 16.0D)), 0.0F);
1111                GL11.glCallList(this.glSkyList2);
1112                GL11.glPopMatrix();
1113                GL11.glEnable(GL11.GL_TEXTURE_2D);
1114                GL11.glDepthMask(true);
1115            }
1116        }
1117    
1118        public void renderClouds(float par1)
1119        {
1120            if (this.mc.theWorld.provider.isSurfaceWorld())
1121            {
1122                if (this.mc.gameSettings.fancyGraphics)
1123                {
1124                    this.renderCloudsFancy(par1);
1125                }
1126                else
1127                {
1128                    GL11.glDisable(GL11.GL_CULL_FACE);
1129                    float var2 = (float)(this.mc.renderViewEntity.lastTickPosY + (this.mc.renderViewEntity.posY - this.mc.renderViewEntity.lastTickPosY) * (double)par1);
1130                    byte var3 = 32;
1131                    int var4 = 256 / var3;
1132                    Tessellator var5 = Tessellator.instance;
1133                    GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/environment/clouds.png"));
1134                    GL11.glEnable(GL11.GL_BLEND);
1135                    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
1136                    Vec3 var6 = this.theWorld.drawClouds(par1);
1137                    float var7 = (float)var6.xCoord;
1138                    float var8 = (float)var6.yCoord;
1139                    float var9 = (float)var6.zCoord;
1140                    float var10;
1141    
1142                    if (this.mc.gameSettings.anaglyph)
1143                    {
1144                        var10 = (var7 * 30.0F + var8 * 59.0F + var9 * 11.0F) / 100.0F;
1145                        float var11 = (var7 * 30.0F + var8 * 70.0F) / 100.0F;
1146                        float var12 = (var7 * 30.0F + var9 * 70.0F) / 100.0F;
1147                        var7 = var10;
1148                        var8 = var11;
1149                        var9 = var12;
1150                    }
1151    
1152                    var10 = 4.8828125E-4F;
1153                    double var24 = (double)((float)this.cloudOffsetX + par1);
1154                    double var13 = this.mc.renderViewEntity.prevPosX + (this.mc.renderViewEntity.posX - this.mc.renderViewEntity.prevPosX) * (double)par1 + var24 * 0.029999999329447746D;
1155                    double var15 = this.mc.renderViewEntity.prevPosZ + (this.mc.renderViewEntity.posZ - this.mc.renderViewEntity.prevPosZ) * (double)par1;
1156                    int var17 = MathHelper.floor_double(var13 / 2048.0D);
1157                    int var18 = MathHelper.floor_double(var15 / 2048.0D);
1158                    var13 -= (double)(var17 * 2048);
1159                    var15 -= (double)(var18 * 2048);
1160                    float var19 = this.theWorld.provider.getCloudHeight() - var2 + 0.33F;
1161                    float var20 = (float)(var13 * (double)var10);
1162                    float var21 = (float)(var15 * (double)var10);
1163                    var5.startDrawingQuads();
1164                    var5.setColorRGBA_F(var7, var8, var9, 0.8F);
1165    
1166                    for (int var22 = -var3 * var4; var22 < var3 * var4; var22 += var3)
1167                    {
1168                        for (int var23 = -var3 * var4; var23 < var3 * var4; var23 += var3)
1169                        {
1170                            var5.addVertexWithUV((double)(var22 + 0), (double)var19, (double)(var23 + var3), (double)((float)(var22 + 0) * var10 + var20), (double)((float)(var23 + var3) * var10 + var21));
1171                            var5.addVertexWithUV((double)(var22 + var3), (double)var19, (double)(var23 + var3), (double)((float)(var22 + var3) * var10 + var20), (double)((float)(var23 + var3) * var10 + var21));
1172                            var5.addVertexWithUV((double)(var22 + var3), (double)var19, (double)(var23 + 0), (double)((float)(var22 + var3) * var10 + var20), (double)((float)(var23 + 0) * var10 + var21));
1173                            var5.addVertexWithUV((double)(var22 + 0), (double)var19, (double)(var23 + 0), (double)((float)(var22 + 0) * var10 + var20), (double)((float)(var23 + 0) * var10 + var21));
1174                        }
1175                    }
1176    
1177                    var5.draw();
1178                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
1179                    GL11.glDisable(GL11.GL_BLEND);
1180                    GL11.glEnable(GL11.GL_CULL_FACE);
1181                }
1182            }
1183        }
1184    
1185        public boolean func_72721_a(double par1, double par3, double par5, float par7)
1186        {
1187            return false;
1188        }
1189    
1190        /**
1191         * Renders the 3d fancy clouds
1192         */
1193        public void renderCloudsFancy(float par1)
1194        {
1195            GL11.glDisable(GL11.GL_CULL_FACE);
1196            float var2 = (float)(this.mc.renderViewEntity.lastTickPosY + (this.mc.renderViewEntity.posY - this.mc.renderViewEntity.lastTickPosY) * (double)par1);
1197            Tessellator var3 = Tessellator.instance;
1198            float var4 = 12.0F;
1199            float var5 = 4.0F;
1200            double var6 = (double)((float)this.cloudOffsetX + par1);
1201            double var8 = (this.mc.renderViewEntity.prevPosX + (this.mc.renderViewEntity.posX - this.mc.renderViewEntity.prevPosX) * (double)par1 + var6 * 0.029999999329447746D) / (double)var4;
1202            double var10 = (this.mc.renderViewEntity.prevPosZ + (this.mc.renderViewEntity.posZ - this.mc.renderViewEntity.prevPosZ) * (double)par1) / (double)var4 + 0.33000001311302185D;
1203            float var12 = this.theWorld.provider.getCloudHeight() - var2 + 0.33F;
1204            int var13 = MathHelper.floor_double(var8 / 2048.0D);
1205            int var14 = MathHelper.floor_double(var10 / 2048.0D);
1206            var8 -= (double)(var13 * 2048);
1207            var10 -= (double)(var14 * 2048);
1208            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/environment/clouds.png"));
1209            GL11.glEnable(GL11.GL_BLEND);
1210            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
1211            Vec3 var15 = this.theWorld.drawClouds(par1);
1212            float var16 = (float)var15.xCoord;
1213            float var17 = (float)var15.yCoord;
1214            float var18 = (float)var15.zCoord;
1215            float var19;
1216            float var21;
1217            float var20;
1218    
1219            if (this.mc.gameSettings.anaglyph)
1220            {
1221                var19 = (var16 * 30.0F + var17 * 59.0F + var18 * 11.0F) / 100.0F;
1222                var20 = (var16 * 30.0F + var17 * 70.0F) / 100.0F;
1223                var21 = (var16 * 30.0F + var18 * 70.0F) / 100.0F;
1224                var16 = var19;
1225                var17 = var20;
1226                var18 = var21;
1227            }
1228    
1229            var19 = (float)(var8 * 0.0D);
1230            var20 = (float)(var10 * 0.0D);
1231            var21 = 0.00390625F;
1232            var19 = (float)MathHelper.floor_double(var8) * var21;
1233            var20 = (float)MathHelper.floor_double(var10) * var21;
1234            float var22 = (float)(var8 - (double)MathHelper.floor_double(var8));
1235            float var23 = (float)(var10 - (double)MathHelper.floor_double(var10));
1236            byte var24 = 8;
1237            byte var25 = 4;
1238            float var26 = 9.765625E-4F;
1239            GL11.glScalef(var4, 1.0F, var4);
1240    
1241            for (int var27 = 0; var27 < 2; ++var27)
1242            {
1243                if (var27 == 0)
1244                {
1245                    GL11.glColorMask(false, false, false, false);
1246                }
1247                else if (this.mc.gameSettings.anaglyph)
1248                {
1249                    if (EntityRenderer.anaglyphField == 0)
1250                    {
1251                        GL11.glColorMask(false, true, true, true);
1252                    }
1253                    else
1254                    {
1255                        GL11.glColorMask(true, false, false, true);
1256                    }
1257                }
1258                else
1259                {
1260                    GL11.glColorMask(true, true, true, true);
1261                }
1262    
1263                for (int var28 = -var25 + 1; var28 <= var25; ++var28)
1264                {
1265                    for (int var29 = -var25 + 1; var29 <= var25; ++var29)
1266                    {
1267                        var3.startDrawingQuads();
1268                        float var30 = (float)(var28 * var24);
1269                        float var31 = (float)(var29 * var24);
1270                        float var32 = var30 - var22;
1271                        float var33 = var31 - var23;
1272    
1273                        if (var12 > -var5 - 1.0F)
1274                        {
1275                            var3.setColorRGBA_F(var16 * 0.7F, var17 * 0.7F, var18 * 0.7F, 0.8F);
1276                            var3.setNormal(0.0F, -1.0F, 0.0F);
1277                            var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + (float)var24), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1278                            var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + 0.0F), (double)(var33 + (float)var24), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1279                            var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + 0.0F), (double)(var33 + 0.0F), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1280                            var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + 0.0F), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1281                        }
1282    
1283                        if (var12 <= var5 + 1.0F)
1284                        {
1285                            var3.setColorRGBA_F(var16, var17, var18, 0.8F);
1286                            var3.setNormal(0.0F, 1.0F, 0.0F);
1287                            var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + var5 - var26), (double)(var33 + (float)var24), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1288                            var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + var5 - var26), (double)(var33 + (float)var24), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1289                            var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + var5 - var26), (double)(var33 + 0.0F), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1290                            var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + var5 - var26), (double)(var33 + 0.0F), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1291                        }
1292    
1293                        var3.setColorRGBA_F(var16 * 0.9F, var17 * 0.9F, var18 * 0.9F, 0.8F);
1294                        int var34;
1295    
1296                        if (var28 > -1)
1297                        {
1298                            var3.setNormal(-1.0F, 0.0F, 0.0F);
1299    
1300                            for (var34 = 0; var34 < var24; ++var34)
1301                            {
1302                                var3.addVertexWithUV((double)(var32 + (float)var34 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + (float)var24), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1303                                var3.addVertexWithUV((double)(var32 + (float)var34 + 0.0F), (double)(var12 + var5), (double)(var33 + (float)var24), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1304                                var3.addVertexWithUV((double)(var32 + (float)var34 + 0.0F), (double)(var12 + var5), (double)(var33 + 0.0F), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1305                                var3.addVertexWithUV((double)(var32 + (float)var34 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + 0.0F), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1306                            }
1307                        }
1308    
1309                        if (var28 <= 1)
1310                        {
1311                            var3.setNormal(1.0F, 0.0F, 0.0F);
1312    
1313                            for (var34 = 0; var34 < var24; ++var34)
1314                            {
1315                                var3.addVertexWithUV((double)(var32 + (float)var34 + 1.0F - var26), (double)(var12 + 0.0F), (double)(var33 + (float)var24), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1316                                var3.addVertexWithUV((double)(var32 + (float)var34 + 1.0F - var26), (double)(var12 + var5), (double)(var33 + (float)var24), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + (float)var24) * var21 + var20));
1317                                var3.addVertexWithUV((double)(var32 + (float)var34 + 1.0F - var26), (double)(var12 + var5), (double)(var33 + 0.0F), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1318                                var3.addVertexWithUV((double)(var32 + (float)var34 + 1.0F - var26), (double)(var12 + 0.0F), (double)(var33 + 0.0F), (double)((var30 + (float)var34 + 0.5F) * var21 + var19), (double)((var31 + 0.0F) * var21 + var20));
1319                            }
1320                        }
1321    
1322                        var3.setColorRGBA_F(var16 * 0.8F, var17 * 0.8F, var18 * 0.8F, 0.8F);
1323    
1324                        if (var29 > -1)
1325                        {
1326                            var3.setNormal(0.0F, 0.0F, -1.0F);
1327    
1328                            for (var34 = 0; var34 < var24; ++var34)
1329                            {
1330                                var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + var5), (double)(var33 + (float)var34 + 0.0F), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1331                                var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + var5), (double)(var33 + (float)var34 + 0.0F), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1332                                var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + 0.0F), (double)(var33 + (float)var34 + 0.0F), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1333                                var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + (float)var34 + 0.0F), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1334                            }
1335                        }
1336    
1337                        if (var29 <= 1)
1338                        {
1339                            var3.setNormal(0.0F, 0.0F, 1.0F);
1340    
1341                            for (var34 = 0; var34 < var24; ++var34)
1342                            {
1343                                var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + var5), (double)(var33 + (float)var34 + 1.0F - var26), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1344                                var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + var5), (double)(var33 + (float)var34 + 1.0F - var26), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1345                                var3.addVertexWithUV((double)(var32 + (float)var24), (double)(var12 + 0.0F), (double)(var33 + (float)var34 + 1.0F - var26), (double)((var30 + (float)var24) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1346                                var3.addVertexWithUV((double)(var32 + 0.0F), (double)(var12 + 0.0F), (double)(var33 + (float)var34 + 1.0F - var26), (double)((var30 + 0.0F) * var21 + var19), (double)((var31 + (float)var34 + 0.5F) * var21 + var20));
1347                            }
1348                        }
1349    
1350                        var3.draw();
1351                    }
1352                }
1353            }
1354    
1355            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
1356            GL11.glDisable(GL11.GL_BLEND);
1357            GL11.glEnable(GL11.GL_CULL_FACE);
1358        }
1359    
1360        /**
1361         * Updates some of the renderers sorted by distance from the player
1362         */
1363        public boolean updateRenderers(EntityLiving par1EntityLiving, boolean par2)
1364        {
1365            byte var3 = 2;
1366            RenderSorter var4 = new RenderSorter(par1EntityLiving);
1367            WorldRenderer[] var5 = new WorldRenderer[var3];
1368            ArrayList var6 = null;
1369            int var7 = this.worldRenderersToUpdate.size();
1370            int var8 = 0;
1371            this.theWorld.theProfiler.startSection("nearChunksSearch");
1372            int var9;
1373            WorldRenderer var10;
1374            int var11;
1375            int var12;
1376            label136:
1377    
1378            for (var9 = 0; var9 < var7; ++var9)
1379            {
1380                var10 = (WorldRenderer)this.worldRenderersToUpdate.get(var9);
1381    
1382                if (var10 != null)
1383                {
1384                    if (!par2)
1385                    {
1386                        if (var10.distanceToEntitySquared(par1EntityLiving) > 256.0F)
1387                        {
1388                            for (var11 = 0; var11 < var3 && (var5[var11] == null || var4.doCompare(var5[var11], var10) <= 0); ++var11)
1389                            {
1390                                ;
1391                            }
1392    
1393                            --var11;
1394    
1395                            if (var11 > 0)
1396                            {
1397                                var12 = var11;
1398    
1399                                while (true)
1400                                {
1401                                    --var12;
1402    
1403                                    if (var12 == 0)
1404                                    {
1405                                        var5[var11] = var10;
1406                                        continue label136;
1407                                    }
1408    
1409                                    var5[var12 - 1] = var5[var12];
1410                                }
1411                            }
1412    
1413                            continue;
1414                        }
1415                    }
1416                    else if (!var10.isInFrustum)
1417                    {
1418                        continue;
1419                    }
1420    
1421                    if (var6 == null)
1422                    {
1423                        var6 = new ArrayList();
1424                    }
1425    
1426                    ++var8;
1427                    var6.add(var10);
1428                    this.worldRenderersToUpdate.set(var9, (Object)null);
1429                }
1430            }
1431    
1432            this.theWorld.theProfiler.endSection();
1433            this.theWorld.theProfiler.startSection("sort");
1434    
1435            if (var6 != null)
1436            {
1437                if (var6.size() > 1)
1438                {
1439                    Collections.sort(var6, var4);
1440                }
1441    
1442                for (var9 = var6.size() - 1; var9 >= 0; --var9)
1443                {
1444                    var10 = (WorldRenderer)var6.get(var9);
1445                    var10.updateRenderer();
1446                    var10.needsUpdate = false;
1447                }
1448            }
1449    
1450            this.theWorld.theProfiler.endSection();
1451            var9 = 0;
1452            this.theWorld.theProfiler.startSection("rebuild");
1453            int var16;
1454    
1455            for (var16 = var3 - 1; var16 >= 0; --var16)
1456            {
1457                WorldRenderer var17 = var5[var16];
1458    
1459                if (var17 != null)
1460                {
1461                    if (!var17.isInFrustum && var16 != var3 - 1)
1462                    {
1463                        var5[var16] = null;
1464                        var5[0] = null;
1465                        break;
1466                    }
1467    
1468                    var5[var16].updateRenderer();
1469                    var5[var16].needsUpdate = false;
1470                    ++var9;
1471                }
1472            }
1473    
1474            this.theWorld.theProfiler.endSection();
1475            this.theWorld.theProfiler.startSection("cleanup");
1476            var16 = 0;
1477            var11 = 0;
1478    
1479            for (var12 = this.worldRenderersToUpdate.size(); var16 != var12; ++var16)
1480            {
1481                WorldRenderer var13 = (WorldRenderer)this.worldRenderersToUpdate.get(var16);
1482    
1483                if (var13 != null)
1484                {
1485                    boolean var14 = false;
1486    
1487                    for (int var15 = 0; var15 < var3 && !var14; ++var15)
1488                    {
1489                        if (var13 == var5[var15])
1490                        {
1491                            var14 = true;
1492                        }
1493                    }
1494    
1495                    if (!var14)
1496                    {
1497                        if (var11 != var16)
1498                        {
1499                            this.worldRenderersToUpdate.set(var11, var13);
1500                        }
1501    
1502                        ++var11;
1503                    }
1504                }
1505            }
1506    
1507            this.theWorld.theProfiler.endSection();
1508            this.theWorld.theProfiler.startSection("trim");
1509    
1510            while (true)
1511            {
1512                --var16;
1513    
1514                if (var16 < var11)
1515                {
1516                    this.theWorld.theProfiler.endSection();
1517                    return var7 == var8 + var9;
1518                }
1519    
1520                this.worldRenderersToUpdate.remove(var16);
1521            }
1522        }
1523    
1524        public void drawBlockBreaking(EntityPlayer par1EntityPlayer, MovingObjectPosition par2MovingObjectPosition, int par3, ItemStack par4ItemStack, float par5)
1525        {
1526            Tessellator var6 = Tessellator.instance;
1527            GL11.glEnable(GL11.GL_BLEND);
1528            GL11.glEnable(GL11.GL_ALPHA_TEST);
1529            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
1530            GL11.glColor4f(1.0F, 1.0F, 1.0F, (MathHelper.sin((float)Minecraft.getSystemTime() / 100.0F) * 0.2F + 0.4F) * 0.5F);
1531    
1532            if (par3 != 0 && par4ItemStack != null)
1533            {
1534                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
1535                float var7 = MathHelper.sin((float)Minecraft.getSystemTime() / 100.0F) * 0.2F + 0.8F;
1536                GL11.glColor4f(var7, var7, var7, MathHelper.sin((float)Minecraft.getSystemTime() / 200.0F) * 0.2F + 0.5F);
1537                int var8 = this.renderEngine.getTexture("/terrain.png");
1538                GL11.glBindTexture(GL11.GL_TEXTURE_2D, var8);
1539            }
1540    
1541            GL11.glDisable(GL11.GL_BLEND);
1542            GL11.glDisable(GL11.GL_ALPHA_TEST);
1543        }
1544    
1545        public void drawBlockDamageTexture(Tessellator par1Tessellator, EntityPlayer par2EntityPlayer, float par3)
1546        {
1547            double var4 = par2EntityPlayer.lastTickPosX + (par2EntityPlayer.posX - par2EntityPlayer.lastTickPosX) * (double)par3;
1548            double var6 = par2EntityPlayer.lastTickPosY + (par2EntityPlayer.posY - par2EntityPlayer.lastTickPosY) * (double)par3;
1549            double var8 = par2EntityPlayer.lastTickPosZ + (par2EntityPlayer.posZ - par2EntityPlayer.lastTickPosZ) * (double)par3;
1550    
1551            if (!this.field_72738_E.isEmpty())
1552            {
1553                GL11.glBlendFunc(GL11.GL_DST_COLOR, GL11.GL_SRC_COLOR);
1554                int var10 = this.renderEngine.getTexture("/terrain.png");
1555                GL11.glBindTexture(GL11.GL_TEXTURE_2D, var10);
1556                GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.5F);
1557                GL11.glPushMatrix();
1558                GL11.glDisable(GL11.GL_ALPHA_TEST);
1559                GL11.glPolygonOffset(-3.0F, -3.0F);
1560                GL11.glEnable(GL11.GL_POLYGON_OFFSET_FILL);
1561                GL11.glEnable(GL11.GL_ALPHA_TEST);
1562                par1Tessellator.startDrawingQuads();
1563                par1Tessellator.setTranslation(-var4, -var6, -var8);
1564                par1Tessellator.disableColor();
1565                Iterator var11 = this.field_72738_E.values().iterator();
1566    
1567                while (var11.hasNext())
1568                {
1569                    DestroyBlockProgress var12 = (DestroyBlockProgress)var11.next();
1570                    double var13 = (double)var12.func_73110_b() - var4;
1571                    double var15 = (double)var12.func_73109_c() - var6;
1572                    double var17 = (double)var12.func_73108_d() - var8;
1573    
1574                    if (var13 * var13 + var15 * var15 + var17 * var17 > 1024.0D)
1575                    {
1576                        var11.remove();
1577                    }
1578                    else
1579                    {
1580                        int var19 = this.theWorld.getBlockId(var12.func_73110_b(), var12.func_73109_c(), var12.func_73108_d());
1581                        Block var20 = var19 > 0 ? Block.blocksList[var19] : null;
1582    
1583                        if (var20 == null)
1584                        {
1585                            var20 = Block.stone;
1586                        }
1587    
1588                        this.globalRenderBlocks.renderBlockUsingTexture(var20, var12.func_73110_b(), var12.func_73109_c(), var12.func_73108_d(), 240 + var12.func_73106_e());
1589                    }
1590                }
1591    
1592                par1Tessellator.draw();
1593                par1Tessellator.setTranslation(0.0D, 0.0D, 0.0D);
1594                GL11.glDisable(GL11.GL_ALPHA_TEST);
1595                GL11.glPolygonOffset(0.0F, 0.0F);
1596                GL11.glDisable(GL11.GL_POLYGON_OFFSET_FILL);
1597                GL11.glEnable(GL11.GL_ALPHA_TEST);
1598                GL11.glDepthMask(true);
1599                GL11.glPopMatrix();
1600            }
1601        }
1602    
1603        /**
1604         * Draws the selection box for the player. Args: entityPlayer, rayTraceHit, i, itemStack, partialTickTime
1605         */
1606        public void drawSelectionBox(EntityPlayer par1EntityPlayer, MovingObjectPosition par2MovingObjectPosition, int par3, ItemStack par4ItemStack, float par5)
1607        {
1608            if (par3 == 0 && par2MovingObjectPosition.typeOfHit == EnumMovingObjectType.TILE)
1609            {
1610                GL11.glEnable(GL11.GL_BLEND);
1611                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
1612                GL11.glColor4f(0.0F, 0.0F, 0.0F, 0.4F);
1613                GL11.glLineWidth(2.0F);
1614                GL11.glDisable(GL11.GL_TEXTURE_2D);
1615                GL11.glDepthMask(false);
1616                float var6 = 0.002F;
1617                int var7 = this.theWorld.getBlockId(par2MovingObjectPosition.blockX, par2MovingObjectPosition.blockY, par2MovingObjectPosition.blockZ);
1618    
1619                if (var7 > 0)
1620                {
1621                    Block.blocksList[var7].setBlockBoundsBasedOnState(this.theWorld, par2MovingObjectPosition.blockX, par2MovingObjectPosition.blockY, par2MovingObjectPosition.blockZ);
1622                    double var8 = par1EntityPlayer.lastTickPosX + (par1EntityPlayer.posX - par1EntityPlayer.lastTickPosX) * (double)par5;
1623                    double var10 = par1EntityPlayer.lastTickPosY + (par1EntityPlayer.posY - par1EntityPlayer.lastTickPosY) * (double)par5;
1624                    double var12 = par1EntityPlayer.lastTickPosZ + (par1EntityPlayer.posZ - par1EntityPlayer.lastTickPosZ) * (double)par5;
1625                    this.drawOutlinedBoundingBox(Block.blocksList[var7].getSelectedBoundingBoxFromPool(this.theWorld, par2MovingObjectPosition.blockX, par2MovingObjectPosition.blockY, par2MovingObjectPosition.blockZ).expand((double)var6, (double)var6, (double)var6).getOffsetBoundingBox(-var8, -var10, -var12));
1626                }
1627    
1628                GL11.glDepthMask(true);
1629                GL11.glEnable(GL11.GL_TEXTURE_2D);
1630                GL11.glDisable(GL11.GL_BLEND);
1631            }
1632        }
1633    
1634        /**
1635         * Draws lines for the edges of the bounding box.
1636         */
1637        private void drawOutlinedBoundingBox(AxisAlignedBB par1AxisAlignedBB)
1638        {
1639            Tessellator var2 = Tessellator.instance;
1640            var2.startDrawing(3);
1641            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
1642            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
1643            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
1644            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
1645            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
1646            var2.draw();
1647            var2.startDrawing(3);
1648            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
1649            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
1650            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
1651            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
1652            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
1653            var2.draw();
1654            var2.startDrawing(1);
1655            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
1656            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
1657            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.minZ);
1658            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.minZ);
1659            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
1660            var2.addVertex(par1AxisAlignedBB.maxX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
1661            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.minY, par1AxisAlignedBB.maxZ);
1662            var2.addVertex(par1AxisAlignedBB.minX, par1AxisAlignedBB.maxY, par1AxisAlignedBB.maxZ);
1663            var2.draw();
1664        }
1665    
1666        /**
1667         * Marks the blocks in the given range for update
1668         */
1669        public void markBlocksForUpdate(int par1, int par2, int par3, int par4, int par5, int par6)
1670        {
1671            int var7 = MathHelper.bucketInt(par1, 16);
1672            int var8 = MathHelper.bucketInt(par2, 16);
1673            int var9 = MathHelper.bucketInt(par3, 16);
1674            int var10 = MathHelper.bucketInt(par4, 16);
1675            int var11 = MathHelper.bucketInt(par5, 16);
1676            int var12 = MathHelper.bucketInt(par6, 16);
1677    
1678            for (int var13 = var7; var13 <= var10; ++var13)
1679            {
1680                int var14 = var13 % this.renderChunksWide;
1681    
1682                if (var14 < 0)
1683                {
1684                    var14 += this.renderChunksWide;
1685                }
1686    
1687                for (int var15 = var8; var15 <= var11; ++var15)
1688                {
1689                    int var16 = var15 % this.renderChunksTall;
1690    
1691                    if (var16 < 0)
1692                    {
1693                        var16 += this.renderChunksTall;
1694                    }
1695    
1696                    for (int var17 = var9; var17 <= var12; ++var17)
1697                    {
1698                        int var18 = var17 % this.renderChunksDeep;
1699    
1700                        if (var18 < 0)
1701                        {
1702                            var18 += this.renderChunksDeep;
1703                        }
1704    
1705                        int var19 = (var18 * this.renderChunksTall + var16) * this.renderChunksWide + var14;
1706                        WorldRenderer var20 = this.worldRenderers[var19];
1707    
1708                        if (var20 != null && !var20.needsUpdate)
1709                        {
1710                            this.worldRenderersToUpdate.add(var20);
1711                            var20.markDirty();
1712                        }
1713                    }
1714                }
1715            }
1716        }
1717    
1718        /**
1719         * Will mark the block and neighbors that their renderers need an update (could be all the same renderer
1720         * potentially) Args: x, y, z
1721         */
1722        public void markBlockNeedsUpdate(int par1, int par2, int par3)
1723        {
1724            this.markBlocksForUpdate(par1 - 1, par2 - 1, par3 - 1, par1 + 1, par2 + 1, par3 + 1);
1725        }
1726    
1727        /**
1728         * As of mc 1.2.3 this method has exactly the same signature and does exactly the same as markBlockNeedsUpdate
1729         */
1730        public void markBlockNeedsUpdate2(int par1, int par2, int par3)
1731        {
1732            this.markBlocksForUpdate(par1 - 1, par2 - 1, par3 - 1, par1 + 1, par2 + 1, par3 + 1);
1733        }
1734    
1735        /**
1736         * Called across all registered IWorldAccess instances when a block range is invalidated. Args: minX, minY, minZ,
1737         * maxX, maxY, maxZ
1738         */
1739        public void markBlockRangeNeedsUpdate(int par1, int par2, int par3, int par4, int par5, int par6)
1740        {
1741            this.markBlocksForUpdate(par1 - 1, par2 - 1, par3 - 1, par4 + 1, par5 + 1, par6 + 1);
1742        }
1743    
1744        /**
1745         * Checks all renderers that previously weren't in the frustum and 1/16th of those that previously were in the
1746         * frustum for frustum clipping Args: frustum, partialTickTime
1747         */
1748        public void clipRenderersByFrustum(ICamera par1ICamera, float par2)
1749        {
1750            for (int var3 = 0; var3 < this.worldRenderers.length; ++var3)
1751            {
1752                if (!this.worldRenderers[var3].skipAllRenderPasses() && (!this.worldRenderers[var3].isInFrustum || (var3 + this.frustumCheckOffset & 15) == 0))
1753                {
1754                    this.worldRenderers[var3].updateInFrustum(par1ICamera);
1755                }
1756            }
1757    
1758            ++this.frustumCheckOffset;
1759        }
1760    
1761        /**
1762         * Plays the specified record. Arg: recordName, x, y, z
1763         */
1764        public void playRecord(String par1Str, int par2, int par3, int par4)
1765        {
1766            if (par1Str != null)
1767            {
1768                this.mc.ingameGUI.setRecordPlayingMessage("C418 - " + par1Str);
1769            }
1770    
1771            this.mc.sndManager.playStreaming(par1Str, (float)par2, (float)par3, (float)par4, 1.0F, 1.0F);
1772        }
1773    
1774        /**
1775         * Plays the specified sound. Arg: soundName, x, y, z, volume, pitch
1776         */
1777        public void playSound(String par1Str, double par2, double par4, double par6, float par8, float par9) {}
1778    
1779        /**
1780         * Spawns a particle. Arg: particleType, x, y, z, velX, velY, velZ
1781         */
1782        public void spawnParticle(String par1Str, double par2, double par4, double par6, double par8, double par10, double par12)
1783        {
1784            this.func_72726_b(par1Str, par2, par4, par6, par8, par10, par12);
1785        }
1786    
1787        public EntityFX func_72726_b(String par1Str, double par2, double par4, double par6, double par8, double par10, double par12)
1788        {
1789            if (this.mc != null && this.mc.renderViewEntity != null && this.mc.effectRenderer != null)
1790            {
1791                int var14 = this.mc.gameSettings.particleSetting;
1792    
1793                if (var14 == 1 && this.theWorld.rand.nextInt(3) == 0)
1794                {
1795                    var14 = 2;
1796                }
1797    
1798                double var15 = this.mc.renderViewEntity.posX - par2;
1799                double var17 = this.mc.renderViewEntity.posY - par4;
1800                double var19 = this.mc.renderViewEntity.posZ - par6;
1801                EntityFX var21 = null;
1802                Object effectObject = null;
1803    
1804                if (par1Str.equals("hugeexplosion"))
1805                {
1806                    this.mc.effectRenderer.addEffect(var21 = new EntityHugeExplodeFX(this.theWorld, par2, par4, par6, par8, par10, par12));
1807                }
1808                else if (par1Str.equals("largeexplode"))
1809                {
1810                    this.mc.effectRenderer.addEffect(var21 = new EntityLargeExplodeFX(this.renderEngine, this.theWorld, par2, par4, par6, par8, par10, par12));
1811                }
1812    
1813                if (var21 != null)
1814                {
1815                    return (EntityFX)var21;
1816                }
1817                else
1818                {
1819                    double var22 = 16.0D;
1820    
1821                    if (var15 * var15 + var17 * var17 + var19 * var19 > var22 * var22)
1822                    {
1823                        return null;
1824                    }
1825                    else if (var14 > 1)
1826                    {
1827                        return null;
1828                    }
1829                    else
1830                    {
1831                        if (par1Str.equals("bubble"))
1832                        {
1833                            var21 = new EntityBubbleFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1834                        }
1835                        else if (par1Str.equals("suspended"))
1836                        {
1837                            var21 = new EntitySuspendFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1838                        }
1839                        else if (par1Str.equals("depthsuspend"))
1840                        {
1841                            var21 = new EntityAuraFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1842                        }
1843                        else if (par1Str.equals("townaura"))
1844                        {
1845                            var21 = new EntityAuraFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1846                        }
1847                        else if (par1Str.equals("crit"))
1848                        {
1849                            var21 = new EntityCritFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1850                        }
1851                        else if (par1Str.equals("magicCrit"))
1852                        {
1853                            var21 = new EntityCritFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1854                            ((EntityFX)var21).setRBGColorF(((EntityFX)var21).getRedColorF() * 0.3F, ((EntityFX)var21).getGreenColorF() * 0.8F, ((EntityFX)var21).getBlueColorF());
1855                            ((EntityFX)var21).setParticleTextureIndex(((EntityFX)var21).getParticleTextureIndex() + 1);
1856                        }
1857                        else if (par1Str.equals("smoke"))
1858                        {
1859                            var21 = new EntitySmokeFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1860                        }
1861                        else if (par1Str.equals("mobSpell"))
1862                        {
1863                            var21 = new EntitySpellParticleFX(this.theWorld, par2, par4, par6, 0.0D, 0.0D, 0.0D);
1864                            ((EntityFX)var21).setRBGColorF((float)par8, (float)par10, (float)par12);
1865                        }
1866                        else if (par1Str.equals("spell"))
1867                        {
1868                            var21 = new EntitySpellParticleFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1869                        }
1870                        else if (par1Str.equals("instantSpell"))
1871                        {
1872                            var21 = new EntitySpellParticleFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1873                            ((EntitySpellParticleFX)var21).func_70589_b(144);
1874                        }
1875                        else if (par1Str.equals("note"))
1876                        {
1877                            var21 = new EntityNoteFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1878                        }
1879                        else if (par1Str.equals("portal"))
1880                        {
1881                            var21 = new EntityPortalFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1882                        }
1883                        else if (par1Str.equals("enchantmenttable"))
1884                        {
1885                            var21 = new EntityEnchantmentTableParticleFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1886                        }
1887                        else if (par1Str.equals("explode"))
1888                        {
1889                            var21 = new EntityExplodeFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1890                        }
1891                        else if (par1Str.equals("flame"))
1892                        {
1893                            var21 = new EntityFlameFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1894                        }
1895                        else if (par1Str.equals("lava"))
1896                        {
1897                            var21 = new EntityLavaFX(this.theWorld, par2, par4, par6);
1898                        }
1899                        else if (par1Str.equals("footstep"))
1900                        {
1901                            var21 = new EntityFootStepFX(this.renderEngine, this.theWorld, par2, par4, par6);
1902                        }
1903                        else if (par1Str.equals("splash"))
1904                        {
1905                            var21 = new EntitySplashFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1906                        }
1907                        else if (par1Str.equals("largesmoke"))
1908                        {
1909                            var21 = new EntitySmokeFX(this.theWorld, par2, par4, par6, par8, par10, par12, 2.5F);
1910                        }
1911                        else if (par1Str.equals("cloud"))
1912                        {
1913                            var21 = new EntityCloudFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1914                        }
1915                        else if (par1Str.equals("reddust"))
1916                        {
1917                            var21 = new EntityReddustFX(this.theWorld, par2, par4, par6, (float)par8, (float)par10, (float)par12);
1918                        }
1919                        else if (par1Str.equals("snowballpoof"))
1920                        {
1921                            var21 = new EntityBreakingFX(this.theWorld, par2, par4, par6, Item.snowball);
1922                            effectObject = Item.snowball;
1923                        }
1924                        else if (par1Str.equals("dripWater"))
1925                        {
1926                            var21 = new EntityDropParticleFX(this.theWorld, par2, par4, par6, Material.water);
1927                        }
1928                        else if (par1Str.equals("dripLava"))
1929                        {
1930                            var21 = new EntityDropParticleFX(this.theWorld, par2, par4, par6, Material.lava);
1931                        }
1932                        else if (par1Str.equals("snowshovel"))
1933                        {
1934                            var21 = new EntitySnowShovelFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1935                        }
1936                        else if (par1Str.equals("slime"))
1937                        {
1938                            var21 = new EntityBreakingFX(this.theWorld, par2, par4, par6, Item.slimeBall);
1939                            effectObject = Item.slimeBall;
1940                        }
1941                        else if (par1Str.equals("heart"))
1942                        {
1943                            var21 = new EntityHeartFX(this.theWorld, par2, par4, par6, par8, par10, par12);
1944                        }
1945                        else
1946                        {
1947                            int var24;
1948    
1949                            if (par1Str.startsWith("iconcrack_"))
1950                            {
1951                                var24 = Integer.parseInt(par1Str.substring(par1Str.indexOf("_") + 1));
1952                                var21 = new EntityBreakingFX(this.theWorld, par2, par4, par6, par8, par10, par12, Item.itemsList[var24]);
1953                                effectObject = Item.itemsList[var24];
1954                            }
1955                            else if (par1Str.startsWith("tilecrack_"))
1956                            {
1957                                var24 = Integer.parseInt(par1Str.substring(par1Str.indexOf("_") + 1));
1958                                var21 = new EntityDiggingFX(this.theWorld, par2, par4, par6, par8, par10, par12, Block.blocksList[var24], 0, 0);
1959                                effectObject = Block.blocksList[var24];
1960                            }
1961                        }
1962    
1963                        if (var21 != null)
1964                        {
1965                            this.mc.effectRenderer.addEffect((EntityFX)var21, effectObject);
1966                        }
1967    
1968                        return (EntityFX)var21;
1969                    }
1970                }
1971            }
1972            else
1973            {
1974                return null;
1975            }
1976        }
1977    
1978        /**
1979         * Start the skin for this entity downloading, if necessary, and increment its reference counter
1980         */
1981        public void obtainEntitySkin(Entity par1Entity)
1982        {
1983            par1Entity.updateCloak();
1984    
1985            if (par1Entity.skinUrl != null)
1986            {
1987                this.renderEngine.obtainImageData(par1Entity.skinUrl, new ImageBufferDownload());
1988            }
1989    
1990            if (par1Entity.cloakUrl != null)
1991            {
1992                this.renderEngine.obtainImageData(par1Entity.cloakUrl, new ImageBufferDownload());
1993            }
1994        }
1995    
1996        /**
1997         * Decrement the reference counter for this entity's skin image data
1998         */
1999        public void releaseEntitySkin(Entity par1Entity)
2000        {
2001            if (par1Entity.skinUrl != null)
2002            {
2003                this.renderEngine.releaseImageData(par1Entity.skinUrl);
2004            }
2005    
2006            if (par1Entity.cloakUrl != null)
2007            {
2008                this.renderEngine.releaseImageData(par1Entity.cloakUrl);
2009            }
2010        }
2011    
2012        public void func_72728_f()
2013        {
2014            GLAllocation.deleteDisplayLists(this.glRenderListBase);
2015        }
2016    
2017        /**
2018         * Plays a pre-canned sound effect along with potentially auxiliary data-driven one-shot behaviour (particles, etc).
2019         */
2020        public void playAuxSFX(EntityPlayer par1EntityPlayer, int par2, int par3, int par4, int par5, int par6)
2021        {
2022            Random var7 = this.theWorld.rand;
2023            double var8;
2024            double var10;
2025            double var12;
2026            String var14;
2027            int var15;
2028            int var20;
2029            double var23;
2030            double var25;
2031            double var27;
2032            double var29;
2033            double var39;
2034    
2035            switch (par2)
2036            {
2037                case 1000:
2038                    this.theWorld.playSound((double)par3, (double)par4, (double)par5, "random.click", 1.0F, 1.0F);
2039                    break;
2040                case 1001:
2041                    this.theWorld.playSound((double)par3, (double)par4, (double)par5, "random.click", 1.0F, 1.2F);
2042                    break;
2043                case 1002:
2044                    this.theWorld.playSound((double)par3, (double)par4, (double)par5, "random.bow", 1.0F, 1.2F);
2045                    break;
2046                case 1003:
2047                    if (Math.random() < 0.5D)
2048                    {
2049                        this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "random.door_open", 1.0F, this.theWorld.rand.nextFloat() * 0.1F + 0.9F);
2050                    }
2051                    else
2052                    {
2053                        this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "random.door_close", 1.0F, this.theWorld.rand.nextFloat() * 0.1F + 0.9F);
2054                    }
2055    
2056                    break;
2057                case 1004:
2058                    this.theWorld.playSound((double)((float)par3 + 0.5F), (double)((float)par4 + 0.5F), (double)((float)par5 + 0.5F), "random.fizz", 0.5F, 2.6F + (var7.nextFloat() - var7.nextFloat()) * 0.8F);
2059                    break;
2060                case 1005:
2061                    if (Item.itemsList[par6] instanceof ItemRecord)
2062                    {
2063                        this.theWorld.playRecord(((ItemRecord)Item.itemsList[par6]).recordName, par3, par4, par5);
2064                    }
2065                    else
2066                    {
2067                        this.theWorld.playRecord((String)null, par3, par4, par5);
2068                    }
2069    
2070                    break;
2071                case 1007:
2072                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "mob.ghast.charge", 10.0F, (var7.nextFloat() - var7.nextFloat()) * 0.2F + 1.0F);
2073                    break;
2074                case 1008:
2075                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "mob.ghast.fireball", 10.0F, (var7.nextFloat() - var7.nextFloat()) * 0.2F + 1.0F);
2076                    break;
2077                case 1010:
2078                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "mob.zombie.wood", 2.0F, (var7.nextFloat() - var7.nextFloat()) * 0.2F + 1.0F);
2079                    break;
2080                case 1011:
2081                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "mob.zombie.metal", 2.0F, (var7.nextFloat() - var7.nextFloat()) * 0.2F + 1.0F);
2082                    break;
2083                case 1012:
2084                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "mob.zombie.woodbreak", 2.0F, (var7.nextFloat() - var7.nextFloat()) * 0.2F + 1.0F);
2085                    break;
2086                case 2000:
2087                    int var33 = par6 % 3 - 1;
2088                    int var9 = par6 / 3 % 3 - 1;
2089                    var10 = (double)par3 + (double)var33 * 0.6D + 0.5D;
2090                    var12 = (double)par4 + 0.5D;
2091                    double var34 = (double)par5 + (double)var9 * 0.6D + 0.5D;
2092    
2093                    for (int var35 = 0; var35 < 10; ++var35)
2094                    {
2095                        double var37 = var7.nextDouble() * 0.2D + 0.01D;
2096                        double var38 = var10 + (double)var33 * 0.01D + (var7.nextDouble() - 0.5D) * (double)var9 * 0.5D;
2097                        var39 = var12 + (var7.nextDouble() - 0.5D) * 0.5D;
2098                        var23 = var34 + (double)var9 * 0.01D + (var7.nextDouble() - 0.5D) * (double)var33 * 0.5D;
2099                        var25 = (double)var33 * var37 + var7.nextGaussian() * 0.01D;
2100                        var27 = -0.03D + var7.nextGaussian() * 0.01D;
2101                        var29 = (double)var9 * var37 + var7.nextGaussian() * 0.01D;
2102                        this.spawnParticle("smoke", var38, var39, var23, var25, var27, var29);
2103                    }
2104    
2105                    return;
2106                case 2001:
2107                    var20 = par6 & 4095;
2108    
2109                    if (var20 > 0)
2110                    {
2111                        Block var40 = Block.blocksList[var20];
2112                        this.mc.sndManager.playSound(var40.stepSound.getBreakSound(), (float)par3 + 0.5F, (float)par4 + 0.5F, (float)par5 + 0.5F, (var40.stepSound.getVolume() + 1.0F) / 2.0F, var40.stepSound.getPitch() * 0.8F);
2113                    }
2114    
2115                    this.mc.effectRenderer.addBlockDestroyEffects(par3, par4, par5, par6 & 4095, par6 >> 12 & 255);
2116                    break;
2117                case 2002:
2118                    var8 = (double)par3;
2119                    var10 = (double)par4;
2120                    var12 = (double)par5;
2121                    var14 = "iconcrack_" + Item.potion.shiftedIndex;
2122    
2123                    for (var15 = 0; var15 < 8; ++var15)
2124                    {
2125                        this.spawnParticle(var14, var8, var10, var12, var7.nextGaussian() * 0.15D, var7.nextDouble() * 0.2D, var7.nextGaussian() * 0.15D);
2126                    }
2127    
2128                    var15 = Item.potion.getColorFromDamage(par6, 0);
2129                    float var16 = (float)(var15 >> 16 & 255) / 255.0F;
2130                    float var17 = (float)(var15 >> 8 & 255) / 255.0F;
2131                    float var18 = (float)(var15 >> 0 & 255) / 255.0F;
2132                    String var19 = "spell";
2133    
2134                    if (Item.potion.isEffectInstant(par6))
2135                    {
2136                        var19 = "instantSpell";
2137                    }
2138    
2139                    for (var20 = 0; var20 < 100; ++var20)
2140                    {
2141                        var39 = var7.nextDouble() * 4.0D;
2142                        var23 = var7.nextDouble() * Math.PI * 2.0D;
2143                        var25 = Math.cos(var23) * var39;
2144                        var27 = 0.01D + var7.nextDouble() * 0.5D;
2145                        var29 = Math.sin(var23) * var39;
2146                        EntityFX var31 = this.func_72726_b(var19, var8 + var25 * 0.1D, var10 + 0.3D, var12 + var29 * 0.1D, var25, var27, var29);
2147    
2148                        if (var31 != null)
2149                        {
2150                            float var32 = 0.75F + var7.nextFloat() * 0.25F;
2151                            var31.setRBGColorF(var16 * var32, var17 * var32, var18 * var32);
2152                            var31.multiplyVelocity((float)var39);
2153                        }
2154                    }
2155    
2156                    this.theWorld.playSound((double)par3 + 0.5D, (double)par4 + 0.5D, (double)par5 + 0.5D, "random.glass", 1.0F, this.theWorld.rand.nextFloat() * 0.1F + 0.9F);
2157                    break;
2158                case 2003:
2159                    var8 = (double)par3 + 0.5D;
2160                    var10 = (double)par4;
2161                    var12 = (double)par5 + 0.5D;
2162                    var14 = "iconcrack_" + Item.eyeOfEnder.shiftedIndex;
2163    
2164                    for (var15 = 0; var15 < 8; ++var15)
2165                    {
2166                        this.spawnParticle(var14, var8, var10, var12, var7.nextGaussian() * 0.15D, var7.nextDouble() * 0.2D, var7.nextGaussian() * 0.15D);
2167                    }
2168    
2169                    for (double var36 = 0.0D; var36 < (Math.PI * 2D); var36 += 0.15707963267948966D)
2170                    {
2171                        this.spawnParticle("portal", var8 + Math.cos(var36) * 5.0D, var10 - 0.4D, var12 + Math.sin(var36) * 5.0D, Math.cos(var36) * -5.0D, 0.0D, Math.sin(var36) * -5.0D);
2172                        this.spawnParticle("portal", var8 + Math.cos(var36) * 5.0D, var10 - 0.4D, var12 + Math.sin(var36) * 5.0D, Math.cos(var36) * -7.0D, 0.0D, Math.sin(var36) * -7.0D);
2173                    }
2174    
2175                    return;
2176                case 2004:
2177                    for (int var21 = 0; var21 < 20; ++var21)
2178                    {
2179                        double var22 = (double)par3 + 0.5D + ((double)this.theWorld.rand.nextFloat() - 0.5D) * 2.0D;
2180                        double var24 = (double)par4 + 0.5D + ((double)this.theWorld.rand.nextFloat() - 0.5D) * 2.0D;
2181                        double var26 = (double)par5 + 0.5D + ((double)this.theWorld.rand.nextFloat() - 0.5D) * 2.0D;
2182                        this.theWorld.spawnParticle("smoke", var22, var24, var26, 0.0D, 0.0D, 0.0D);
2183                        this.theWorld.spawnParticle("flame", var22, var24, var26, 0.0D, 0.0D, 0.0D);
2184                    }
2185            }
2186        }
2187    
2188        /**
2189         * Starts (or continues) destroying a block with given ID at the given coordinates for the given partially destroyed
2190         * value
2191         */
2192        public void destroyBlockPartially(int par1, int par2, int par3, int par4, int par5)
2193        {
2194            if (par5 >= 0 && par5 < 10)
2195            {
2196                DestroyBlockProgress var6 = (DestroyBlockProgress)this.field_72738_E.get(Integer.valueOf(par1));
2197    
2198                if (var6 == null || var6.func_73110_b() != par2 || var6.func_73109_c() != par3 || var6.func_73108_d() != par4)
2199                {
2200                    var6 = new DestroyBlockProgress(par1, par2, par3, par4);
2201                    this.field_72738_E.put(Integer.valueOf(par1), var6);
2202                }
2203    
2204                var6.func_73107_a(par5);
2205            }
2206            else
2207            {
2208                this.field_72738_E.remove(Integer.valueOf(par1));
2209            }
2210        }
2211    }